type Arch struct {Namestring// name of architectureBuildstring// build tagWordBitsint// length of word in bits (32 or 64)WordBytesint// length of word in bytes (4 or 8)CarrySafeLoopbool// whether loops preserve carry flag across iterations// contains filtered or unexported fields}

func (*Arch)HasShiftWide¶

func (a *Arch) HasShiftWide()bool

HasShiftWide reports whether the Arch has working LshWide/RshWide instructions.If not, calling them will panic.

type Asm struct {Arch *Arch// architecture// contains filtered or unexported fields}

funcNewAsm¶

func NewAsm(arch *Arch) *Asm

NewAsm returns a new Asm preparing assemblyfor the given architecture to be written to file.

func (*Asm)Add¶

func (a *Asm) Add(src1, src2, dstReg, carryCarry)

Add emits dst = src1+src2, with the specified carry behavior.

func (*Asm)AddWords¶

func (a *Asm) AddWords(src1Reg, src2, dstRegPtr)

AddWords emits dst = src1*WordBytes + src2.It does not set or use the carry flag.

func (*Asm)AltCarry¶

func (a *Asm) AltCarry()Reg

AltCarry returns the secondary carry register, or else the zero Reg.

func (*Asm)And¶

func (a *Asm) And(src1, src2, dstReg)

And emits dst = src1 & src2It may modify the carry flag.

func (*Asm)Carry¶

func (a *Asm) Carry()Reg

Carry returns the carry register, or else the zero Reg.

func (*Asm)ClearCarry¶

func (a *Asm) ClearCarry(whichCarry)

ClearCarry clears the carry flag.The ‘which’ parameter must be AddCarry or SubCarry to specify how the flag will be used.(On some systems, the sub carry's actual processor bit is inverted from its usual value.)

func (*Asm)Comment¶

func (a *Asm) Comment(formatstring, args ...any)

Comment emits a line comment to the assembly output.

func (*Asm)ConvertCarry¶

func (a *Asm) ConvertCarry(whichCarry, dstReg)

ConvertCarry converts the carry flag in dst from the internal format to a 0 or 1.The carry flag is left in an undefined state.

func (*Asm)EOL¶

func (a *Asm) EOL(formatstring, args ...any)

EOL appends an end-of-line comment to the previous line.

func (*Asm)Enabled¶

func (a *Asm) Enabled(optionOption)bool

Enabled reports whether the optional CPU feature is consideredto be enabled at this point in the assembly output.

func (*Asm)Fatalf¶

func (a *Asm) Fatalf(formatstring, args ...any)

Fatalf reports a fatal error by panicking.Panicking is appropriate because there is a bug in the generator,and panicking will show the exact source lines leading to that bug.

func (*Asm)Free¶

func (a *Asm) Free(rReg)

Free frees a previously allocated register.If r is not a register (if it's an immediate or a memory reference), Free is a no-op.

func (*Asm)FreeAll¶

func (a *Asm) FreeAll()

FreeAll frees all known registers.

func (*Asm)Func¶

func (a *Asm) Func(declstring) *Func

Func starts a new function in the assembly output.

func (*Asm)HasRegShift¶

func (a *Asm) HasRegShift()bool

HasRegShift reports whether the architecture can use shift expressions as operands.

func (*Asm)Imm¶

func (a *Asm) Imm(xint)Reg

Imm returns a Reg representing an immediate (constant) value.

func (*Asm)IsZero¶

func (a *Asm) IsZero(rReg)bool

IsZero reports whether r is a zero immediate or the zero register.

func (*Asm)Jmp¶

func (a *Asm) Jmp(labelstring)

Jmp jumps to the label.

func (*Asm)JmpEnable¶

func (a *Asm) JmpEnable(optionOption, labelstring)bool

JmpEnable emits a test for the optional CPU feature that jumps to label if the feature is present.If JmpEnable returns false, the feature is not available on this architecture and no code was emitted.

func (*Asm)JmpNonZero¶

func (a *Asm) JmpNonZero(srcReg, labelstring)

JmpNonZero jumps to the label if src is non-zero.It may modify the carry flag unless a.Arch,CarrySafeLoop is true.

func (*Asm)JmpZero¶

func (a *Asm) JmpZero(srcReg, labelstring)

JmpZero jumps to the label if src is zero.It may modify the carry flag unless a.Arch.CarrySafeLoop is true.

func (*Asm)Label¶

func (a *Asm) Label(namestring)

Label emits a label with the given name.

func (*Asm)Lsh¶

func (a *Asm) Lsh(shift, src, dstReg)

Lsh emits dst = src << shift.It may modify the carry flag.

func (*Asm)LshReg¶

func (a *Asm) LshReg(shift, srcReg)Reg

LshReg returns a shift-expression operand src<<shift.If a.HasRegShift() == false, LshReg panics.

func (*Asm)LshWide¶

func (a *Asm) LshWide(shift, adj, src, dstReg)

LshWide emits dst = src << shift with low bits shifted from adj.It may modify the carry flag.

func (*Asm)Mov¶

func (a *Asm) Mov(src, dstReg)

Mov emits dst = src.

func (*Asm)MulWide¶

func (a *Asm) MulWide(src1, src2, dstlo, dsthiReg)

MulWide emits dstlo = src1 * src2 and dsthi = (src1 * src2) >> WordBits.The carry flag is left in an undefined state.If dstlo or dsthi is the zero Reg, then those outputs are discarded.

func (*Asm)Neg¶

func (a *Asm) Neg(src, dstReg)

Neg emits dst = -src.It may modify the carry flag.

func (*Asm)Or¶

func (a *Asm) Or(src1, src2, dstReg)

Or emits dst = src1 | src2It may modify the carry flag.

func (*Asm)Printf¶

func (a *Asm) Printf(formatstring, args ...any)

Printf emits to the assembly output.

func (*Asm)Reg¶

func (a *Asm) Reg()Reg

Reg allocates a new register.

func (*Asm)RegHint¶

func (a *Asm) RegHint(hintHint)Reg

RegHint allocates a new register, with a hint as to its purpose.

func (*Asm)RegsUsed¶

func (a *Asm) RegsUsed()RegsUsed

RegsUsed returns a snapshot of which registers are currently allocated,which can be passed to a future call toAsm.SetRegsUsed.

func (*Asm)RestoreCarry¶

func (a *Asm) RestoreCarry(srcReg)

RestoreCarry restores the carry flag from src.src is left in an undefined state.

func (*Asm)Ret¶

func (a *Asm) Ret()

Ret returns.

func (*Asm)Rsh¶

func (a *Asm) Rsh(shift, src, dstReg)

Rsh emits dst = src >> shift.It may modify the carry flag.

func (*Asm)RshReg¶

func (a *Asm) RshReg(shift, srcReg)Reg

RshReg returns a shift-expression operand src>>shift.If a.HasRegShift() == false, RshReg panics.

func (*Asm)RshWide¶

func (a *Asm) RshWide(shift, adj, src, dstReg)

RshWide emits dst = src >> shift with high bits shifted from adj.It may modify the carry flag.

func (*Asm)SLTU¶

func (a *Asm) SLTU(src1, src2, dstReg)

SLTU emits dst = src2 < src1 (0 or 1), using an unsigned comparison.

func (*Asm)SaveCarry¶

func (a *Asm) SaveCarry(dstReg)

SaveCarry saves the carry flag into dst.The meaning of the bits in dst is architecture-dependent.The carry flag is left in an undefined state.

func (*Asm)SaveConvertCarry¶

func (a *Asm) SaveConvertCarry(whichCarry, dstReg)

SaveConvertCarry saves and converts the carry flag into dst: 0 unset, 1 set.The carry flag is left in an undefined state.

func (*Asm)SetOption¶

func (a *Asm) SetOption(optionOption, onbool)

SetOption changes whether the optional CPU feature should beconsidered to be enabled.

func (*Asm)SetRegsUsed¶

func (a *Asm) SetRegsUsed(usedRegsUsed)

SetRegsUsed sets which registers are currently allocated.The argument should have been returned from a previouscall toAsm.RegsUsed.

func (*Asm)Sub¶

func (a *Asm) Sub(src1, src2, dstReg, carryCarry)

Sub emits dst = src2-src1, with the specified carry behavior.

func (*Asm)Unfree¶

func (a *Asm) Unfree(rReg)

Unfree reallocates a previously freed register r.If r is not a register (if it's an immediate or a memory reference), Unfree is a no-op.If r is not free for allocation, Unfree panics.A Free paired with Unfree can release a register for use temporarilybut then reclaim it, such as at the end of a loop body when it must be restored.

func (*Asm)Xor¶

func (a *Asm) Xor(src1, src2, dstReg)

Xor emits dst = src1 ^ src2It may modify the carry flag.

func (*Asm)ZR¶

func (a *Asm) ZR()Reg

ZR returns the zero register (the specific register guaranteed to hold the integer 0),or else the zero Reg (Reg{}, which has r.Valid() == false).

type Carryuint

type Func struct {NamestringAsm  *Asm// contains filtered or unexported fields}

func (*Func)Arg¶

func (f *Func) Arg(namestring)Reg

Arg allocates a new register, copies the named argument (or result) into it,and returns that register.

func (*Func)ArgHint¶

func (f *Func) ArgHint(namestring, hintHint)Reg

ArgHint is like Arg but uses a register allocation hint.

func (*Func)ArgPtr¶

func (f *Func) ArgPtr(namestring)RegPtr

ArgPtr is like Arg but returns a RegPtr.

func (*Func)Pipe¶

func (f *Func) Pipe() *Pipe

Pipe creates and returns a new pipe for use in the function f.

func (*Func)StoreArg¶

func (f *Func) StoreArg(srcReg, namestring)

StoreArg stores src into the named argument (or result).

type Hintuint

type Optionint

type Pipe struct {// contains filtered or unexported fields}

func (*Pipe)AtUnrollEnd¶

func (p *Pipe) AtUnrollEnd(end func())

AtUnrollEnd sets a function to call at the end of an unrolled sequence.SeePipe.Loop for details.

func (*Pipe)AtUnrollStart¶

func (p *Pipe) AtUnrollStart(start func())

AtUnrollStart sets a function to call at the start of an unrolled sequence.SeePipe.Loop for details.

func (*Pipe)Done¶

func (p *Pipe) Done()

Done frees all the registers allocated by the pipe.

func (*Pipe)DropInput¶

func (p *Pipe) DropInput(namestring)

DropInput deletes the named input from the pipe,usually because it has been exhausted.(This is not used yet but will be used in a future generator.)

func (*Pipe)LoadN¶

func (p *Pipe) LoadN(nint) [][]Reg

LoadN returns the next n columns of input words as a slice of rows.Regs for inputs that have been marked using p.SetMemOK will be direct memory references.Regs for other inputs will be newly allocated registers and must be freed.

func (*Pipe)LoadPtrs¶

func (p *Pipe) LoadPtrs(nReg)

LoadPtrs loads the slice pointer arguments into registers,assuming that the slice length n has already been loadedinto the register n.

Start will call LoadPtrs if it has not been called already.LoadPtrs only needs to be called explicitly when code needsto use LoadN before Start, like when the shift.go generatorsread an initial word before the loop.

func (*Pipe)Loop¶

func (p *Pipe) Loop(block func(in, out [][]Reg))

Loop emits code for the loop, calling block repeatedly to emit code thathandles a block of N input columns (for arbitrary N = len(in[0]) chosen by p).block must call p.StoreN(out) to write N output columns.The out slice is a pre-allocated matrix of uninitialized Reg values.block is expected to set each entry to the Reg that should be writtenbefore calling p.StoreN(out).

For example, if the loop is to be unrolled 4x in blocks of 2 columns each,the sequence of calls to emit the unrolled loop body is:

start()  // set by pAtUnrollStart... reads for 2 columns ...block()... writes for 2 columns ...... reads for 2 columns ...block()... writes for 2 columns ...end()  // set by p.AtUnrollEnd

Any registers allocated during block are freed automatically when block returns.

func (*Pipe)Restart¶

func (p *Pipe) Restart(nReg, factors ...int)

Restart prepares to loop over an additional n columns,beyond a previous loop run by p.Start/p.Loop.

func (*Pipe)SetBackward¶

func (p *Pipe) SetBackward()

SetBackward sets the pipe to process the input and output columns in reverse order.This is needed for left shifts, which might otherwise overwrite data they will read later.

func (*Pipe)SetHint¶

func (p *Pipe) SetHint(namestring, hintHint)

SetHint records that the inputs from the named vectorshould be allocated with the given register hint.

If the hint indicates a single register on the target architecture,then SetHint calls SetMaxColumns(1), since the hinted registercan only be used for one value at a time.

func (*Pipe)SetLabel¶

func (p *Pipe) SetLabel(labelstring)

SetLabel sets the label prefix for the loops emitted by the pipe.The default prefix is "loop".

func (*Pipe)SetMaxColumns¶

func (p *Pipe) SetMaxColumns(mint)

SetMaxColumns sets the maximum number ofcolumns processed in a single loop body call.

func (*Pipe)SetUseIndexCounter¶

func (p *Pipe) SetUseIndexCounter()

SetUseIndexCounter sets the pipe to use an index counter if possible,meaning the loop counter is also used as an index for accessing the slice data.This clever trick is slower on modern processors, but it is still necessary on 386.On non-386 systems, SetUseIndexCounter is a no-op.

func (*Pipe)Start¶

func (p *Pipe) Start(nReg, factors ...int)

Start prepares to loop over n columns.The factors give a sequence of unrolling factors to use,which must be either strictly increasing or strictly decreasingand must include 1.For example, 4, 1 means to process 4 elements at a timeand then 1 at a time for the final 0-3; specifying 1,4 insteadhandles 0-3 elements first and then 4 at a time.Similarly, 32, 4, 1 means to process 32 at a time,then 4 at a time, then 1 at a time.

One benefit of using 1, 4 instead of 4, 1 is that the bodyprocessing 4 at a time needs more registers, and if it isthe final body, the register holding the fragment count (0-3)has been freed and is available for use.

Start may modify the carry flag.

Start must be followed by a call to Loop1 or LoopN,but it is permitted to emit other instructions first,for example to set an initial carry flag.

func (*Pipe)StoreN¶

func (p *Pipe) StoreN(regs [][]Reg)

StoreN writes regs (a slice of rows) to the next n columns of output, where n = len(regs[0]).

type Reg struct {// contains filtered or unexported fields}

func (Reg)IsImm¶

func (rReg) IsImm()bool

IsImm reports whether r is an immediate value.

func (Reg)IsMem¶

func (rReg) IsMem()bool

IsMem reports whether r is a memory value.

func (Reg)String¶

func (rReg) String()string

String returns the assembly syntax for r.

func (Reg)Valid¶

func (rReg) Valid()bool

Valid reports whether is valid, meaning r is not the zero value of Reg (a register with no name).

type RegPtr struct {// contains filtered or unexported fields}

func (RegPtr)String¶

func (rRegPtr) String()string

String returns the assembly syntax for r.

func (RegPtr)Valid¶

func (rRegPtr) Valid()bool

Valid reports whether is valid, meaning r is not the zero value of RegPtr (a register with no name).

type RegsUsed struct {// contains filtered or unexported fields}