type ctxt7 … const funcAlign … const REGFROM … type Optab … func IsAtomicInstruction(as obj.As) bool { … } var atomicLDADD … var atomicSWP … var atomicCASP … var oprange … var xcmp … const S32 … const S64 … const Sbit … const LSL0_32 … const LSL0_64 … func OPDP2(x uint32) uint32 { … } func OPDP3(sf uint32, op54 uint32, op31 uint32, o0 uint32) uint32 { … } func OPBcc(x uint32) uint32 { … } func OPBLR(x uint32) uint32 { … } func SYSOP(l uint32, op0 uint32, op1 uint32, crn uint32, crm uint32, op2 uint32, rt uint32) uint32 { … } func SYSHINT(x uint32) uint32 { … } func LDSTR(sz uint32, v uint32, opc uint32) uint32 { … } func LD2STR(o uint32) uint32 { … } func LDSTX(sz uint32, o2 uint32, l uint32, o1 uint32, o0 uint32) uint32 { … } func FPCMP(m uint32, s uint32, type_ uint32, op uint32, op2 uint32) uint32 { … } func FPCCMP(m uint32, s uint32, type_ uint32, op uint32) uint32 { … } func FPOP1S(m uint32, s uint32, type_ uint32, op uint32) uint32 { … } func FPOP2S(m uint32, s uint32, type_ uint32, op uint32) uint32 { … } func FPOP3S(m uint32, s uint32, type_ uint32, op uint32, op2 uint32) uint32 { … } func FPCVTI(sf uint32, s uint32, type_ uint32, rmode uint32, op uint32) uint32 { … } func ADR(p uint32, o uint32, rt uint32) uint32 { … } func OPBIT(x uint32) uint32 { … } func MOVCONST(d int64, s int, rt int) uint32 { … } const LFROM … const LTO … const NOTUSETMP … const BRANCH14BITS … const BRANCH19BITS … var optab … var pstatefield … var prfopfield … var sysInstFields … const OP_NOOP … // pcAlignPadLength returns the number of bytes required to align pc to alignedValue, // reporting an error if alignedValue is not a power of two or is out of range. func pcAlignPadLength(ctxt *obj.Link, pc int64, alignedValue int64) int { … } // size returns the size of the sequence of machine instructions when p is encoded with o. // Usually it just returns o.size directly, in some cases it checks whether the optimization // conditions are met, and if so returns the size of the optimized instruction sequence. // These optimizations need to be synchronized with the asmout function. func (o *Optab) size(ctxt *obj.Link, p *obj.Prog) int { … } func span7(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) { … } type codeBuffer … func (cb *codeBuffer) pc() int64 { … } // Write a sequence of opcodes into the code buffer. func (cb *codeBuffer) emit(op ...uint32) { … } // Completes the code buffer for the function by padding the buffer to function alignment // with zero values. func (cb *codeBuffer) finish() { … } // Return the size of the assembled Prog, in bytes. func (c *ctxt7) asmsizeBytes(p *obj.Prog) int { … } // Modify the Prog list if the Prog is a branch with a large offset that cannot be // encoded in the instruction. Return true if a modification was made, false if not. func (c *ctxt7) fixUpLongBranch(p *obj.Prog) bool { … } // Adds literal values from the Prog into the literal pool if necessary. func (c *ctxt7) addLiteralsToPool(p *obj.Prog) { … } // isUnsafePoint returns whether p is an unsafe point. func (c *ctxt7) isUnsafePoint(p *obj.Prog) bool { … } // isRestartable returns whether p is a multi-instruction sequence that, // if preempted, can be restarted. func (c *ctxt7) isRestartable(p *obj.Prog) bool { … } /* * when the first reference to the literal pool threatens * to go out of range of a 1Mb PC-relative offset * drop the pool now. */ func (c *ctxt7) checkpool(p *obj.Prog) { … } func (c *ctxt7) flushpool(p *obj.Prog) { … } /* * MOVD foo(SB), R is actually * MOVD addr, REGTMP * MOVD REGTMP, R * where addr is the address of the DWORD containing the address of foo. * * TODO: hash */ func (c *ctxt7) addpool(p *obj.Prog, a *obj.Addr) { … } // roundUp rounds up x to "to". func roundUp(x, to uint32) uint32 { … } // splitImm24uScaled splits an immediate into a scaled 12 bit unsigned lo value // and an unscaled shifted 12 bit unsigned hi value. These are typically used // by adding or subtracting the hi value and using the lo value as the offset // for a load or store. func splitImm24uScaled(v int32, shift int) (int32, int32, error) { … } func (c *ctxt7) regoff(a *obj.Addr) int32 { … } func isSTLXRop(op obj.As) bool { … } func isSTXPop(op obj.As) bool { … } func isANDop(op obj.As) bool { … } func isANDWop(op obj.As) bool { … } func isADDop(op obj.As) bool { … } func isADDWop(op obj.As) bool { … } func isADDSop(op obj.As) bool { … } func isNEGop(op obj.As) bool { … } func isLoadStorePairOp(op obj.As) bool { … } func isMOVop(op obj.As) bool { … } func isRegShiftOrExt(a *obj.Addr) bool { … } const maxPCDisp … // ispcdisp reports whether v is a valid PC-relative displacement. func ispcdisp(v int32) bool { … } func isaddcon(v int64) bool { … } func isaddcon2(v int64) bool { … } // isbitcon reports whether a constant can be encoded into a logical instruction. // bitcon has a binary form of repetition of a bit sequence of length 2, 4, 8, 16, 32, or 64, // which itself is a rotate (w.r.t. the length of the unit) of a sequence of ones. // special cases: 0 and -1 are not bitcon. // this function needs to run against virtually all the constants, so it needs to be fast. // for this reason, bitcon testing and bitcon encoding are separate functions. func isbitcon(x uint64) bool { … } // sequenceOfOnes tests whether a constant is a sequence of ones in binary, with leading and trailing zeros. func sequenceOfOnes(x uint64) bool { … } // bitconEncode returns the encoding of a bitcon used in logical instructions // x is known to be a bitcon // a bitcon is a sequence of n ones at low bits (i.e. 1<<n-1), right rotated // by R bits, and repeated with period of 64, 32, 16, 8, 4, or 2. // it is encoded in logical instructions with 3 bitfields // N (1 bit) : R (6 bits) : S (6 bits), where // N=1 -- period=64 // N=0, S=0xxxxx -- period=32 // N=0, S=10xxxx -- period=16 // N=0, S=110xxx -- period=8 // N=0, S=1110xx -- period=4 // N=0, S=11110x -- period=2 // R is the shift amount, low bits of S = n-1 func bitconEncode(x uint64, mode int) uint32 { … } func log2(x uint64) uint32 { … } func autoclass(l int64) int { … } func oregclass(l int64) int { … } /* * given an offset v and a class c (see above) * return the offset value to use in the instruction, * scaled if necessary */ func (c *ctxt7) offsetshift(p *obj.Prog, v int64, cls int) int64 { … } /* * if v contains a single 16-bit value aligned * on a 16-bit field, and thus suitable for movk/movn, * return the field index 0 to 3; otherwise return -1. */ func movcon(v int64) int { … } func rclass(r int16) int { … } // con32class reclassifies the constant of 32-bit instruction. Because the constant type is 32-bit, // but saved in Offset which type is int64, con32class treats it as uint32 type and reclassifies it. func (c *ctxt7) con32class(a *obj.Addr) int { … } // con64class reclassifies the constant of C_VCON and C_LCON class. func (c *ctxt7) con64class(a *obj.Addr) int { … } // loadStoreClass reclassifies a load or store operation based on its offset. func (c *ctxt7) loadStoreClass(p *obj.Prog, lsc int, v int64) int { … } // loadStorePairClass reclassifies a load or store pair operation based on its offset. func (c *ctxt7) loadStorePairClass(p *obj.Prog, lsc int, v int64) int { … } func (c *ctxt7) aclass(a *obj.Addr) int { … } func (c *ctxt7) oplook(p *obj.Prog) *Optab { … } func cmp(a int, b int) bool { … } func ocmp(p1, p2 Optab) int { … } func oprangeset(a obj.As, t []Optab) { … } func buildop(ctxt *obj.Link) { … } // chipfloat7() checks if the immediate constants available in FMOVS/FMOVD instructions. // For details of the range of constants available, see // http://infocenter.arm.com/help/topic/com.arm.doc.dui0473m/dom1359731199385.html. func (c *ctxt7) chipfloat7(e float64) int { … } /* form offset parameter to SYS; special register number */ func SYSARG5(op0 int, op1 int, Cn int, Cm int, op2 int) int { … } func SYSARG4(op1 int, Cn int, Cm int, op2 int) int { … } // checkUnpredictable checks if the source and transfer registers are the same register. // ARM64 manual says it is "constrained unpredictable" if the src and dst registers of STP/LDP are same. func (c *ctxt7) checkUnpredictable(p *obj.Prog, isload bool, wback bool, rn int16, rt1 int16, rt2 int16) { … } /* checkindex checks if index >= 0 && index <= maxindex */ func (c *ctxt7) checkindex(p *obj.Prog, index, maxindex int) { … } /* checkoffset checks whether the immediate offset is valid for VLD[1-4].P and VST[1-4].P */ func (c *ctxt7) checkoffset(p *obj.Prog, as obj.As) { … } /* checkShiftAmount checks whether the index shift amount is valid */ /* for load with register offset instructions */ func (c *ctxt7) checkShiftAmount(p *obj.Prog, a *obj.Addr) { … } func (c *ctxt7) asmout(p *obj.Prog, out []uint32) (count int) { … } func (c *ctxt7) addrRelocType(p *obj.Prog) objabi.RelocType { … } /* * basic Rm op Rn -> Rd (using shifted register with 0) * also op Rn -> Rt * also Rm*Rn op Ra -> Rd * also Vm op Vn -> Vd */ func (c *ctxt7) oprrr(p *obj.Prog, a obj.As) uint32 { … } /* * imm -> Rd * imm op Rn -> Rd */ func (c *ctxt7) opirr(p *obj.Prog, a obj.As) uint32 { … } func (c *ctxt7) opbit(p *obj.Prog, a obj.As) uint32 { … } /* * add/subtract sign or zero-extended register */ func (c *ctxt7) opxrrr(p *obj.Prog, a obj.As, rd, rn, rm int16, extend bool) uint32 { … } func (c *ctxt7) opimm(p *obj.Prog, a obj.As) uint32 { … } func (c *ctxt7) brdist(p *obj.Prog, preshift int, flen int, shift int) int64 { … } /* * pc-relative branches */ func (c *ctxt7) opbra(p *obj.Prog, a obj.As) uint32 { … } func (c *ctxt7) opbrr(p *obj.Prog, a obj.As) uint32 { … } func (c *ctxt7) op0(p *obj.Prog, a obj.As) uint32 { … } /* * register offset */ func (c *ctxt7) opload(p *obj.Prog, a obj.As) uint32 { … } func (c *ctxt7) opstore(p *obj.Prog, a obj.As) uint32 { … } /* * load/store register (scaled 12-bit unsigned immediate) C3.3.13 * these produce 64-bit values (when there's an option) */ func (c *ctxt7) olsr12u(p *obj.Prog, o uint32, v int32, rn, rt int16) uint32 { … } /* * load/store register (unscaled 9-bit signed immediate) C3.3.12 */ func (c *ctxt7) olsr9s(p *obj.Prog, o uint32, v int32, rn, rt int16) uint32 { … } // store(immediate) // scaled 12-bit unsigned immediate offset. // unscaled 9-bit signed immediate offset. // pre/post-indexed store. // and the 12-bit and 9-bit are distinguished in olsr12u and oslr9s. func (c *ctxt7) opstr(p *obj.Prog, a obj.As) uint32 { … } // load(immediate) // scaled 12-bit unsigned immediate offset. // unscaled 9-bit signed immediate offset. // pre/post-indexed load. // and the 12-bit and 9-bit are distinguished in olsr12u and oslr9s. func (c *ctxt7) opldr(p *obj.Prog, a obj.As) uint32 { … } // olsxrr attaches register operands to a load/store opcode supplied in o. // The result either encodes a load of r from (r1+r2) or a store of r to (r1+r2). func (c *ctxt7) olsxrr(p *obj.Prog, o int32, r int, r1 int, r2 int) uint32 { … } // opldrr returns the ARM64 opcode encoding corresponding to the obj.As opcode // for load instruction with register offset. // The offset register can be (Rn)(Rm.UXTW<<2) or (Rn)(Rm<<2) or (Rn)(Rm). func (c *ctxt7) opldrr(p *obj.Prog, a obj.As, extension bool) uint32 { … } // opstrr returns the ARM64 opcode encoding corresponding to the obj.As opcode // for store instruction with register offset. // The offset register can be (Rn)(Rm.UXTW<<2) or (Rn)(Rm<<2) or (Rn)(Rm). func (c *ctxt7) opstrr(p *obj.Prog, a obj.As, extension bool) uint32 { … } func (c *ctxt7) oaddi(p *obj.Prog, a obj.As, v int32, rd, rn int16) uint32 { … } func (c *ctxt7) oaddi12(p *obj.Prog, v int32, rd, rn int16) uint32 { … } /* * load a literal value into dr */ func (c *ctxt7) omovlit(as obj.As, p *obj.Prog, a *obj.Addr, dr int) uint32 { … } // load a constant (MOVCON or BITCON) in a into rt func (c *ctxt7) omovconst(as obj.As, p *obj.Prog, a *obj.Addr, rt int) (o1 uint32) { … } // load a 32-bit/64-bit large constant (LCON or VCON) in a.Offset into rt // put the instruction sequence in os and return the number of instructions. func (c *ctxt7) omovlconst(as obj.As, p *obj.Prog, a *obj.Addr, rt int, os []uint32) (num uint8) { … } func (c *ctxt7) opbfm(p *obj.Prog, a obj.As, r, s int64, rf, rt int16) uint32 { … } func (c *ctxt7) opextr(p *obj.Prog, a obj.As, v int64, rn, rm, rt int16) uint32 { … } /* generate instruction encoding for ldp and stp series */ func (c *ctxt7) opldpstp(p *obj.Prog, o *Optab, vo int32, rbase, rl, rh int16, ldp uint32) uint32 { … } func (c *ctxt7) maskOpvldvst(p *obj.Prog, o1 uint32) uint32 { … } /* * size in log2(bytes) */ func movesize(a obj.As) int { … } // rm is the Rm register value, o is the extension, amount is the left shift value. func roff(rm int16, o uint32, amount int16) uint32 { … } // encRegShiftOrExt returns the encoding of shifted/extended register, Rx<<n and Rx.UXTW<<n, etc. func (c *ctxt7) encRegShiftOrExt(p *obj.Prog, a *obj.Addr, r int16) uint32 { … } // pack returns the encoding of the "Q" field and two arrangement specifiers. func pack(q uint32, arngA, arngB uint8) uint32 { … }
Codebase Browser
go