mips

Imports

Imports #

"cmd/internal/obj"
"cmd/internal/objabi"
"cmd/internal/sys"
"fmt"
"log"
"slices"
"cmd/internal/obj"
"fmt"
"cmd/internal/obj"
"cmd/internal/sys"
"encoding/binary"
"fmt"
"internal/abi"
"log"
"math"
"cmd/internal/obj"
"cmd/internal/obj"

Constants & Variables

AABSD const #

const AABSD = *ast.BinaryExpr

AABSF const #

const AABSF

AABSW const #

const AABSW

AADD const #

const AADD

AADDD const #

const AADDD

AADDF const #

const AADDF

AADDU const #

const AADDU

AADDV const #

const AADDV

AADDVU const #

const AADDVU

AADDW const #

const AADDW

AAND const #

const AAND

ABEQ const #

const ABEQ

ABFPF const #

const ABFPF

ABFPT const #

const ABFPT

ABGEZ const #

const ABGEZ

ABGEZAL const #

const ABGEZAL

ABGTZ const #

const ABGTZ

ABLEZ const #

const ABLEZ

ABLTZ const #

const ABLTZ

ABLTZAL const #

const ABLTZAL

ABNE const #

const ABNE

ABREAK const #

const ABREAK

ACLO const #

const ACLO

ACLZ const #

const ACLZ

ACMOVF const #

const ACMOVF

ACMOVN const #

const ACMOVN

ACMOVT const #

const ACMOVT

ACMOVZ const #

const ACMOVZ

ACMPEQD const #

const ACMPEQD

ACMPEQF const #

const ACMPEQF

ACMPGED const #

const ACMPGED

ACMPGEF const #

const ACMPGEF

ACMPGTD const #

const ACMPGTD

ACMPGTF const #

const ACMPGTF

ADIV const #

const ADIV

ADIVD const #

const ADIVD

ADIVF const #

const ADIVF

ADIVU const #

const ADIVU

ADIVV const #

const ADIVV

ADIVVU const #

const ADIVVU

ADIVW const #

const ADIVW

ADSBH const #

const ADSBH

ADSHD const #

const ADSHD

AGOK const #

const AGOK

AJAL const #

const AJAL = obj.ACALL

AJMP const #

aliases

const AJMP = obj.AJMP

ALAST const #

const ALAST

ALL const #

const ALL

ALLV const #

const ALLV

ALUI const #

const ALUI

AMADD const #

const AMADD

AMOVB const #

const AMOVB

AMOVBU const #

const AMOVBU

AMOVD const #

const AMOVD

AMOVDF const #

const AMOVDF

AMOVDV const #

const AMOVDV

AMOVDW const #

const AMOVDW

AMOVF const #

const AMOVF

AMOVFD const #

const AMOVFD

AMOVFV const #

const AMOVFV

AMOVFW const #

const AMOVFW

AMOVH const #

const AMOVH

AMOVHU const #

const AMOVHU

AMOVV const #

64-bit

const AMOVV

AMOVVD const #

const AMOVVD

AMOVVF const #

const AMOVVF

AMOVVL const #

const AMOVVL

AMOVVR const #

const AMOVVR

AMOVW const #

const AMOVW

AMOVWD const #

const AMOVWD

AMOVWF const #

const AMOVWF

AMOVWL const #

const AMOVWL

AMOVWR const #

const AMOVWR

AMOVWU const #

const AMOVWU

AMSUB const #

const AMSUB

AMUL const #

const AMUL

AMULD const #

const AMULD

AMULF const #

const AMULF

AMULU const #

const AMULU

AMULV const #

const AMULV

AMULVU const #

const AMULVU

AMULW const #

const AMULW

ANEGD const #

const ANEGD

ANEGF const #

const ANEGF

ANEGV const #

const ANEGV

ANEGW const #

const ANEGW

ANOOP const #

const ANOOP

ANOR const #

const ANOR

ANYMEM const #

const ANYMEM = *ast.BinaryExpr

AOR const #

const AOR

AREM const #

const AREM

AREMU const #

const AREMU

AREMV const #

const AREMV

AREMVU const #

const AREMVU

ARET const #

const ARET = obj.ARET

ARFE const #

const ARFE

AROTR const #

const AROTR

AROTRV const #

const AROTRV

ASC const #

const ASC

ASCV const #

const ASCV

ASEB const #

const ASEB

ASEH const #

const ASEH

ASGT const #

const ASGT

ASGTU const #

const ASGTU

ASLL const #

const ASLL

