From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001
From: upstream source tree <ports@midipix.org>
Date: Sun, 15 Mar 2015 20:14:05 -0400
Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified
 gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream
 tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.
---
 libgo/go/exp/ogle/arch.go | 125 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 125 insertions(+)
 create mode 100644 libgo/go/exp/ogle/arch.go

(limited to 'libgo/go/exp/ogle/arch.go')

diff --git a/libgo/go/exp/ogle/arch.go b/libgo/go/exp/ogle/arch.go
new file mode 100644
index 000000000..52b1c9757
--- /dev/null
+++ b/libgo/go/exp/ogle/arch.go
@@ -0,0 +1,125 @@
+// Copyright 2009 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ogle
+
+import (
+	"debug/proc"
+	"math"
+)
+
+type Arch interface {
+	// ToWord converts an array of up to 8 bytes in memory order
+	// to a word.
+	ToWord(data []byte) proc.Word
+	// FromWord converts a word to an array of up to 8 bytes in
+	// memory order.
+	FromWord(v proc.Word, out []byte)
+	// ToFloat32 converts a word to a float.  The order of this
+	// word will be the order returned by ToWord on the memory
+	// representation of a float, and thus may require reversing.
+	ToFloat32(bits uint32) float32
+	// FromFloat32 converts a float to a word.  This should return
+	// a word that can be passed to FromWord to get the memory
+	// representation of a float on this architecture.
+	FromFloat32(f float32) uint32
+	// ToFloat64 is to float64 as ToFloat32 is to float32.
+	ToFloat64(bits uint64) float64
+	// FromFloat64 is to float64 as FromFloat32 is to float32.
+	FromFloat64(f float64) uint64
+
+	// IntSize returns the number of bytes in an 'int'.
+	IntSize() int
+	// PtrSize returns the number of bytes in a 'uintptr'.
+	PtrSize() int
+	// FloatSize returns the number of bytes in a 'float'.
+	FloatSize() int
+	// Align rounds offset up to the appropriate offset for a
+	// basic type with the given width.
+	Align(offset, width int) int
+
+	// G returns the current G pointer.
+	G(regs proc.Regs) proc.Word
+
+	// ClosureSize returns the number of bytes expected by
+	// ParseClosure.
+	ClosureSize() int
+	// ParseClosure takes ClosureSize bytes read from a return PC
+	// in a remote process, determines if the code is a closure,
+	// and returns the frame size of the closure if it is.
+	ParseClosure(data []byte) (frame int, ok bool)
+}
+
+type ArchLSB struct{}
+
+func (ArchLSB) ToWord(data []byte) proc.Word {
+	var v proc.Word
+	for i, b := range data {
+		v |= proc.Word(b) << (uint(i) * 8)
+	}
+	return v
+}
+
+func (ArchLSB) FromWord(v proc.Word, out []byte) {
+	for i := range out {
+		out[i] = byte(v)
+		v >>= 8
+	}
+}
+
+func (ArchLSB) ToFloat32(bits uint32) float32 {
+	// TODO(austin) Do these definitions depend on my current
+	// architecture?
+	return math.Float32frombits(bits)
+}
+
+func (ArchLSB) FromFloat32(f float32) uint32 { return math.Float32bits(f) }
+
+func (ArchLSB) ToFloat64(bits uint64) float64 { return math.Float64frombits(bits) }
+
+func (ArchLSB) FromFloat64(f float64) uint64 { return math.Float64bits(f) }
+
+type ArchAlignedMultiple struct{}
+
+func (ArchAlignedMultiple) Align(offset, width int) int {
+	return ((offset - 1) | (width - 1)) + 1
+}
+
+type amd64 struct {
+	ArchLSB
+	ArchAlignedMultiple
+	gReg int
+}
+
+func (a *amd64) IntSize() int { return 4 }
+
+func (a *amd64) PtrSize() int { return 8 }
+
+func (a *amd64) FloatSize() int { return 4 }
+
+func (a *amd64) G(regs proc.Regs) proc.Word {
+	// See src/pkg/runtime/mkasmh
+	if a.gReg == -1 {
+		ns := regs.Names()
+		for i, n := range ns {
+			if n == "r15" {
+				a.gReg = i
+				break
+			}
+		}
+	}
+
+	return regs.Get(a.gReg)
+}
+
+func (a *amd64) ClosureSize() int { return 8 }
+
+func (a *amd64) ParseClosure(data []byte) (int, bool) {
+	if data[0] == 0x48 && data[1] == 0x81 && data[2] == 0xc4 && data[7] == 0xc3 {
+		return int(a.ToWord(data[3:7]) + 8), true
+	}
+	return 0, false
+}
+
+var Amd64 = &amd64{gReg: -1}
-- 
cgit v1.2.3