go/src/cmd/internal/obj/util.go

const REG_NONE

// Line returns a string containing the filename and line number for p
func (p *Prog) Line() string {}

func (p *Prog) InnermostLine(w io.Writer) {}

// InnermostLineNumber returns a string containing the line number for the
// innermost inlined function (if any inlining) at p's position
func (p *Prog) InnermostLineNumber() string {}

// InnermostLineNumberHTML returns a string containing the line number for the
// innermost inlined function (if any inlining) at p's position
func (p *Prog) InnermostLineNumberHTML() string {}

// InnermostFilename returns a string containing the innermost
// (in inlining) filename at p's position
func (p *Prog) InnermostFilename() string {}

var armCondCode

const C_SCOND

const C_SBIT

const C_PBIT

const C_WBIT

const C_FBIT

const C_UBIT

const C_SCOND_XOR

// CConv formats opcode suffix bits (Prog.Scond).
func CConv(s uint8) string {}

// CConvARM formats ARM opcode suffix bits (mostly condition codes).
func CConvARM(s uint8) string {}

func (p *Prog) String() string {}

func (p *Prog) InnermostString(w io.Writer) {}

// InstructionString returns a string representation of the instruction without preceding
// program counter or file and line number.
func (p *Prog) InstructionString() string {}

// WriteInstructionString writes a string representation of the instruction without preceding
// program counter or file and line number.
func (p *Prog) WriteInstructionString(w io.Writer) {}

func (ctxt *Link) NewProg() *Prog {}

func (ctxt *Link) CanReuseProgs() bool {}

// Dconv accepts an argument 'a' within a prog 'p' and returns a string
// with a formatted version of the argument.
func Dconv(p *Prog, a *Addr) string {}

// DconvWithABIDetail accepts an argument 'a' within a prog 'p'
// and returns a string with a formatted version of the argument, in
// which text symbols are rendered with explicit ABI selectors.
func DconvWithABIDetail(p *Prog, a *Addr) string {}

// WriteDconv accepts an argument 'a' within a prog 'p'
// and writes a formatted version of the arg to the writer.
func WriteDconv(w io.Writer, p *Prog, a *Addr) {}

func writeDconv(w io.Writer, p *Prog, a *Addr, abiDetail bool) {}

func (a *Addr) WriteNameTo(w io.Writer) {}

func (a *Addr) writeNameTo(w io.Writer, abiDetail bool) {}

func offConv(off int64) string {}

type opSuffixSet

var opSuffixSpace

// RegisterOpSuffix assigns cconv function for formatting opcode suffixes
// when compiling for GOARCH=arch.
//
// cconv is never called with 0 argument.
func RegisterOpSuffix(arch string, cconv func(uint8) string) {}

type regSet

var regSpace

const RBase386

const RBaseAMD64

const RBaseARM

const RBasePPC64

const RBaseARM64

const RBaseMIPS

const RBaseS390X

const RBaseRISCV

const RBaseWasm

const RBaseLOONG64

// RegisterRegister binds a pretty-printer (Rconv) for register
// numbers to a given register number range. Lo is inclusive,
// hi exclusive (valid registers are lo through hi-1).
func RegisterRegister(lo, hi int, Rconv func(int) string) {}

func Rconv(reg int) string {}

type regListSet

var regListSpace

const RegListARMLo

const RegListARMHi

const RegListARM64Lo

const RegListARM64Hi

const RegListX86Lo

const RegListX86Hi

// RegisterRegisterList binds a pretty-printer (RLconv) for register list
// numbers to a given register list number range. Lo is inclusive,
// hi exclusive (valid register list are lo through hi-1).
func RegisterRegisterList(lo, hi int64, rlconv func(int64) string) {}

func RLconv(list int64) string {}

type spcSet

var spcSpace

// RegisterSpecialOperands binds a pretty-printer (SPCconv) for special
// operand numbers to a given special operand number range. Lo is inclusive,
// hi is exclusive (valid special operands are lo through hi-1).
func RegisterSpecialOperands(lo, hi int64, rlconv func(int64) string) {}

// SPCconv returns the string representation of the special operand spc.
func SPCconv(spc int64) string {}

type opSet

var aSpace

// RegisterOpcode binds a list of instruction names
// to a given instruction number range.
func RegisterOpcode(lo As, Anames []string) {}

func (a As) String() string {}

var Anames

func Bool2int(b bool) int {}

func abiDecorate(a *Addr, abiDetail bool) string {}

// AlignmentPadding bytes to add to align code as requested.
// Alignment is restricted to powers of 2 between 8 and 2048 inclusive.
//
// pc_: current offset in function, in bytes
// p:  a PCALIGN or PCALIGNMAX prog
// ctxt: the context, for current function
// cursym: current function being assembled
// returns number of bytes of padding needed,
// updates minimum alignment for the function.
func AlignmentPadding(pc int32, p *Prog, ctxt *Link, cursym *LSym) int {}

// AlignmentPaddingLength is the number of bytes to add to align code as requested.
// Alignment is restricted to powers of 2 between 8 and 2048 inclusive.
// This only computes the length and does not update the (missing parameter)
// current function's own required alignment.
//
// pc: current offset in function, in bytes
// p:  a PCALIGN or PCALIGNMAX prog
// ctxt: the context, for current function
// returns number of bytes of padding needed,
func AlignmentPaddingLength(pc int32, p *Prog, ctxt *Link) int {}

// requireAlignment ensures that the function is aligned enough to support
// the required code alignment
func requireAlignment(a int64, ctxt *Link, cursym *LSym) {}