ASLLV const #

const ASLLV

ASQRTD const #

const ASQRTD

ASQRTF const #

const ASQRTF

ASRA const #

const ASRA

ASRAV const #

const ASRAV

ASRL const #

const ASRL

ASRLV const #

const ASRLV

ASUB const #

const ASUB

ASUBD const #

const ASUBD

ASUBF const #

const ASUBF

ASUBU const #

const ASUBU

ASUBV const #

const ASUBV

ASUBVU const #

const ASUBVU

ASUBW const #

const ASUBW

ASYNC const #

const ASYNC

ASYSCALL const #

const ASYSCALL

ATEQ const #

const ATEQ

ATLBP const #

const ATLBP

ATLBR const #

const ATLBR

ATLBWI const #

const ATLBWI

ATLBWR const #

const ATLBWR

ATNE const #

const ATNE

ATRUNCDV const #

const ATRUNCDV

ATRUNCDW const #

const ATRUNCDW

ATRUNCFV const #

64-bit FP

const ATRUNCFV

ATRUNCFW const #

const ATRUNCFW

AVMOVB const #

MSA

const AVMOVB

AVMOVD const #

const AVMOVD

AVMOVH const #

const AVMOVH

AVMOVW const #

const AVMOVW

AWORD const #

const AWORD

AWSBH const #

const AWSBH

AXOR const #

const AXOR

Anames var #

var Anames = []string{...}

BIG const #

const BIG = 32766

BRANCH const #

const BRANCH = *ast.BinaryExpr

C_ADD0CON const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_ADD0CON

C_ADDCON const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_ADDCON

C_ADDR const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_ADDR

C_AND0CON const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_AND0CON

C_ANDCON const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_ANDCON

C_DACON const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_DACON

C_DCON const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_DCON

C_FCREG const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_FCREG

C_FREG const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_FREG

C_GOK const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_GOK

C_HI const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_HI

C_LACON const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_LACON

C_LAUTO const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_LAUTO

C_LBRA const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_LBRA

C_LCON const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_LCON

C_LECON const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_LECON

C_LEXT const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_LEXT

C_LO const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_LO

C_LOREG const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_LOREG

C_MREG const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_MREG

C_NCLASS const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_NCLASS

C_NONE const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_NONE = iota

C_REG const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_REG

C_SACON const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_SACON

C_SAUTO const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_SAUTO

C_SBRA const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_SBRA

C_SCON const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_SCON

C_SECON const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_SECON

C_SEXT const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_SEXT

C_SOREG const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_SOREG

C_STCON const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_STCON

C_TEXTSIZE const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_TEXTSIZE

C_TLS const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_TLS

C_UCON const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_UCON

C_WREG const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_WREG

C_ZCON const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_ZCON

C_ZOREG const #

go:generate go run ../mkcnames.go -i a.out.go -o anames0.go -p mips

const C_ZOREG

DELAY const #

DELAY = LOAD|BRANCH|FCMP

const DELAY = BRANCH

E_FCR const #

const E_FCR = *ast.BinaryExpr

E_HILO const #

const E_HILO = *ast.BinaryExpr

E_MCR const #

const E_MCR = *ast.BinaryExpr

E_MEM const #

const E_MEM = *ast.BinaryExpr

E_MEMSB const #

const E_MEMSB = *ast.BinaryExpr

E_MEMSP const #

const E_MEMSP = *ast.BinaryExpr

FCMP const #

const FCMP = *ast.BinaryExpr

FOLL const #

mark flags

const FOLL = *ast.BinaryExpr

FREGRET const #

const FREGRET = REG_F0

LABEL const #

const LABEL = *ast.BinaryExpr

LEAF const #

const LEAF = *ast.BinaryExpr

LOAD const #

const LOAD = *ast.BinaryExpr

Linkmips var #

var Linkmips = obj.LinkArch{...}

Linkmips64 var #

var Linkmips64 = obj.LinkArch{...}

Linkmips64le var #

var Linkmips64le = obj.LinkArch{...}

Linkmipsle var #

var Linkmipsle = obj.LinkArch{...}

MIPSDWARFRegisters var #

https://llvm.org/svn/llvm-project/llvm/trunk/lib/Target/Mips/MipsRegisterInfo.td search for DwarfRegNum https://gcc.gnu.org/viewcvs/gcc/trunk/gcc/config/mips/mips.c?view=co&revision=258099&content-type=text%2Fplain search for mips_dwarf_regno For now, this is adequate for both 32 and 64 bit.

