arch

Imports

Imports #

"cmd/internal/obj/s390x"
"cmd/internal/obj"
"cmd/internal/obj/arm"
"cmd/internal/obj/arm64"
"cmd/internal/obj/loong64"
"cmd/internal/obj/mips"
"cmd/internal/obj/ppc64"
"cmd/internal/obj/riscv"
"cmd/internal/obj/s390x"
"cmd/internal/obj/wasm"
"cmd/internal/obj/x86"
"fmt"
"strings"
"strings"
"cmd/internal/obj"
"cmd/internal/obj/arm"
"cmd/internal/obj"
"cmd/internal/obj/arm64"
"errors"
"cmd/internal/obj"
"cmd/internal/obj/loong64"
"errors"
"fmt"
"cmd/internal/obj"
"cmd/internal/obj/mips"
"cmd/internal/obj"
"cmd/internal/obj/ppc64"
"cmd/internal/obj"
"cmd/internal/obj/riscv"

Constants & Variables

RFP const #

Pseudo-registers whose names are the constant name without the leading R.

const RFP = *ast.UnaryExpr

RPC const #

Pseudo-registers whose names are the constant name without the leading R.

const RPC

RSB const #

Pseudo-registers whose names are the constant name without the leading R.

const RSB

RSP const #

Pseudo-registers whose names are the constant name without the leading R.

const RSP

aMCR const #

MCR is not defined by the obj/arm; instead we define it privately here. It is encoded as an MRC with a bit inside the instruction word, passed to arch.ARMMRCOffset.

const aMCR = *ast.BinaryExpr

arm64Jump var #

var arm64Jump = map[string]bool{...}

arm64LS var #

var arm64LS = map[string]uint8{...}

arm64SpecialOperand var #

var arm64SpecialOperand map[string]arm64.SpecialOperand

armJump var #

var armJump = map[string]bool{...}

armLS var #

var armLS = map[string]uint8{...}

armSCOND var #

var armSCOND = map[string]uint8{...}

bcode var #

var bcode = []obj.As{...}

loong64ElemExtMap var #

var loong64ElemExtMap = map[string]int16{...}

loong64LasxArngExtMap var #

var loong64LasxArngExtMap = map[string]int16{...}

loong64LsxArngExtMap var #

var loong64LsxArngExtMap = map[string]int16{...}

Structs

Arch struct #

Arch wraps the link architecture object with more architecture-specific information.

type Arch struct {
*obj.LinkArch
Instructions map[string]obj.As
Register map[string]int16
RegisterPrefix map[string]bool
RegisterNumber func(string, int16) (int16, bool)
IsJump func(word string) bool
}

Functions

ARM64RegisterArrangement function #

ARM64RegisterArrangement constructs an ARM64 vector register arrangement.

func ARM64RegisterArrangement(reg int16, name string, arng string) (int64, error)

ARM64RegisterExtension function #

ARM64RegisterExtension constructs an ARM64 register with extension or arrangement.

func ARM64RegisterExtension(a *obj.Addr, ext string, reg int16, num int16, isAmount bool, isIndex bool) error

ARM64RegisterListOffset function #

ARM64RegisterListOffset generates offset encoding according to AArch64 specification.

func ARM64RegisterListOffset(firstReg int, regCnt int, arrangement int64) (int64, error)

ARM64RegisterShift function #

ARM64RegisterShift constructs an ARM64 register with shift operation.

func ARM64RegisterShift(reg int16, op int16, count int16) (int64, error)

ARM64Suffix function #

ARM64Suffix handles the special suffix for the ARM64. It returns a boolean to indicate success; failure means cond was unrecognized.

func ARM64Suffix(prog *obj.Prog, cond string) bool

ARMConditionCodes function #

ARMConditionCodes handles the special condition code situation for the ARM. It returns a boolean to indicate success; failure means cond was unrecognized.

func ARMConditionCodes(prog *obj.Prog, cond string) bool

ARMMRCOffset function #

ARMMRCOffset implements the peculiar encoding of the MRC and MCR instructions. The difference between MRC and MCR is represented by a bit high in the word, not in the usual way by the opcode itself. Asm must use AMRC for both instructions, so we return the opcode for MRC so that asm doesn't need to import obj/arm.

func ARMMRCOffset(op obj.As, cond string, x0 int64, x1 int64, x2 int64, x3 int64, x4 int64, x5 int64) (offset int64, op0 obj.As, ok bool)

GetARM64SpecialOperand function #

GetARM64SpecialOperand returns the internal representation of a special operand.

func GetARM64SpecialOperand(name string) arm64.SpecialOperand

IsARM64ADR function #

IsARM64ADR reports whether the op (as defined by an arm64.A* constant) is one of the comparison instructions that require special handling.

func IsARM64ADR(op obj.As) bool

IsARM64CASP function #

IsARM64CASP reports whether the op (as defined by an arm64.A* constant) is one of the CASP-like instructions, and its 2nd destination is a register pair that require special handling.

func IsARM64CASP(op obj.As) bool

IsARM64CMP function #

IsARM64CMP reports whether the op (as defined by an arm64.A* constant) is one of the comparison instructions that require special handling.

func IsARM64CMP(op obj.As) bool

IsARM64STLXR function #

IsARM64STLXR reports whether the op (as defined by an arm64.A* constant) is one of the STLXR-like instructions that require special handling.

func IsARM64STLXR(op obj.As) bool

IsARM64TBL function #

IsARM64TBL reports whether the op (as defined by an arm64.A* constant) is one of the TBL-like instructions and one of its inputs does not fit into prog.Reg, so require special handling.

func IsARM64TBL(op obj.As) bool

IsARMBFX function #

