1// Copyright 2015 The Go Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style 3// license that can be found in the LICENSE file. 4 5package main 6 7// Generic opcodes typically specify a width. The inputs and outputs 8// of that op are the given number of bits wide. There is no notion of 9// "sign", so Add32 can be used both for signed and unsigned 32-bit 10// addition. 11 12// Signed/unsigned is explicit with the extension ops 13// (SignExt*/ZeroExt*) and implicit as the arg to some opcodes 14// (e.g. the second argument to shifts is unsigned). If not mentioned, 15// all args take signed inputs, or don't care whether their inputs 16// are signed or unsigned. 17 18var genericOps = []opData{ 19 // 2-input arithmetic 20 // Types must be consistent with Go typing. Add, for example, must take two values 21 // of the same type and produces that same type. 22 {name: "Add8", argLength: 2, commutative: true}, // arg0 + arg1 23 {name: "Add16", argLength: 2, commutative: true}, 24 {name: "Add32", argLength: 2, commutative: true}, 25 {name: "Add64", argLength: 2, commutative: true}, 26 {name: "AddPtr", argLength: 2}, // For address calculations. arg0 is a pointer and arg1 is an int. 27 {name: "Add32F", argLength: 2, commutative: true}, 28 {name: "Add64F", argLength: 2, commutative: true}, 29 30 {name: "Sub8", argLength: 2}, // arg0 - arg1 31 {name: "Sub16", argLength: 2}, 32 {name: "Sub32", argLength: 2}, 33 {name: "Sub64", argLength: 2}, 34 {name: "SubPtr", argLength: 2}, 35 {name: "Sub32F", argLength: 2}, 36 {name: "Sub64F", argLength: 2}, 37 38 {name: "Mul8", argLength: 2, commutative: true}, // arg0 * arg1 39 {name: "Mul16", argLength: 2, commutative: true}, 40 {name: "Mul32", argLength: 2, commutative: true}, 41 {name: "Mul64", argLength: 2, commutative: true}, 42 {name: "Mul32F", argLength: 2, commutative: true}, 43 {name: "Mul64F", argLength: 2, commutative: true}, 44 45 {name: "Div32F", argLength: 2}, // arg0 / arg1 46 {name: "Div64F", argLength: 2}, 47 48 {name: "Hmul32", argLength: 2, commutative: true}, 49 {name: "Hmul32u", argLength: 2, commutative: true}, 50 {name: "Hmul64", argLength: 2, commutative: true}, 51 {name: "Hmul64u", argLength: 2, commutative: true}, 52 53 {name: "Mul32uhilo", argLength: 2, typ: "(UInt32,UInt32)", commutative: true}, // arg0 * arg1, returns (hi, lo) 54 {name: "Mul64uhilo", argLength: 2, typ: "(UInt64,UInt64)", commutative: true}, // arg0 * arg1, returns (hi, lo) 55 56 {name: "Mul32uover", argLength: 2, typ: "(UInt32,Bool)", commutative: true}, // Let x = arg0*arg1 (full 32x32-> 64 unsigned multiply), returns (uint32(x), (uint32(x) != x)) 57 {name: "Mul64uover", argLength: 2, typ: "(UInt64,Bool)", commutative: true}, // Let x = arg0*arg1 (full 64x64->128 unsigned multiply), returns (uint64(x), (uint64(x) != x)) 58 59 // Weird special instructions for use in the strength reduction of divides. 60 // These ops compute unsigned (arg0 + arg1) / 2, correct to all 61 // 32/64 bits, even when the intermediate result of the add has 33/65 bits. 62 // These ops can assume arg0 >= arg1. 63 // Note: these ops aren't commutative! 64 {name: "Avg32u", argLength: 2, typ: "UInt32"}, // 32-bit platforms only 65 {name: "Avg64u", argLength: 2, typ: "UInt64"}, // 64-bit platforms only 66 67 // For Div16, Div32 and Div64, AuxInt non-zero means that the divisor has been proved to be not -1 68 // or that the dividend is not the most negative value. 69 {name: "Div8", argLength: 2}, // arg0 / arg1, signed 70 {name: "Div8u", argLength: 2}, // arg0 / arg1, unsigned 71 {name: "Div16", argLength: 2, aux: "Bool"}, 72 {name: "Div16u", argLength: 2}, 73 {name: "Div32", argLength: 2, aux: "Bool"}, 74 {name: "Div32u", argLength: 2}, 75 {name: "Div64", argLength: 2, aux: "Bool"}, 76 {name: "Div64u", argLength: 2}, 77 {name: "Div128u", argLength: 3}, // arg0:arg1 / arg2 (128-bit divided by 64-bit), returns (q, r) 78 79 // For Mod16, Mod32 and Mod64, AuxInt non-zero means that the divisor has been proved to be not -1. 80 {name: "Mod8", argLength: 2}, // arg0 % arg1, signed 81 {name: "Mod8u", argLength: 2}, // arg0 % arg1, unsigned 82 {name: "Mod16", argLength: 2, aux: "Bool"}, 83 {name: "Mod16u", argLength: 2}, 84 {name: "Mod32", argLength: 2, aux: "Bool"}, 85 {name: "Mod32u", argLength: 2}, 86 {name: "Mod64", argLength: 2, aux: "Bool"}, 87 {name: "Mod64u", argLength: 2}, 88 89 {name: "And8", argLength: 2, commutative: true}, // arg0 & arg1 90 {name: "And16", argLength: 2, commutative: true}, 91 {name: "And32", argLength: 2, commutative: true}, 92 {name: "And64", argLength: 2, commutative: true}, 93 94 {name: "Or8", argLength: 2, commutative: true}, // arg0 | arg1 95 {name: "Or16", argLength: 2, commutative: true}, 96 {name: "Or32", argLength: 2, commutative: true}, 97 {name: "Or64", argLength: 2, commutative: true}, 98 99 {name: "Xor8", argLength: 2, commutative: true}, // arg0 ^ arg1 100 {name: "Xor16", argLength: 2, commutative: true}, 101 {name: "Xor32", argLength: 2, commutative: true}, 102 {name: "Xor64", argLength: 2, commutative: true}, 103 104 // For shifts, AxB means the shifted value has A bits and the shift amount has B bits. 105 // Shift amounts are considered unsigned. 106 // If arg1 is known to be nonnegative and less than the number of bits in arg0, 107 // then auxInt may be set to 1. 108 // This enables better code generation on some platforms. 109 {name: "Lsh8x8", argLength: 2, aux: "Bool"}, // arg0 << arg1 110 {name: "Lsh8x16", argLength: 2, aux: "Bool"}, 111 {name: "Lsh8x32", argLength: 2, aux: "Bool"}, 112 {name: "Lsh8x64", argLength: 2, aux: "Bool"}, 113 {name: "Lsh16x8", argLength: 2, aux: "Bool"}, 114 {name: "Lsh16x16", argLength: 2, aux: "Bool"}, 115 {name: "Lsh16x32", argLength: 2, aux: "Bool"}, 116 {name: "Lsh16x64", argLength: 2, aux: "Bool"}, 117 {name: "Lsh32x8", argLength: 2, aux: "Bool"}, 118 {name: "Lsh32x16", argLength: 2, aux: "Bool"}, 119 {name: "Lsh32x32", argLength: 2, aux: "Bool"}, 120 {name: "Lsh32x64", argLength: 2, aux: "Bool"}, 121 {name: "Lsh64x8", argLength: 2, aux: "Bool"}, 122 {name: "Lsh64x16", argLength: 2, aux: "Bool"}, 123 {name: "Lsh64x32", argLength: 2, aux: "Bool"}, 124 {name: "Lsh64x64", argLength: 2, aux: "Bool"}, 125 126 {name: "Rsh8x8", argLength: 2, aux: "Bool"}, // arg0 >> arg1, signed 127 {name: "Rsh8x16", argLength: 2, aux: "Bool"}, 128 {name: "Rsh8x32", argLength: 2, aux: "Bool"}, 129 {name: "Rsh8x64", argLength: 2, aux: "Bool"}, 130 {name: "Rsh16x8", argLength: 2, aux: "Bool"}, 131 {name: "Rsh16x16", argLength: 2, aux: "Bool"}, 132 {name: "Rsh16x32", argLength: 2, aux: "Bool"}, 133 {name: "Rsh16x64", argLength: 2, aux: "Bool"}, 134 {name: "Rsh32x8", argLength: 2, aux: "Bool"}, 135 {name: "Rsh32x16", argLength: 2, aux: "Bool"}, 136 {name: "Rsh32x32", argLength: 2, aux: "Bool"}, 137 {name: "Rsh32x64", argLength: 2, aux: "Bool"}, 138 {name: "Rsh64x8", argLength: 2, aux: "Bool"}, 139 {name: "Rsh64x16", argLength: 2, aux: "Bool"}, 140 {name: "Rsh64x32", argLength: 2, aux: "Bool"}, 141 {name: "Rsh64x64", argLength: 2, aux: "Bool"}, 142 143 {name: "Rsh8Ux8", argLength: 2, aux: "Bool"}, // arg0 >> arg1, unsigned 144 {name: "Rsh8Ux16", argLength: 2, aux: "Bool"}, 145 {name: "Rsh8Ux32", argLength: 2, aux: "Bool"}, 146 {name: "Rsh8Ux64", argLength: 2, aux: "Bool"}, 147 {name: "Rsh16Ux8", argLength: 2, aux: "Bool"}, 148 {name: "Rsh16Ux16", argLength: 2, aux: "Bool"}, 149 {name: "Rsh16Ux32", argLength: 2, aux: "Bool"}, 150 {name: "Rsh16Ux64", argLength: 2, aux: "Bool"}, 151 {name: "Rsh32Ux8", argLength: 2, aux: "Bool"}, 152 {name: "Rsh32Ux16", argLength: 2, aux: "Bool"}, 153 {name: "Rsh32Ux32", argLength: 2, aux: "Bool"}, 154 {name: "Rsh32Ux64", argLength: 2, aux: "Bool"}, 155 {name: "Rsh64Ux8", argLength: 2, aux: "Bool"}, 156 {name: "Rsh64Ux16", argLength: 2, aux: "Bool"}, 157 {name: "Rsh64Ux32", argLength: 2, aux: "Bool"}, 158 {name: "Rsh64Ux64", argLength: 2, aux: "Bool"}, 159 160 // 2-input comparisons 161 {name: "Eq8", argLength: 2, commutative: true, typ: "Bool"}, // arg0 == arg1 162 {name: "Eq16", argLength: 2, commutative: true, typ: "Bool"}, 163 {name: "Eq32", argLength: 2, commutative: true, typ: "Bool"}, 164 {name: "Eq64", argLength: 2, commutative: true, typ: "Bool"}, 165 {name: "EqPtr", argLength: 2, commutative: true, typ: "Bool"}, 166 {name: "EqInter", argLength: 2, typ: "Bool"}, // arg0 or arg1 is nil; other cases handled by frontend 167 {name: "EqSlice", argLength: 2, typ: "Bool"}, // arg0 or arg1 is nil; other cases handled by frontend 168 {name: "Eq32F", argLength: 2, commutative: true, typ: "Bool"}, 169 {name: "Eq64F", argLength: 2, commutative: true, typ: "Bool"}, 170 171 {name: "Neq8", argLength: 2, commutative: true, typ: "Bool"}, // arg0 != arg1 172 {name: "Neq16", argLength: 2, commutative: true, typ: "Bool"}, 173 {name: "Neq32", argLength: 2, commutative: true, typ: "Bool"}, 174 {name: "Neq64", argLength: 2, commutative: true, typ: "Bool"}, 175 {name: "NeqPtr", argLength: 2, commutative: true, typ: "Bool"}, 176 {name: "NeqInter", argLength: 2, typ: "Bool"}, // arg0 or arg1 is nil; other cases handled by frontend 177 {name: "NeqSlice", argLength: 2, typ: "Bool"}, // arg0 or arg1 is nil; other cases handled by frontend 178 {name: "Neq32F", argLength: 2, commutative: true, typ: "Bool"}, 179 {name: "Neq64F", argLength: 2, commutative: true, typ: "Bool"}, 180 181 {name: "Less8", argLength: 2, typ: "Bool"}, // arg0 < arg1, signed 182 {name: "Less8U", argLength: 2, typ: "Bool"}, // arg0 < arg1, unsigned 183 {name: "Less16", argLength: 2, typ: "Bool"}, 184 {name: "Less16U", argLength: 2, typ: "Bool"}, 185 {name: "Less32", argLength: 2, typ: "Bool"}, 186 {name: "Less32U", argLength: 2, typ: "Bool"}, 187 {name: "Less64", argLength: 2, typ: "Bool"}, 188 {name: "Less64U", argLength: 2, typ: "Bool"}, 189 {name: "Less32F", argLength: 2, typ: "Bool"}, 190 {name: "Less64F", argLength: 2, typ: "Bool"}, 191 192 {name: "Leq8", argLength: 2, typ: "Bool"}, // arg0 <= arg1, signed 193 {name: "Leq8U", argLength: 2, typ: "Bool"}, // arg0 <= arg1, unsigned 194 {name: "Leq16", argLength: 2, typ: "Bool"}, 195 {name: "Leq16U", argLength: 2, typ: "Bool"}, 196 {name: "Leq32", argLength: 2, typ: "Bool"}, 197 {name: "Leq32U", argLength: 2, typ: "Bool"}, 198 {name: "Leq64", argLength: 2, typ: "Bool"}, 199 {name: "Leq64U", argLength: 2, typ: "Bool"}, 200 {name: "Leq32F", argLength: 2, typ: "Bool"}, 201 {name: "Leq64F", argLength: 2, typ: "Bool"}, 202 203 // the type of a CondSelect is the same as the type of its first 204 // two arguments, which should be register-width scalars; the third 205 // argument should be a boolean 206 {name: "CondSelect", argLength: 3}, // arg2 ? arg0 : arg1 207 208 // boolean ops 209 {name: "AndB", argLength: 2, commutative: true, typ: "Bool"}, // arg0 && arg1 (not shortcircuited) 210 {name: "OrB", argLength: 2, commutative: true, typ: "Bool"}, // arg0 || arg1 (not shortcircuited) 211 {name: "EqB", argLength: 2, commutative: true, typ: "Bool"}, // arg0 == arg1 212 {name: "NeqB", argLength: 2, commutative: true, typ: "Bool"}, // arg0 != arg1 213 {name: "Not", argLength: 1, typ: "Bool"}, // !arg0, boolean 214 215 // 1-input ops 216 {name: "Neg8", argLength: 1}, // -arg0 217 {name: "Neg16", argLength: 1}, 218 {name: "Neg32", argLength: 1}, 219 {name: "Neg64", argLength: 1}, 220 {name: "Neg32F", argLength: 1}, 221 {name: "Neg64F", argLength: 1}, 222 223 {name: "Com8", argLength: 1}, // ^arg0 224 {name: "Com16", argLength: 1}, 225 {name: "Com32", argLength: 1}, 226 {name: "Com64", argLength: 1}, 227 228 {name: "Ctz8", argLength: 1}, // Count trailing (low order) zeroes (returns 0-8) 229 {name: "Ctz16", argLength: 1}, // Count trailing (low order) zeroes (returns 0-16) 230 {name: "Ctz32", argLength: 1}, // Count trailing (low order) zeroes (returns 0-32) 231 {name: "Ctz64", argLength: 1}, // Count trailing (low order) zeroes (returns 0-64) 232 {name: "Ctz8NonZero", argLength: 1}, // same as above, but arg[0] known to be non-zero, returns 0-7 233 {name: "Ctz16NonZero", argLength: 1}, // same as above, but arg[0] known to be non-zero, returns 0-15 234 {name: "Ctz32NonZero", argLength: 1}, // same as above, but arg[0] known to be non-zero, returns 0-31 235 {name: "Ctz64NonZero", argLength: 1}, // same as above, but arg[0] known to be non-zero, returns 0-63 236 {name: "BitLen8", argLength: 1}, // Number of bits in arg[0] (returns 0-8) 237 {name: "BitLen16", argLength: 1}, // Number of bits in arg[0] (returns 0-16) 238 {name: "BitLen32", argLength: 1}, // Number of bits in arg[0] (returns 0-32) 239 {name: "BitLen64", argLength: 1}, // Number of bits in arg[0] (returns 0-64) 240 241 {name: "Bswap16", argLength: 1}, // Swap bytes 242 {name: "Bswap32", argLength: 1}, // Swap bytes 243 {name: "Bswap64", argLength: 1}, // Swap bytes 244 245 {name: "BitRev8", argLength: 1}, // Reverse the bits in arg[0] 246 {name: "BitRev16", argLength: 1}, // Reverse the bits in arg[0] 247 {name: "BitRev32", argLength: 1}, // Reverse the bits in arg[0] 248 {name: "BitRev64", argLength: 1}, // Reverse the bits in arg[0] 249 250 {name: "PopCount8", argLength: 1}, // Count bits in arg[0] 251 {name: "PopCount16", argLength: 1}, // Count bits in arg[0] 252 {name: "PopCount32", argLength: 1}, // Count bits in arg[0] 253 {name: "PopCount64", argLength: 1}, // Count bits in arg[0] 254 255 // RotateLeftX instructions rotate the X bits of arg[0] to the left 256 // by the low lg_2(X) bits of arg[1], interpreted as an unsigned value. 257 // Note that this works out regardless of the bit width or signedness of 258 // arg[1]. In particular, RotateLeft by x is the same as RotateRight by -x. 259 {name: "RotateLeft64", argLength: 2}, 260 {name: "RotateLeft32", argLength: 2}, 261 {name: "RotateLeft16", argLength: 2}, 262 {name: "RotateLeft8", argLength: 2}, 263 264 // Square root. 265 // Special cases: 266 // +∞ → +∞ 267 // ±0 → ±0 (sign preserved) 268 // x<0 → NaN 269 // NaN → NaN 270 {name: "Sqrt", argLength: 1}, // √arg0 (floating point, double precision) 271 {name: "Sqrt32", argLength: 1}, // √arg0 (floating point, single precision) 272 273 // Round to integer, float64 only. 274 // Special cases: 275 // ±∞ → ±∞ (sign preserved) 276 // ±0 → ±0 (sign preserved) 277 // NaN → NaN 278 {name: "Floor", argLength: 1}, // round arg0 toward -∞ 279 {name: "Ceil", argLength: 1}, // round arg0 toward +∞ 280 {name: "Trunc", argLength: 1}, // round arg0 toward 0 281 {name: "Round", argLength: 1}, // round arg0 to nearest, ties away from 0 282 {name: "RoundToEven", argLength: 1}, // round arg0 to nearest, ties to even 283 284 // Modify the sign bit 285 {name: "Abs", argLength: 1}, // absolute value arg0 286 {name: "Copysign", argLength: 2}, // copy sign from arg0 to arg1 287 288 // Float min/max implementation, if hardware is available. 289 {name: "Min64F", argLength: 2}, // min(arg0,arg1) 290 {name: "Min32F", argLength: 2}, // min(arg0,arg1) 291 {name: "Max64F", argLength: 2}, // max(arg0,arg1) 292 {name: "Max32F", argLength: 2}, // max(arg0,arg1) 293 294 // 3-input opcode. 295 // Fused-multiply-add, float64 only. 296 // When a*b+c is exactly zero (before rounding), then the result is +0 or -0. 297 // The 0's sign is determined according to the standard rules for the 298 // addition (-0 if both a*b and c are -0, +0 otherwise). 299 // 300 // Otherwise, when a*b+c rounds to zero, then the resulting 0's sign is 301 // determined by the sign of the exact result a*b+c. 302 // See section 6.3 in ieee754. 303 // 304 // When the multiply is an infinity times a zero, the result is NaN. 305 // See section 7.2 in ieee754. 306 {name: "FMA", argLength: 3}, // compute (a*b)+c without intermediate rounding 307 308 // Data movement. Max argument length for Phi is indefinite. 309 {name: "Phi", argLength: -1, zeroWidth: true}, // select an argument based on which predecessor block we came from 310 {name: "Copy", argLength: 1}, // output = arg0 311 // Convert converts between pointers and integers. 312 // We have a special op for this so as to not confuse GC 313 // (particularly stack maps). It takes a memory arg so it 314 // gets correctly ordered with respect to GC safepoints. 315 // It gets compiled to nothing, so its result must in the same 316 // register as its argument. regalloc knows it can use any 317 // allocatable integer register for OpConvert. 318 // arg0=ptr/int arg1=mem, output=int/ptr 319 {name: "Convert", argLength: 2, zeroWidth: true, resultInArg0: true}, 320 321 // constants. Constant values are stored in the aux or 322 // auxint fields. 323 {name: "ConstBool", aux: "Bool"}, // auxint is 0 for false and 1 for true 324 {name: "ConstString", aux: "String"}, // value is aux.(string) 325 {name: "ConstNil", typ: "BytePtr"}, // nil pointer 326 {name: "Const8", aux: "Int8"}, // auxint is sign-extended 8 bits 327 {name: "Const16", aux: "Int16"}, // auxint is sign-extended 16 bits 328 {name: "Const32", aux: "Int32"}, // auxint is sign-extended 32 bits 329 // Note: ConstX are sign-extended even when the type of the value is unsigned. 330 // For instance, uint8(0xaa) is stored as auxint=0xffffffffffffffaa. 331 {name: "Const64", aux: "Int64"}, // value is auxint 332 // Note: for both Const32F and Const64F, we disallow encoding NaNs. 333 // Signaling NaNs are tricky because if you do anything with them, they become quiet. 334 // Particularly, converting a 32 bit sNaN to 64 bit and back converts it to a qNaN. 335 // See issue 36399 and 36400. 336 // Encodings of +inf, -inf, and -0 are fine. 337 {name: "Const32F", aux: "Float32"}, // value is math.Float64frombits(uint64(auxint)) and is exactly representable as float 32 338 {name: "Const64F", aux: "Float64"}, // value is math.Float64frombits(uint64(auxint)) 339 {name: "ConstInterface"}, // nil interface 340 {name: "ConstSlice"}, // nil slice 341 342 // Constant-like things 343 {name: "InitMem", zeroWidth: true}, // memory input to the function. 344 {name: "Arg", aux: "SymOff", symEffect: "Read", zeroWidth: true}, // argument to the function. aux=GCNode of arg, off = offset in that arg. 345 346 // Like Arg, these are generic ops that survive lowering. AuxInt is a register index, and the actual output register for each index is defined by the architecture. 347 // AuxInt = integer argument index (not a register number). ABI-specified spill loc obtained from function 348 {name: "ArgIntReg", aux: "NameOffsetInt8", zeroWidth: true}, // argument to the function in an int reg. 349 {name: "ArgFloatReg", aux: "NameOffsetInt8", zeroWidth: true}, // argument to the function in a float reg. 350 351 // The address of a variable. arg0 is the base pointer. 352 // If the variable is a global, the base pointer will be SB and 353 // the Aux field will be a *obj.LSym. 354 // If the variable is a local, the base pointer will be SP and 355 // the Aux field will be a *gc.Node. 356 {name: "Addr", argLength: 1, aux: "Sym", symEffect: "Addr"}, // Address of a variable. Arg0=SB. Aux identifies the variable. 357 {name: "LocalAddr", argLength: 2, aux: "Sym", symEffect: "Addr"}, // Address of a variable. Arg0=SP. Arg1=mem. Aux identifies the variable. 358 359 {name: "SP", zeroWidth: true}, // stack pointer 360 {name: "SB", typ: "Uintptr", zeroWidth: true}, // static base pointer (a.k.a. globals pointer) 361 {name: "Invalid"}, // unused value 362 {name: "SPanchored", typ: "Uintptr", argLength: 2, zeroWidth: true}, // arg0 = SP, arg1 = mem. Result is identical to arg0, but cannot be scheduled before memory state arg1. 363 364 // Memory operations 365 {name: "Load", argLength: 2}, // Load from arg0. arg1=memory 366 {name: "Dereference", argLength: 2}, // Load from arg0. arg1=memory. Helper op for arg/result passing, result is an otherwise not-SSA-able "value". 367 {name: "Store", argLength: 3, typ: "Mem", aux: "Typ"}, // Store arg1 to arg0. arg2=memory, aux=type. Returns memory. 368 // Normally we require that the source and destination of Move do not overlap. 369 // There is an exception when we know all the loads will happen before all 370 // the stores. In that case, overlap is ok. See 371 // memmove inlining in generic.rules. When inlineablememmovesize (in ../rewrite.go) 372 // returns true, we must do all loads before all stores, when lowering Move. 373 // The type of Move is used for the write barrier pass to insert write barriers 374 // and for alignment on some architectures. 375 // For pointerless types, it is possible for the type to be inaccurate. 376 // For type alignment and pointer information, use the type in Aux; 377 // for type size, use the size in AuxInt. 378 // The "inline runtime.memmove" rewrite rule generates Moves with inaccurate types, 379 // such as type byte instead of the more accurate type [8]byte. 380 {name: "Move", argLength: 3, typ: "Mem", aux: "TypSize"}, // arg0=destptr, arg1=srcptr, arg2=mem, auxint=size, aux=type. Returns memory. 381 {name: "Zero", argLength: 2, typ: "Mem", aux: "TypSize"}, // arg0=destptr, arg1=mem, auxint=size, aux=type. Returns memory. 382 383 // Memory operations with write barriers. 384 // Expand to runtime calls. Write barrier will be removed if write on stack. 385 {name: "StoreWB", argLength: 3, typ: "Mem", aux: "Typ"}, // Store arg1 to arg0. arg2=memory, aux=type. Returns memory. 386 {name: "MoveWB", argLength: 3, typ: "Mem", aux: "TypSize"}, // arg0=destptr, arg1=srcptr, arg2=mem, auxint=size, aux=type. Returns memory. 387 {name: "ZeroWB", argLength: 2, typ: "Mem", aux: "TypSize"}, // arg0=destptr, arg1=mem, auxint=size, aux=type. Returns memory. 388 {name: "WBend", argLength: 1, typ: "Mem"}, // Write barrier code is done, interrupting is now allowed. 389 390 // WB invokes runtime.gcWriteBarrier. This is not a normal 391 // call: it takes arguments in registers, doesn't clobber 392 // general-purpose registers (the exact clobber set is 393 // arch-dependent), and is not a safe-point. 394 {name: "WB", argLength: 1, typ: "(BytePtr,Mem)", aux: "Int64"}, // arg0=mem, auxint=# of buffer entries needed. Returns buffer pointer and memory. 395 396 {name: "HasCPUFeature", argLength: 0, typ: "bool", aux: "Sym", symEffect: "None"}, // aux=place that this feature flag can be loaded from 397 398 // PanicBounds and PanicExtend generate a runtime panic. 399 // Their arguments provide index values to use in panic messages. 400 // Both PanicBounds and PanicExtend have an AuxInt value from the BoundsKind type (in ../op.go). 401 // PanicBounds' index is int sized. 402 // PanicExtend's index is int64 sized. (PanicExtend is only used on 32-bit archs.) 403 {name: "PanicBounds", argLength: 3, aux: "Int64", typ: "Mem", call: true}, // arg0=idx, arg1=len, arg2=mem, returns memory. 404 {name: "PanicExtend", argLength: 4, aux: "Int64", typ: "Mem", call: true}, // arg0=idxHi, arg1=idxLo, arg2=len, arg3=mem, returns memory. 405 406 // Function calls. Arguments to the call have already been written to the stack. 407 // Return values appear on the stack. The method receiver, if any, is treated 408 // as a phantom first argument. 409 // TODO(josharian): ClosureCall and InterCall should have Int32 aux 410 // to match StaticCall's 32 bit arg size limit. 411 // TODO(drchase,josharian): could the arg size limit be bundled into the rules for CallOff? 412 413 // Before lowering, LECalls receive their fixed inputs (first), memory (last), 414 // and a variable number of input values in the middle. 415 // They produce a variable number of result values. 416 // These values are not necessarily "SSA-able"; they can be too large, 417 // but in that case inputs are loaded immediately before with OpDereference, 418 // and outputs are stored immediately with OpStore. 419 // 420 // After call expansion, Calls have the same fixed-middle-memory arrangement of inputs, 421 // with the difference that the "middle" is only the register-resident inputs, 422 // and the non-register inputs are instead stored at ABI-defined offsets from SP 423 // (and the stores thread through the memory that is ultimately an input to the call). 424 // Outputs follow a similar pattern; register-resident outputs are the leading elements 425 // of a Result-typed output, with memory last, and any memory-resident outputs have been 426 // stored to ABI-defined locations. Each non-memory input or output fits in a register. 427 // 428 // Subsequent architecture-specific lowering only changes the opcode. 429 430 {name: "ClosureCall", argLength: -1, aux: "CallOff", call: true}, // arg0=code pointer, arg1=context ptr, arg2..argN-1 are register inputs, argN=memory. auxint=arg size. Returns Result of register results, plus memory. 431 {name: "StaticCall", argLength: -1, aux: "CallOff", call: true}, // call function aux.(*obj.LSym), arg0..argN-1 are register inputs, argN=memory. auxint=arg size. Returns Result of register results, plus memory. 432 {name: "InterCall", argLength: -1, aux: "CallOff", call: true}, // interface call. arg0=code pointer, arg1..argN-1 are register inputs, argN=memory, auxint=arg size. Returns Result of register results, plus memory. 433 {name: "TailCall", argLength: -1, aux: "CallOff", call: true}, // tail call function aux.(*obj.LSym), arg0..argN-1 are register inputs, argN=memory. auxint=arg size. Returns Result of register results, plus memory. 434 435 {name: "ClosureLECall", argLength: -1, aux: "CallOff", call: true}, // late-expanded closure call. arg0=code pointer, arg1=context ptr, arg2..argN-1 are inputs, argN is mem. auxint = arg size. Result is tuple of result(s), plus mem. 436 {name: "StaticLECall", argLength: -1, aux: "CallOff", call: true}, // late-expanded static call function aux.(*ssa.AuxCall.Fn). arg0..argN-1 are inputs, argN is mem. auxint = arg size. Result is tuple of result(s), plus mem. 437 {name: "InterLECall", argLength: -1, aux: "CallOff", call: true}, // late-expanded interface call. arg0=code pointer, arg1..argN-1 are inputs, argN is mem. auxint = arg size. Result is tuple of result(s), plus mem. 438 {name: "TailLECall", argLength: -1, aux: "CallOff", call: true}, // late-expanded static tail call function aux.(*ssa.AuxCall.Fn). arg0..argN-1 are inputs, argN is mem. auxint = arg size. Result is tuple of result(s), plus mem. 439 440 // Conversions: signed extensions, zero (unsigned) extensions, truncations 441 {name: "SignExt8to16", argLength: 1, typ: "Int16"}, 442 {name: "SignExt8to32", argLength: 1, typ: "Int32"}, 443 {name: "SignExt8to64", argLength: 1, typ: "Int64"}, 444 {name: "SignExt16to32", argLength: 1, typ: "Int32"}, 445 {name: "SignExt16to64", argLength: 1, typ: "Int64"}, 446 {name: "SignExt32to64", argLength: 1, typ: "Int64"}, 447 {name: "ZeroExt8to16", argLength: 1, typ: "UInt16"}, 448 {name: "ZeroExt8to32", argLength: 1, typ: "UInt32"}, 449 {name: "ZeroExt8to64", argLength: 1, typ: "UInt64"}, 450 {name: "ZeroExt16to32", argLength: 1, typ: "UInt32"}, 451 {name: "ZeroExt16to64", argLength: 1, typ: "UInt64"}, 452 {name: "ZeroExt32to64", argLength: 1, typ: "UInt64"}, 453 {name: "Trunc16to8", argLength: 1}, 454 {name: "Trunc32to8", argLength: 1}, 455 {name: "Trunc32to16", argLength: 1}, 456 {name: "Trunc64to8", argLength: 1}, 457 {name: "Trunc64to16", argLength: 1}, 458 {name: "Trunc64to32", argLength: 1}, 459 460 {name: "Cvt32to32F", argLength: 1}, 461 {name: "Cvt32to64F", argLength: 1}, 462 {name: "Cvt64to32F", argLength: 1}, 463 {name: "Cvt64to64F", argLength: 1}, 464 {name: "Cvt32Fto32", argLength: 1}, 465 {name: "Cvt32Fto64", argLength: 1}, 466 {name: "Cvt64Fto32", argLength: 1}, 467 {name: "Cvt64Fto64", argLength: 1}, 468 {name: "Cvt32Fto64F", argLength: 1}, 469 {name: "Cvt64Fto32F", argLength: 1}, 470 {name: "CvtBoolToUint8", argLength: 1}, 471 472 // Force rounding to precision of type. 473 {name: "Round32F", argLength: 1}, 474 {name: "Round64F", argLength: 1}, 475 476 // Automatically inserted safety checks 477 {name: "IsNonNil", argLength: 1, typ: "Bool"}, // arg0 != nil 478 {name: "IsInBounds", argLength: 2, typ: "Bool"}, // 0 <= arg0 < arg1. arg1 is guaranteed >= 0. 479 {name: "IsSliceInBounds", argLength: 2, typ: "Bool"}, // 0 <= arg0 <= arg1. arg1 is guaranteed >= 0. 480 {name: "NilCheck", argLength: 2, nilCheck: true}, // arg0=ptr, arg1=mem. Panics if arg0 is nil. Returns the ptr unmodified. 481 482 // Pseudo-ops 483 {name: "GetG", argLength: 1, zeroWidth: true}, // runtime.getg() (read g pointer). arg0=mem 484 {name: "GetClosurePtr"}, // get closure pointer from dedicated register 485 {name: "GetCallerPC"}, // for getcallerpc intrinsic 486 {name: "GetCallerSP", argLength: 1}, // for getcallersp intrinsic. arg0=mem. 487 488 // Indexing operations 489 {name: "PtrIndex", argLength: 2}, // arg0=ptr, arg1=index. Computes ptr+sizeof(*v.type)*index, where index is extended to ptrwidth type 490 {name: "OffPtr", argLength: 1, aux: "Int64"}, // arg0 + auxint (arg0 and result are pointers) 491 492 // Slices 493 {name: "SliceMake", argLength: 3}, // arg0=ptr, arg1=len, arg2=cap 494 {name: "SlicePtr", argLength: 1, typ: "BytePtr"}, // ptr(arg0) 495 {name: "SliceLen", argLength: 1}, // len(arg0) 496 {name: "SliceCap", argLength: 1}, // cap(arg0) 497 // SlicePtrUnchecked, like SlicePtr, extracts the pointer from a slice. 498 // SlicePtr values are assumed non-nil, because they are guarded by bounds checks. 499 // SlicePtrUnchecked values can be nil. 500 {name: "SlicePtrUnchecked", argLength: 1}, 501 502 // Complex (part/whole) 503 {name: "ComplexMake", argLength: 2}, // arg0=real, arg1=imag 504 {name: "ComplexReal", argLength: 1}, // real(arg0) 505 {name: "ComplexImag", argLength: 1}, // imag(arg0) 506 507 // Strings 508 {name: "StringMake", argLength: 2}, // arg0=ptr, arg1=len 509 {name: "StringPtr", argLength: 1, typ: "BytePtr"}, // ptr(arg0) 510 {name: "StringLen", argLength: 1, typ: "Int"}, // len(arg0) 511 512 // Interfaces 513 {name: "IMake", argLength: 2}, // arg0=itab, arg1=data 514 {name: "ITab", argLength: 1, typ: "Uintptr"}, // arg0=interface, returns itable field 515 {name: "IData", argLength: 1}, // arg0=interface, returns data field 516 517 // Structs 518 {name: "StructMake0"}, // Returns struct with 0 fields. 519 {name: "StructMake1", argLength: 1}, // arg0=field0. Returns struct. 520 {name: "StructMake2", argLength: 2}, // arg0,arg1=field0,field1. Returns struct. 521 {name: "StructMake3", argLength: 3}, // arg0..2=field0..2. Returns struct. 522 {name: "StructMake4", argLength: 4}, // arg0..3=field0..3. Returns struct. 523 {name: "StructSelect", argLength: 1, aux: "Int64"}, // arg0=struct, auxint=field index. Returns the auxint'th field. 524 525 // Arrays 526 {name: "ArrayMake0"}, // Returns array with 0 elements 527 {name: "ArrayMake1", argLength: 1}, // Returns array with 1 element 528 {name: "ArraySelect", argLength: 1, aux: "Int64"}, // arg0=array, auxint=index. Returns a[i]. 529 530 // Spill&restore ops for the register allocator. These are 531 // semantically identical to OpCopy; they do not take/return 532 // stores like regular memory ops do. We can get away without memory 533 // args because we know there is no aliasing of spill slots on the stack. 534 {name: "StoreReg", argLength: 1}, 535 {name: "LoadReg", argLength: 1}, 536 537 // Used during ssa construction. Like Copy, but the arg has not been specified yet. 538 {name: "FwdRef", aux: "Sym", symEffect: "None"}, 539 540 // Unknown value. Used for Values whose values don't matter because they are dead code. 541 {name: "Unknown"}, 542 543 {name: "VarDef", argLength: 1, aux: "Sym", typ: "Mem", symEffect: "None", zeroWidth: true}, // aux is a *gc.Node of a variable that is about to be initialized. arg0=mem, returns mem 544 // TODO: what's the difference between VarLive and KeepAlive? 545 {name: "VarLive", argLength: 1, aux: "Sym", symEffect: "Read", zeroWidth: true}, // aux is a *gc.Node of a variable that must be kept live. arg0=mem, returns mem 546 {name: "KeepAlive", argLength: 2, typ: "Mem", zeroWidth: true}, // arg[0] is a value that must be kept alive until this mark. arg[1]=mem, returns mem 547 548 // InlMark marks the start of an inlined function body. Its AuxInt field 549 // distinguishes which entry in the local inline tree it is marking. 550 {name: "InlMark", argLength: 1, aux: "Int32", typ: "Void"}, // arg[0]=mem, returns void. 551 552 // Ops for breaking 64-bit operations on 32-bit architectures 553 {name: "Int64Make", argLength: 2, typ: "UInt64"}, // arg0=hi, arg1=lo 554 {name: "Int64Hi", argLength: 1, typ: "UInt32"}, // high 32-bit of arg0 555 {name: "Int64Lo", argLength: 1, typ: "UInt32"}, // low 32-bit of arg0 556 557 {name: "Add32carry", argLength: 2, commutative: true, typ: "(UInt32,Flags)"}, // arg0 + arg1, returns (value, carry) 558 {name: "Add32withcarry", argLength: 3, commutative: true}, // arg0 + arg1 + arg2, arg2=carry (0 or 1) 559 560 {name: "Sub32carry", argLength: 2, typ: "(UInt32,Flags)"}, // arg0 - arg1, returns (value, carry) 561 {name: "Sub32withcarry", argLength: 3}, // arg0 - arg1 - arg2, arg2=carry (0 or 1) 562 563 {name: "Add64carry", argLength: 3, commutative: true, typ: "(UInt64,UInt64)"}, // arg0 + arg1 + arg2, arg2 must be 0 or 1. returns (value, value>>64) 564 {name: "Sub64borrow", argLength: 3, typ: "(UInt64,UInt64)"}, // arg0 - (arg1 + arg2), arg2 must be 0 or 1. returns (value, value>>64&1) 565 566 {name: "Signmask", argLength: 1, typ: "Int32"}, // 0 if arg0 >= 0, -1 if arg0 < 0 567 {name: "Zeromask", argLength: 1, typ: "UInt32"}, // 0 if arg0 == 0, 0xffffffff if arg0 != 0 568 {name: "Slicemask", argLength: 1}, // 0 if arg0 == 0, -1 if arg0 > 0, undef if arg0<0. Type is native int size. 569 570 {name: "SpectreIndex", argLength: 2}, // arg0 if 0 <= arg0 < arg1, 0 otherwise. Type is native int size. 571 {name: "SpectreSliceIndex", argLength: 2}, // arg0 if 0 <= arg0 <= arg1, 0 otherwise. Type is native int size. 572 573 {name: "Cvt32Uto32F", argLength: 1}, // uint32 -> float32, only used on 32-bit arch 574 {name: "Cvt32Uto64F", argLength: 1}, // uint32 -> float64, only used on 32-bit arch 575 {name: "Cvt32Fto32U", argLength: 1}, // float32 -> uint32, only used on 32-bit arch 576 {name: "Cvt64Fto32U", argLength: 1}, // float64 -> uint32, only used on 32-bit arch 577 {name: "Cvt64Uto32F", argLength: 1}, // uint64 -> float32, only used on archs that has the instruction 578 {name: "Cvt64Uto64F", argLength: 1}, // uint64 -> float64, only used on archs that has the instruction 579 {name: "Cvt32Fto64U", argLength: 1}, // float32 -> uint64, only used on archs that has the instruction 580 {name: "Cvt64Fto64U", argLength: 1}, // float64 -> uint64, only used on archs that has the instruction 581 582 // pseudo-ops for breaking Tuple 583 {name: "Select0", argLength: 1, zeroWidth: true}, // the first component of a tuple 584 {name: "Select1", argLength: 1, zeroWidth: true}, // the second component of a tuple 585 {name: "SelectN", argLength: 1, aux: "Int64"}, // arg0=result, auxint=field index. Returns the auxint'th member. 586 {name: "SelectNAddr", argLength: 1, aux: "Int64"}, // arg0=result, auxint=field index. Returns the address of auxint'th member. Used for un-SSA-able result types. 587 {name: "MakeResult", argLength: -1}, // arg0 .. are components of a "Result" (like the result from a Call). The last arg should be memory (like the result from a call). 588 589 // Atomic operations used for semantically inlining sync/atomic and 590 // internal/runtime/atomic. Atomic loads return a new memory so that 591 // the loads are properly ordered with respect to other loads and 592 // stores. 593 {name: "AtomicLoad8", argLength: 2, typ: "(UInt8,Mem)"}, // Load from arg0. arg1=memory. Returns loaded value and new memory. 594 {name: "AtomicLoad32", argLength: 2, typ: "(UInt32,Mem)"}, // Load from arg0. arg1=memory. Returns loaded value and new memory. 595 {name: "AtomicLoad64", argLength: 2, typ: "(UInt64,Mem)"}, // Load from arg0. arg1=memory. Returns loaded value and new memory. 596 {name: "AtomicLoadPtr", argLength: 2, typ: "(BytePtr,Mem)"}, // Load from arg0. arg1=memory. Returns loaded value and new memory. 597 {name: "AtomicLoadAcq32", argLength: 2, typ: "(UInt32,Mem)"}, // Load from arg0. arg1=memory. Lock acquisition, returns loaded value and new memory. 598 {name: "AtomicLoadAcq64", argLength: 2, typ: "(UInt64,Mem)"}, // Load from arg0. arg1=memory. Lock acquisition, returns loaded value and new memory. 599 {name: "AtomicStore8", argLength: 3, typ: "Mem", hasSideEffects: true}, // Store arg1 to *arg0. arg2=memory. Returns memory. 600 {name: "AtomicStore32", argLength: 3, typ: "Mem", hasSideEffects: true}, // Store arg1 to *arg0. arg2=memory. Returns memory. 601 {name: "AtomicStore64", argLength: 3, typ: "Mem", hasSideEffects: true}, // Store arg1 to *arg0. arg2=memory. Returns memory. 602 {name: "AtomicStorePtrNoWB", argLength: 3, typ: "Mem", hasSideEffects: true}, // Store arg1 to *arg0. arg2=memory. Returns memory. 603 {name: "AtomicStoreRel32", argLength: 3, typ: "Mem", hasSideEffects: true}, // Store arg1 to *arg0. arg2=memory. Lock release, returns memory. 604 {name: "AtomicStoreRel64", argLength: 3, typ: "Mem", hasSideEffects: true}, // Store arg1 to *arg0. arg2=memory. Lock release, returns memory. 605 {name: "AtomicExchange32", argLength: 3, typ: "(UInt32,Mem)", hasSideEffects: true}, // Store arg1 to *arg0. arg2=memory. Returns old contents of *arg0 and new memory. 606 {name: "AtomicExchange64", argLength: 3, typ: "(UInt64,Mem)", hasSideEffects: true}, // Store arg1 to *arg0. arg2=memory. Returns old contents of *arg0 and new memory. 607 {name: "AtomicAdd32", argLength: 3, typ: "(UInt32,Mem)", hasSideEffects: true}, // Do *arg0 += arg1. arg2=memory. Returns sum and new memory. 608 {name: "AtomicAdd64", argLength: 3, typ: "(UInt64,Mem)", hasSideEffects: true}, // Do *arg0 += arg1. arg2=memory. Returns sum and new memory. 609 {name: "AtomicCompareAndSwap32", argLength: 4, typ: "(Bool,Mem)", hasSideEffects: true}, // if *arg0==arg1, then set *arg0=arg2. Returns true if store happens and new memory. 610 {name: "AtomicCompareAndSwap64", argLength: 4, typ: "(Bool,Mem)", hasSideEffects: true}, // if *arg0==arg1, then set *arg0=arg2. Returns true if store happens and new memory. 611 {name: "AtomicCompareAndSwapRel32", argLength: 4, typ: "(Bool,Mem)", hasSideEffects: true}, // if *arg0==arg1, then set *arg0=arg2. Lock release, reports whether store happens and new memory. 612 {name: "AtomicAnd8", argLength: 3, typ: "(Uint8, Mem)", hasSideEffects: true}, // *arg0 &= arg1. arg2=memory. Returns old contents of *arg0 and new memory. 613 {name: "AtomicOr8", argLength: 3, typ: "(Uint8, Mem)", hasSideEffects: true}, // *arg0 |= arg1. arg2=memory. Returns old contents of *arg0 and new memory. 614 {name: "AtomicAnd64", argLength: 3, typ: "(Uint64, Mem)", hasSideEffects: true}, // *arg0 &= arg1. arg2=memory. Returns old contents of *arg0 and new memory. 615 {name: "AtomicAnd32", argLength: 3, typ: "(Uint32, Mem)", hasSideEffects: true}, // *arg0 &= arg1. arg2=memory. Returns old contents of *arg0 and new memory. 616 {name: "AtomicOr64", argLength: 3, typ: "(Uint64, Mem)", hasSideEffects: true}, // *arg0 |= arg1. arg2=memory. Returns old contents of *arg0 and new memory. 617 {name: "AtomicOr32", argLength: 3, typ: "(Uint32, Mem)", hasSideEffects: true}, // *arg0 |= arg1. arg2=memory. Returns old contents of *arg0 and new memory. 618 619 // Atomic operation variants 620 // These variants have the same semantics as above atomic operations. 621 // But they are used for generating more efficient code on certain modern machines, with run-time CPU feature detection. 622 // On ARM64, these are used when the LSE hardware feature is avaliable (either known at compile time or detected at runtime). If LSE is not avaliable, 623 // then the basic atomic oprations are used instead. 624 // These are not currently used on any other platform. 625 {name: "AtomicAdd32Variant", argLength: 3, typ: "(UInt32,Mem)", hasSideEffects: true}, // Do *arg0 += arg1. arg2=memory. Returns sum and new memory. 626 {name: "AtomicAdd64Variant", argLength: 3, typ: "(UInt64,Mem)", hasSideEffects: true}, // Do *arg0 += arg1. arg2=memory. Returns sum and new memory. 627 {name: "AtomicExchange32Variant", argLength: 3, typ: "(UInt32,Mem)", hasSideEffects: true}, // Store arg1 to *arg0. arg2=memory. Returns old contents of *arg0 and new memory. 628 {name: "AtomicExchange64Variant", argLength: 3, typ: "(UInt64,Mem)", hasSideEffects: true}, // Store arg1 to *arg0. arg2=memory. Returns old contents of *arg0 and new memory. 629 {name: "AtomicCompareAndSwap32Variant", argLength: 4, typ: "(Bool,Mem)", hasSideEffects: true}, // if *arg0==arg1, then set *arg0=arg2. Returns true if store happens and new memory. 630 {name: "AtomicCompareAndSwap64Variant", argLength: 4, typ: "(Bool,Mem)", hasSideEffects: true}, // if *arg0==arg1, then set *arg0=arg2. Returns true if store happens and new memory. 631 {name: "AtomicAnd8Variant", argLength: 3, typ: "(Uint8, Mem)", hasSideEffects: true}, // *arg0 &= arg1. arg2=memory. Returns old contents of *arg0 and new memory. 632 {name: "AtomicOr8Variant", argLength: 3, typ: "(Uint8, Mem)", hasSideEffects: true}, // *arg0 |= arg1. arg2=memory. Returns old contents of *arg0 and new memory. 633 {name: "AtomicAnd64Variant", argLength: 3, typ: "(Uint64, Mem)", hasSideEffects: true}, // *arg0 &= arg1. arg2=memory. Returns old contents of *arg0 and new memory. 634 {name: "AtomicOr64Variant", argLength: 3, typ: "(Uint64, Mem)", hasSideEffects: true}, // *arg0 |= arg1. arg2=memory. Returns old contents of *arg0 and new memory. 635 {name: "AtomicAnd32Variant", argLength: 3, typ: "(Uint32, Mem)", hasSideEffects: true}, // *arg0 &= arg1. arg2=memory. Returns old contents of *arg0 and new memory. 636 {name: "AtomicOr32Variant", argLength: 3, typ: "(Uint32, Mem)", hasSideEffects: true}, // *arg0 |= arg1. arg2=memory. Returns old contents of *arg0 and new memory. 637 638 // Publication barrier 639 {name: "PubBarrier", argLength: 1, hasSideEffects: true}, // Do data barrier. arg0=memory. 640 641 // Clobber experiment op 642 {name: "Clobber", argLength: 0, typ: "Void", aux: "SymOff", symEffect: "None"}, // write an invalid pointer value to the given pointer slot of a stack variable 643 {name: "ClobberReg", argLength: 0, typ: "Void"}, // clobber a register 644 645 // Prefetch instruction 646 {name: "PrefetchCache", argLength: 2, hasSideEffects: true}, // Do prefetch arg0 to cache. arg0=addr, arg1=memory. 647 {name: "PrefetchCacheStreamed", argLength: 2, hasSideEffects: true}, // Do non-temporal or streamed prefetch arg0 to cache. arg0=addr, arg1=memory. 648} 649 650// kind controls successors implicit exit 651// ---------------------------------------------------------- 652// Exit [return mem] [] yes 653// Ret [return mem] [] yes 654// RetJmp [return mem] [] yes 655// Plain [] [next] 656// If [boolean Value] [then, else] 657// First [] [always, never] 658// Defer [mem] [nopanic, panic] (control opcode should be OpStaticCall to runtime.deferproc) 659// JumpTable [integer Value] [succ1,succ2,..] 660 661var genericBlocks = []blockData{ 662 {name: "Plain"}, // a single successor 663 {name: "If", controls: 1}, // if Controls[0] goto Succs[0] else goto Succs[1] 664 {name: "Defer", controls: 1}, // Succs[0]=defer queued, Succs[1]=defer recovered. Controls[0] is call op (of memory type) 665 {name: "Ret", controls: 1}, // no successors, Controls[0] value is memory result 666 {name: "RetJmp", controls: 1}, // no successors, Controls[0] value is a tail call 667 {name: "Exit", controls: 1}, // no successors, Controls[0] value generates a panic 668 {name: "JumpTable", controls: 1}, // multiple successors, the integer Controls[0] selects which one 669 670 // transient block state used for dead code removal 671 {name: "First"}, // 2 successors, always takes the first one (second is dead) 672} 673 674func init() { 675 archs = append(archs, arch{ 676 name: "generic", 677 ops: genericOps, 678 blocks: genericBlocks, 679 generic: true, 680 }) 681} 682