var MIPSDWARFRegisters = map[int16]int16{...}

NFREG const #

* mips 64

const NFREG = 32

NOSCHED const #

const NOSCHED = *ast.BinaryExpr

NOTUSETMP const #

Optab.flag

const NOTUSETMP = *ast.BinaryExpr

NREG const #

* mips 64

const NREG = 32

NSCHED const #

const NSCHED = 20

NSNAME const #

* mips 64

const NSNAME = 8

NSYM const #

* mips 64

const NSYM = 50

NWREG const #

* mips 64

const NWREG = 32

REGARG const #

const REGARG = *ast.UnaryExpr

REGCTXT const #

const REGCTXT = REG_R22

REGG const #

const REGG = REG_R30

REGLINK const #

const REGLINK = REG_R31

REGRET const #

const REGRET = REG_R1

REGRT1 const #

const REGRT1 = REG_R1

REGRT2 const #

const REGRT2 = REG_R2

REGSB const #

const REGSB = REG_R28

REGSP const #

const REGSP = REG_R29

REGTMP const #

const REGTMP = REG_R23

REGZERO const #

const REGZERO = REG_R0

REG_F0 const #

const REG_F0

REG_F1 const #

const REG_F1

REG_F10 const #

const REG_F10

REG_F11 const #

const REG_F11

REG_F12 const #

const REG_F12

REG_F13 const #

const REG_F13

REG_F14 const #

const REG_F14

REG_F15 const #

const REG_F15

REG_F16 const #

const REG_F16

REG_F17 const #

const REG_F17

REG_F18 const #

const REG_F18

REG_F19 const #

const REG_F19

REG_F2 const #

const REG_F2

REG_F20 const #

const REG_F20

REG_F21 const #

const REG_F21

REG_F22 const #

const REG_F22

REG_F23 const #

const REG_F23

REG_F24 const #

const REG_F24

REG_F25 const #

const REG_F25

REG_F26 const #

const REG_F26

REG_F27 const #

const REG_F27

REG_F28 const #

const REG_F28

REG_F29 const #

const REG_F29

REG_F3 const #

const REG_F3

REG_F30 const #

const REG_F30

REG_F31 const #

const REG_F31

REG_F4 const #

const REG_F4

REG_F5 const #

const REG_F5

REG_F6 const #

const REG_F6

REG_F7 const #

const REG_F7

REG_F8 const #

const REG_F8

REG_F9 const #

const REG_F9

REG_FCR0 const #

FPU control registers

const REG_FCR0

REG_FCR1 const #

const REG_FCR1

REG_FCR10 const #

const REG_FCR10

REG_FCR11 const #

const REG_FCR11

REG_FCR12 const #

const REG_FCR12

REG_FCR13 const #

const REG_FCR13

REG_FCR14 const #

const REG_FCR14

REG_FCR15 const #

const REG_FCR15

REG_FCR16 const #

const REG_FCR16

REG_FCR17 const #

const REG_FCR17

REG_FCR18 const #

const REG_FCR18

REG_FCR19 const #

const REG_FCR19

REG_FCR2 const #

const REG_FCR2

REG_FCR20 const #

const REG_FCR20

REG_FCR21 const #

const REG_FCR21

REG_FCR22 const #

const REG_FCR22

REG_FCR23 const #

const REG_FCR23

REG_FCR24 const #

const REG_FCR24

REG_FCR25 const #

const REG_FCR25

REG_FCR26 const #

const REG_FCR26

REG_FCR27 const #

const REG_FCR27

REG_FCR28 const #

const REG_FCR28

REG_FCR29 const #

const REG_FCR29

REG_FCR3 const #

const REG_FCR3

REG_FCR30 const #

const REG_FCR30

REG_FCR31 const #

const REG_FCR31

REG_FCR4 const #

const REG_FCR4

REG_FCR5 const #

const REG_FCR5

REG_FCR6 const #

const REG_FCR6

REG_FCR7 const #

const REG_FCR7

REG_FCR8 const #

const REG_FCR8

REG_FCR9 const #

const REG_FCR9

REG_HI const #

const REG_HI

REG_LAST const #

const REG_LAST = REG_LO

REG_LO const #

const REG_LO

REG_M0 const #

co-processor 0 control registers

const REG_M0

REG_M1 const #

const REG_M1

REG_M10 const #

const REG_M10

REG_M11 const #

const REG_M11

REG_M12 const #

const REG_M12

REG_M13 const #

const REG_M13

REG_M14 const #

const REG_M14