IsARMBFX reports whether the op (as defined by an arm.A* constant) is one the BFX-like instructions which are in the form of "op $width, $LSB, (Reg,) Reg".

func IsARMBFX(op obj.As) bool

IsARMCMP function #

IsARMCMP reports whether the op (as defined by an arm.A* constant) is one of the comparison instructions that require special handling.

func IsARMCMP(op obj.As) bool

IsARMFloatCmp function #

IsARMFloatCmp reports whether the op is a floating comparison instruction.

func IsARMFloatCmp(op obj.As) bool

IsARMMRC function #

IsARMMRC reports whether the op (as defined by an arm.A* constant) is MRC or MCR.

func IsARMMRC(op obj.As) bool

IsARMMULA function #

IsARMMULA reports whether the op (as defined by an arm.A* constant) is MULA, MULS, MMULA, MMULS, MULABB, MULAWB or MULAWT, the 4-operand instructions.

func IsARMMULA(op obj.As) bool

IsARMSTREX function #

IsARMSTREX reports whether the op (as defined by an arm.A* constant) is one of the STREX-like instructions that require special handling.

func IsARMSTREX(op obj.As) bool

IsLoong64AMO function #

func IsLoong64AMO(op obj.As) bool

IsLoong64MUL function #

IsLoong64MUL reports whether the op (as defined by an loong64.A* constant) is one of the MUL/DIV/REM instructions that require special handling.

func IsLoong64MUL(op obj.As) bool

IsLoong64RDTIME function #

IsLoong64RDTIME reports whether the op (as defined by an loong64.A* constant) is one of the RDTIMELW/RDTIMEHW/RDTIMED instructions that require special handling.

func IsLoong64RDTIME(op obj.As) bool

IsMIPSCMP function #

IsMIPSCMP reports whether the op (as defined by an mips.A* constant) is one of the CMP instructions that require special handling.

func IsMIPSCMP(op obj.As) bool

IsMIPSMUL function #

IsMIPSMUL reports whether the op (as defined by an mips.A* constant) is one of the MUL/DIV/REM/MADD/MSUB instructions that require special handling.

func IsMIPSMUL(op obj.As) bool

IsPPC64CMP function #

IsPPC64CMP reports whether the op (as defined by an ppc64.A* constant) is one of the CMP instructions that require special handling.

func IsPPC64CMP(op obj.As) bool

IsPPC64NEG function #

IsPPC64NEG reports whether the op (as defined by an ppc64.A* constant) is one of the NEG-like instructions that require special handling.

func IsPPC64NEG(op obj.As) bool

IsRISCV64AMO function #

IsRISCV64AMO reports whether the op (as defined by a riscv.A* constant) is one of the AMO instructions that requires special handling.

func IsRISCV64AMO(op obj.As) bool

Loong64RegisterExtension function #

Loong64RegisterExtension constructs an Loong64 register with extension or arrangement.

func Loong64RegisterExtension(a *obj.Addr, ext string, reg int16, num int16, isAmount bool, isIndex bool) error

ParseARMCondition function #

ParseARMCondition parses the conditions attached to an ARM instruction. The input is a single string consisting of period-separated condition codes, such as ".P.W". An initial period is ignored.

func ParseARMCondition(cond string) (uint8, bool)

Set function #

Set configures the architecture specified by GOARCH and returns its representation. It returns nil if GOARCH is not recognized.

func Set(GOARCH string, shared bool) *Arch

archArm function #

func archArm() *Arch

archArm64 function #

func archArm64() *Arch

archLoong64 function #

func archLoong64(linkArch *obj.LinkArch) *Arch

archMips function #

func archMips(linkArch *obj.LinkArch) *Arch

archMips64 function #

func archMips64(linkArch *obj.LinkArch) *Arch

archPPC64 function #

func archPPC64(linkArch *obj.LinkArch) *Arch

archRISCV64 function #

func archRISCV64(shared bool) *Arch

archS390x function #

func archS390x() *Arch

archWasm function #

func archWasm() *Arch

archX86 function #

func archX86(linkArch *obj.LinkArch) *Arch

arm64RegisterNumber function #

func arm64RegisterNumber(name string, n int16) (int16, bool)

armRegisterNumber function #

func armRegisterNumber(name string, n int16) (int16, bool)

jumpArm function #

func jumpArm(word string) bool

jumpArm64 function #

func jumpArm64(word string) bool

jumpLoong64 function #

func jumpLoong64(word string) bool

jumpMIPS function #

func jumpMIPS(word string) bool

jumpPPC64 function #

func jumpPPC64(word string) bool

jumpRISCV function #

func jumpRISCV(word string) bool

jumpS390x function #

func jumpS390x(word string) bool

jumpWasm function #

func jumpWasm(word string) bool

jumpX86 function #

func jumpX86(word string) bool

loong64RegisterNumber function #

func loong64RegisterNumber(name string, n int16) (int16, bool)

mipsRegisterNumber function #

func mipsRegisterNumber(name string, n int16) (int16, bool)

nilRegisterNumber function #

nilRegisterNumber is the register number function for architectures that do not accept the R(N) notation. It always returns failure.

func nilRegisterNumber(name string, n int16) (int16, bool)

parseARM64Suffix function #

parseARM64Suffix parses the suffix attached to an ARM64 instruction. The input is a single string consisting of period-separated condition codes, such as ".P.W". An initial period is ignored.

func parseARM64Suffix(cond string) (uint8, bool)

parseARMCondition function #

func parseARMCondition(cond string, ls map[string]uint8, scond map[string]uint8) (uint8, bool)

ppc64RegisterNumber function #

func ppc64RegisterNumber(name string, n int16) (int16, bool)

s390xRegisterNumber function #

func s390xRegisterNumber(name string, n int16) (int16, bool)

Generated with Arrow