amd64

Imports

Imports # 

"fmt"
"internal/buildcfg"
"math"
"cmd/compile/internal/base"
"cmd/compile/internal/ir"
"cmd/compile/internal/logopt"
"cmd/compile/internal/objw"
"cmd/compile/internal/ssa"
"cmd/compile/internal/ssagen"
"cmd/compile/internal/types"
"cmd/internal/obj"
"cmd/internal/obj/x86"
"cmd/compile/internal/ssagen"
"cmd/internal/obj/x86"
"cmd/compile/internal/ir"
"cmd/compile/internal/objw"
"cmd/compile/internal/types"
"cmd/internal/obj"
"cmd/internal/obj/x86"
"internal/buildcfg"

Constants & Variables

blockJump var # 

var blockJump = [...]struct{...}{...}

dzBlockLen const #

DUFFZERO consists of repeated blocks of 4 MOVUPSs + LEAQ, See runtime/mkduff.go.

const dzBlockLen = 4

dzBlockSize const #

DUFFZERO consists of repeated blocks of 4 MOVUPSs + LEAQ, See runtime/mkduff.go.

const dzBlockSize = 23

dzBlocks const #

DUFFZERO consists of repeated blocks of 4 MOVUPSs + LEAQ, See runtime/mkduff.go.

const dzBlocks = 16

dzClearLen const #

DUFFZERO consists of repeated blocks of 4 MOVUPSs + LEAQ, See runtime/mkduff.go.

const dzClearLen = *ast.BinaryExpr

dzClearStep const #

DUFFZERO consists of repeated blocks of 4 MOVUPSs + LEAQ, See runtime/mkduff.go.

const dzClearStep = 16

dzLeaqSize const #

DUFFZERO consists of repeated blocks of 4 MOVUPSs + LEAQ, See runtime/mkduff.go.

const dzLeaqSize = 4

dzMovSize const #

DUFFZERO consists of repeated blocks of 4 MOVUPSs + LEAQ, See runtime/mkduff.go.

const dzMovSize = 5

dzSize const #

DUFFZERO consists of repeated blocks of 4 MOVUPSs + LEAQ, See runtime/mkduff.go.

const dzSize = *ast.BinaryExpr

eqfJumps var # 

var eqfJumps = [2][2]ssagen.IndexJump{...}

isPlan9 var #

no floating point in note handlers on Plan 9

var isPlan9 = *ast.BinaryExpr

leaptr var # 

var leaptr = x86.ALEAQ

nefJumps var # 

var nefJumps = [2][2]ssagen.IndexJump{...}

Functions

Init function # 

func Init(arch *ssagen.ArchInfo)

duff function #

duff returns the offset (from duffzero, in bytes) and pointer adjust (in bytes) required to use the duffzero mechanism for a block of the given size.

func duff(size int64) (int64, int64)

duffAdj function # 

func duffAdj(size int64) int64

duffStart function #

DUFFZERO consists of repeated blocks of 4 MOVUPSs + LEAQ, See runtime/mkduff.go.

func duffStart(size int64) int64

dzDI function #

duffzeroDI returns the pre-adjustment to DI for a call to DUFFZERO. b is the number of bytes to zero.

func dzDI(b int64) int64

dzOff function #

dzOff returns the offset for a jump into DUFFZERO. b is the number of bytes to zero.

func dzOff(b int64) int64

getgFromTLS function # 

func getgFromTLS(s *ssagen.State, r int16)

ginsnop function # 

func ginsnop(pp *objw.Progs) *obj.Prog

loadByType function #

loadByType returns the load instruction of the given type.

func loadByType(t *types.Type) obj.As

loadRegResult function # 

func loadRegResult(s *ssagen.State, f *ssa.Func, t *types.Type, reg int16, n *ir.Name, off int64) *obj.Prog

memIdx function #

memIdx fills out a as an indexed memory reference for v. It assumes that the base register and the index register are v.Args[0].Reg() and v.Args[1].Reg(), respectively. The caller must still use gc.AddAux/gc.AddAux2 to handle v.Aux as necessary.

func memIdx(a *obj.Addr, v *ssa.Value)

moveByType function #

moveByType returns the reg->reg move instruction of the given type.

func moveByType(t *types.Type) obj.As

opregreg function #

opregreg emits instructions for dest := dest(To) op src(From) and also returns the created obj.Prog so it may be further adjusted (offset, scale, etc).

func opregreg(s *ssagen.State, op obj.As, dest int16, src int16) *obj.Prog

spillArgReg function # 

func spillArgReg(pp *objw.Progs, p *obj.Prog, f *ssa.Func, t *types.Type, reg int16, n *ir.Name, off int64) *obj.Prog

ssaGenBlock function # 

func ssaGenBlock(s *ssagen.State, b *ssa.Block, next *ssa.Block)

ssaGenValue function # 

func ssaGenValue(s *ssagen.State, v *ssa.Value)

ssaMarkMoves function #

ssaMarkMoves marks any MOVXconst ops that need to avoid clobbering flags.

func ssaMarkMoves(s *ssagen.State, b *ssa.Block)

storeByType function #

storeByType returns the store instruction of the given type.

func storeByType(t *types.Type) obj.As

zerorange function # 

func zerorange(pp *objw.Progs, p *obj.Prog, off int64, cnt int64, state *uint32) *obj.Prog

Generated with Arrow