REG_M15 const #

const REG_M15

REG_M16 const #

const REG_M16

REG_M17 const #

const REG_M17

REG_M18 const #

const REG_M18

REG_M19 const #

const REG_M19

REG_M2 const #

const REG_M2

REG_M20 const #

const REG_M20

REG_M21 const #

const REG_M21

REG_M22 const #

const REG_M22

REG_M23 const #

const REG_M23

REG_M24 const #

const REG_M24

REG_M25 const #

const REG_M25

REG_M26 const #

const REG_M26

REG_M27 const #

const REG_M27

REG_M28 const #

const REG_M28

REG_M29 const #

const REG_M29

REG_M3 const #

const REG_M3

REG_M30 const #

const REG_M30

REG_M31 const #

const REG_M31

REG_M4 const #

const REG_M4

REG_M5 const #

const REG_M5

REG_M6 const #

const REG_M6

REG_M7 const #

const REG_M7

REG_M8 const #

const REG_M8

REG_M9 const #

const REG_M9

REG_R0 const #

const REG_R0 = *ast.BinaryExpr

REG_R1 const #

const REG_R1

REG_R10 const #

const REG_R10

REG_R11 const #

const REG_R11

REG_R12 const #

const REG_R12

REG_R13 const #

const REG_R13

REG_R14 const #

const REG_R14

REG_R15 const #

const REG_R15

REG_R16 const #

const REG_R16

REG_R17 const #

const REG_R17

REG_R18 const #

const REG_R18

REG_R19 const #

const REG_R19

REG_R2 const #

const REG_R2

REG_R20 const #

const REG_R20

REG_R21 const #

const REG_R21

REG_R22 const #

const REG_R22

REG_R23 const #

const REG_R23

REG_R24 const #

const REG_R24

REG_R25 const #

const REG_R25

REG_R26 const #

const REG_R26

REG_R27 const #

const REG_R27

REG_R28 const #

const REG_R28

REG_R29 const #

const REG_R29

REG_R3 const #

const REG_R3

REG_R30 const #

const REG_R30

REG_R31 const #

const REG_R31

REG_R4 const #

const REG_R4

REG_R5 const #

const REG_R5

REG_R6 const #

const REG_R6

REG_R7 const #

const REG_R7

REG_R8 const #

const REG_R8

REG_R9 const #

const REG_R9

REG_SPECIAL const #

const REG_SPECIAL = REG_M0

REG_W0 const #

MSA registers The lower bits of W registers are alias to F registers

const REG_W0

REG_W1 const #

const REG_W1

REG_W10 const #

const REG_W10

REG_W11 const #

const REG_W11

REG_W12 const #

const REG_W12

REG_W13 const #

const REG_W13

REG_W14 const #

const REG_W14

REG_W15 const #

const REG_W15

REG_W16 const #

const REG_W16

REG_W17 const #

const REG_W17

REG_W18 const #

const REG_W18

REG_W19 const #

const REG_W19

REG_W2 const #

const REG_W2

REG_W20 const #

const REG_W20

REG_W21 const #

const REG_W21

REG_W22 const #

const REG_W22

REG_W23 const #

const REG_W23

REG_W24 const #

const REG_W24

REG_W25 const #

const REG_W25

REG_W26 const #

const REG_W26

REG_W27 const #

const REG_W27

REG_W28 const #

const REG_W28

REG_W29 const #

const REG_W29

REG_W3 const #

const REG_W3

REG_W30 const #

const REG_W30

REG_W31 const #

const REG_W31

REG_W4 const #

const REG_W4

REG_W5 const #

const REG_W5

REG_W6 const #

const REG_W6

REG_W7 const #

const REG_W7

REG_W8 const #

const REG_W8

REG_W9 const #

const REG_W9

SYNC const #

const SYNC = *ast.BinaryExpr

cnames0 var #

This order should be strictly consistent to that in a.out.go.

var cnames0 = []string{...}

mips64FuncAlign const #

const mips64FuncAlign = 8

oprange var #

var oprange [*ast.BinaryExpr][]Optab

optab var #

var optab = []Optab{...}

r0iszero const #

const r0iszero = 1

xcmp var #

var xcmp [C_NCLASS][C_NCLASS]bool

Structs

Dep struct #

type Dep struct {
ireg uint32
freg uint32
cc uint32
}

Optab struct #

type Optab struct {
as obj.As
a1 uint8
a2 uint8
a3 uint8
type_ int8
size int8
param int16
family sys.ArchFamily
flag uint8
}

Sch struct #

type Sch struct {
p obj.Prog
set Dep
used Dep
soffset int32
size uint8
nop uint8
comp bool
}

ctxt0 struct #

ctxt0 holds state while assembling a single function. Each function gets a fresh ctxt0. This allows for multiple functions to be safely concurrently assembled.

type ctxt0 struct {
ctxt *obj.Link
newprog obj.ProgAlloc
cursym *obj.LSym
autosize int32
instoffset int64
pc int64
}

Functions

BCOND function #

func BCOND(x uint32, y uint32) uint32

DRconv function #

func DRconv(a int) string

FPD function #

func FPD(x uint32, y uint32) uint32

FPF function #

func FPF(x uint32, y uint32) uint32

FPV function #

func FPV(x uint32, y uint32) uint32

FPW function #

func FPW(x uint32, y uint32) uint32

MMU function #

func MMU(x uint32, y uint32) uint32

OP function #

func OP(x uint32, y uint32) uint32

OP_FRRR function #

func OP_FRRR(op uint32, r1 int16, r2 int16, r3 int16) uint32

OP_IRR function #

func OP_IRR(op uint32, i uint32, r2 int16, r3 int16) uint32

OP_JMP function #

func OP_JMP(op uint32, i uint32) uint32

OP_RRR function #

func OP_RRR(op uint32, r1 int16, r2 int16, r3 int16) uint32

OP_SRR function #

func OP_SRR(op uint32, s uint32, r2 int16, r3 int16) uint32

OP_VI10 function #

func OP_VI10(op uint32, df uint32, s10 int32, wd uint32, minor uint32) uint32

OP_VMI10 function #

func OP_VMI10(s10 int32, rs uint32, wd uint32, minor uint32, df uint32) uint32

SP function #

func SP(x uint32, y uint32) uint32

aclass method #

func (c *ctxt0) aclass(a *obj.Addr) int

addnop method #

func (c *ctxt0) addnop(p *obj.Prog)

asmout method #

func (c *ctxt0) asmout(p *obj.Prog, o *Optab, out []uint32)

buildop function #

func buildop(ctxt *obj.Link)

cmp function #

func cmp(a int, b int) bool

compound method #

func (c *ctxt0) compound(p *obj.Prog) bool

conflict function #

* test 2 adjacent instructions * and find out if inserted instructions * are desired to prevent stalls.

func conflict(sa *Sch, sb *Sch) bool

depend method #

* test to see if two instructions can be * interchanged without changing semantics

func (c *ctxt0) depend(sa *Sch, sb *Sch) bool

init function #

func init()

init function #

func init()

init function #

func init()

isRestartable method #

isRestartable returns whether p is a multi-instruction sequence that, if preempted, can be restarted.

func (c *ctxt0) isRestartable(p *obj.Prog) bool

isUnsafePoint method #

isUnsafePoint returns whether p is an unsafe point.

func (c *ctxt0) isUnsafePoint(p *obj.Prog) bool

isint32 function #

func isint32(v int64) bool

isuint32 function #

func isuint32(v uint64) bool

lsoffset method #

MSA Load/Store offset have to be multiple of size of data format

func (c *ctxt0) lsoffset(a obj.As, o int32) int32

markregused method #

func (c *ctxt0) markregused(s *Sch)

ocmp function #

func ocmp(p1 Optab, p2 Optab) int

offoverlap function #

func offoverlap(sa *Sch, sb *Sch) bool

opirr method #

func (c *ctxt0) opirr(a obj.As) uint32

oplook method #

func (c *ctxt0) oplook(p *obj.Prog) *Optab

oprrr method #

func (c *ctxt0) oprrr(a obj.As) uint32

opset function #

func opset(a obj.As, b0 obj.As)

prasm function #

func prasm(p *obj.Prog)

preprocess function #

func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc)

progedit function #

func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc)

rconv function #

func rconv(r int) string

regoff method #

func (c *ctxt0) regoff(a *obj.Addr) int32

sched method #

func (c *ctxt0) sched(p0 *obj.Prog, pe *obj.Prog)

span0 function #

func span0(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc)

stacksplit method #

func (c *ctxt0) stacksplit(p *obj.Prog, framesize int32) *obj.Prog

twobitdf method #

MSA Two-bit Data Format Field Encoding

func (c *ctxt0) twobitdf(a obj.As) uint32

vregoff method #

func (c *ctxt0) vregoff(a *obj.Addr) int64

vshift function #

func vshift(a obj.As) bool

Generated with Arrow