1//===-- BPFInstrInfo.td - Target Description for BPF Target ---------------===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8// 9// This file describes the BPF instructions in TableGen format. 10// 11//===----------------------------------------------------------------------===// 12 13include "BPFInstrFormats.td" 14 15// Instruction Operands and Patterns 16 17// These are target-independent nodes, but have target-specific formats. 18def SDT_BPFCallSeqStart : SDCallSeqStart<[SDTCisVT<0, iPTR>, 19 SDTCisVT<1, iPTR>]>; 20def SDT_BPFCallSeqEnd : SDCallSeqEnd<[SDTCisVT<0, iPTR>, SDTCisVT<1, iPTR>]>; 21def SDT_BPFCall : SDTypeProfile<0, -1, [SDTCisVT<0, iPTR>]>; 22def SDT_BPFSetFlag : SDTypeProfile<0, 3, [SDTCisSameAs<0, 1>]>; 23def SDT_BPFSelectCC : SDTypeProfile<1, 5, [SDTCisSameAs<1, 2>, 24 SDTCisSameAs<0, 4>, 25 SDTCisSameAs<4, 5>]>; 26def SDT_BPFBrCC : SDTypeProfile<0, 4, [SDTCisSameAs<0, 1>, 27 SDTCisVT<3, OtherVT>]>; 28def SDT_BPFWrapper : SDTypeProfile<1, 1, [SDTCisSameAs<0, 1>, 29 SDTCisPtrTy<0>]>; 30def SDT_BPFMEMCPY : SDTypeProfile<0, 4, [SDTCisVT<0, i64>, 31 SDTCisVT<1, i64>, 32 SDTCisVT<2, i64>, 33 SDTCisVT<3, i64>]>; 34 35def BPFcall : SDNode<"BPFISD::CALL", SDT_BPFCall, 36 [SDNPHasChain, SDNPOptInGlue, SDNPOutGlue, 37 SDNPVariadic]>; 38def BPFretflag : SDNode<"BPFISD::RET_FLAG", SDTNone, 39 [SDNPHasChain, SDNPOptInGlue, SDNPVariadic]>; 40def BPFcallseq_start: SDNode<"ISD::CALLSEQ_START", SDT_BPFCallSeqStart, 41 [SDNPHasChain, SDNPOutGlue]>; 42def BPFcallseq_end : SDNode<"ISD::CALLSEQ_END", SDT_BPFCallSeqEnd, 43 [SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]>; 44def BPFbrcc : SDNode<"BPFISD::BR_CC", SDT_BPFBrCC, 45 [SDNPHasChain, SDNPOutGlue, SDNPInGlue]>; 46 47def BPFselectcc : SDNode<"BPFISD::SELECT_CC", SDT_BPFSelectCC, [SDNPInGlue]>; 48def BPFWrapper : SDNode<"BPFISD::Wrapper", SDT_BPFWrapper>; 49def BPFmemcpy : SDNode<"BPFISD::MEMCPY", SDT_BPFMEMCPY, 50 [SDNPHasChain, SDNPInGlue, SDNPOutGlue, 51 SDNPMayStore, SDNPMayLoad]>; 52def BPFIsLittleEndian : Predicate<"CurDAG->getDataLayout().isLittleEndian()">; 53def BPFIsBigEndian : Predicate<"!CurDAG->getDataLayout().isLittleEndian()">; 54def BPFHasALU32 : Predicate<"Subtarget->getHasAlu32()">; 55def BPFNoALU32 : Predicate<"!Subtarget->getHasAlu32()">; 56 57def brtarget : Operand<OtherVT> { 58 let PrintMethod = "printBrTargetOperand"; 59} 60def calltarget : Operand<i64>; 61 62def u64imm : Operand<i64> { 63 let PrintMethod = "printImm64Operand"; 64} 65 66def i64immSExt32 : PatLeaf<(i64 imm), 67 [{return isInt<32>(N->getSExtValue()); }]>; 68def i32immSExt32 : PatLeaf<(i32 imm), 69 [{return isInt<32>(N->getSExtValue()); }]>; 70 71// Addressing modes. 72def ADDRri : ComplexPattern<i64, 2, "SelectAddr", [], []>; 73def FIri : ComplexPattern<i64, 2, "SelectFIAddr", [add, or], []>; 74 75// Address operands 76def MEMri : Operand<i64> { 77 let PrintMethod = "printMemOperand"; 78 let EncoderMethod = "getMemoryOpValue"; 79 let DecoderMethod = "decodeMemoryOpValue"; 80 let MIOperandInfo = (ops GPR, i16imm); 81} 82 83// Conditional code predicates - used for pattern matching for jump instructions 84def BPF_CC_EQ : PatLeaf<(i64 imm), 85 [{return (N->getZExtValue() == ISD::SETEQ);}]>; 86def BPF_CC_NE : PatLeaf<(i64 imm), 87 [{return (N->getZExtValue() == ISD::SETNE);}]>; 88def BPF_CC_GE : PatLeaf<(i64 imm), 89 [{return (N->getZExtValue() == ISD::SETGE);}]>; 90def BPF_CC_GT : PatLeaf<(i64 imm), 91 [{return (N->getZExtValue() == ISD::SETGT);}]>; 92def BPF_CC_GTU : PatLeaf<(i64 imm), 93 [{return (N->getZExtValue() == ISD::SETUGT);}]>; 94def BPF_CC_GEU : PatLeaf<(i64 imm), 95 [{return (N->getZExtValue() == ISD::SETUGE);}]>; 96def BPF_CC_LE : PatLeaf<(i64 imm), 97 [{return (N->getZExtValue() == ISD::SETLE);}]>; 98def BPF_CC_LT : PatLeaf<(i64 imm), 99 [{return (N->getZExtValue() == ISD::SETLT);}]>; 100def BPF_CC_LTU : PatLeaf<(i64 imm), 101 [{return (N->getZExtValue() == ISD::SETULT);}]>; 102def BPF_CC_LEU : PatLeaf<(i64 imm), 103 [{return (N->getZExtValue() == ISD::SETULE);}]>; 104def BPF_CC_EQ_32 : PatLeaf<(i32 imm), 105 [{return (N->getZExtValue() == ISD::SETEQ);}]>; 106def BPF_CC_NE_32 : PatLeaf<(i32 imm), 107 [{return (N->getZExtValue() == ISD::SETNE);}]>; 108def BPF_CC_GE_32 : PatLeaf<(i32 imm), 109 [{return (N->getZExtValue() == ISD::SETGE);}]>; 110def BPF_CC_GT_32 : PatLeaf<(i32 imm), 111 [{return (N->getZExtValue() == ISD::SETGT);}]>; 112def BPF_CC_GTU_32 : PatLeaf<(i32 imm), 113 [{return (N->getZExtValue() == ISD::SETUGT);}]>; 114def BPF_CC_GEU_32 : PatLeaf<(i32 imm), 115 [{return (N->getZExtValue() == ISD::SETUGE);}]>; 116def BPF_CC_LE_32 : PatLeaf<(i32 imm), 117 [{return (N->getZExtValue() == ISD::SETLE);}]>; 118def BPF_CC_LT_32 : PatLeaf<(i32 imm), 119 [{return (N->getZExtValue() == ISD::SETLT);}]>; 120def BPF_CC_LTU_32 : PatLeaf<(i32 imm), 121 [{return (N->getZExtValue() == ISD::SETULT);}]>; 122def BPF_CC_LEU_32 : PatLeaf<(i32 imm), 123 [{return (N->getZExtValue() == ISD::SETULE);}]>; 124 125// For arithmetic and jump instructions the 8-bit 'code' 126// field is divided into three parts: 127// 128// +----------------+--------+--------------------+ 129// | 4 bits | 1 bit | 3 bits | 130// | operation code | source | instruction class | 131// +----------------+--------+--------------------+ 132// (MSB) (LSB) 133class TYPE_ALU_JMP<bits<4> op, bits<1> srctype, 134 dag outs, dag ins, string asmstr, list<dag> pattern> 135 : InstBPF<outs, ins, asmstr, pattern> { 136 137 let Inst{63-60} = op; 138 let Inst{59} = srctype; 139} 140 141//For load and store instructions the 8-bit 'code' field is divided as: 142// 143// +--------+--------+-------------------+ 144// | 3 bits | 2 bits | 3 bits | 145// | mode | size | instruction class | 146// +--------+--------+-------------------+ 147// (MSB) (LSB) 148class TYPE_LD_ST<bits<3> mode, bits<2> size, 149 dag outs, dag ins, string asmstr, list<dag> pattern> 150 : InstBPF<outs, ins, asmstr, pattern> { 151 152 let Inst{63-61} = mode; 153 let Inst{60-59} = size; 154} 155 156// jump instructions 157class JMP_RR<BPFJumpOp Opc, string OpcodeStr, PatLeaf Cond> 158 : TYPE_ALU_JMP<Opc.Value, BPF_X.Value, 159 (outs), 160 (ins GPR:$dst, GPR:$src, brtarget:$BrDst), 161 "if $dst "#OpcodeStr#" $src goto $BrDst", 162 [(BPFbrcc i64:$dst, i64:$src, Cond, bb:$BrDst)]> { 163 bits<4> dst; 164 bits<4> src; 165 bits<16> BrDst; 166 167 let Inst{55-52} = src; 168 let Inst{51-48} = dst; 169 let Inst{47-32} = BrDst; 170 let BPFClass = BPF_JMP; 171} 172 173class JMP_RI<BPFJumpOp Opc, string OpcodeStr, PatLeaf Cond> 174 : TYPE_ALU_JMP<Opc.Value, BPF_K.Value, 175 (outs), 176 (ins GPR:$dst, i64imm:$imm, brtarget:$BrDst), 177 "if $dst "#OpcodeStr#" $imm goto $BrDst", 178 [(BPFbrcc i64:$dst, i64immSExt32:$imm, Cond, bb:$BrDst)]> { 179 bits<4> dst; 180 bits<16> BrDst; 181 bits<32> imm; 182 183 let Inst{51-48} = dst; 184 let Inst{47-32} = BrDst; 185 let Inst{31-0} = imm; 186 let BPFClass = BPF_JMP; 187} 188 189class JMP_RR_32<BPFJumpOp Opc, string OpcodeStr, PatLeaf Cond> 190 : TYPE_ALU_JMP<Opc.Value, BPF_X.Value, 191 (outs), 192 (ins GPR32:$dst, GPR32:$src, brtarget:$BrDst), 193 "if $dst "#OpcodeStr#" $src goto $BrDst", 194 [(BPFbrcc i32:$dst, i32:$src, Cond, bb:$BrDst)]> { 195 bits<4> dst; 196 bits<4> src; 197 bits<16> BrDst; 198 199 let Inst{55-52} = src; 200 let Inst{51-48} = dst; 201 let Inst{47-32} = BrDst; 202 let BPFClass = BPF_JMP32; 203} 204 205class JMP_RI_32<BPFJumpOp Opc, string OpcodeStr, PatLeaf Cond> 206 : TYPE_ALU_JMP<Opc.Value, BPF_K.Value, 207 (outs), 208 (ins GPR32:$dst, i32imm:$imm, brtarget:$BrDst), 209 "if $dst "#OpcodeStr#" $imm goto $BrDst", 210 [(BPFbrcc i32:$dst, i32immSExt32:$imm, Cond, bb:$BrDst)]> { 211 bits<4> dst; 212 bits<16> BrDst; 213 bits<32> imm; 214 215 let Inst{51-48} = dst; 216 let Inst{47-32} = BrDst; 217 let Inst{31-0} = imm; 218 let BPFClass = BPF_JMP32; 219} 220 221multiclass J<BPFJumpOp Opc, string OpcodeStr, PatLeaf Cond, PatLeaf Cond32> { 222 def _rr : JMP_RR<Opc, OpcodeStr, Cond>; 223 def _ri : JMP_RI<Opc, OpcodeStr, Cond>; 224 def _rr_32 : JMP_RR_32<Opc, OpcodeStr, Cond32>; 225 def _ri_32 : JMP_RI_32<Opc, OpcodeStr, Cond32>; 226} 227 228let isBranch = 1, isTerminator = 1, hasDelaySlot=0 in { 229// cmp+goto instructions 230defm JEQ : J<BPF_JEQ, "==", BPF_CC_EQ, BPF_CC_EQ_32>; 231defm JUGT : J<BPF_JGT, ">", BPF_CC_GTU, BPF_CC_GTU_32>; 232defm JUGE : J<BPF_JGE, ">=", BPF_CC_GEU, BPF_CC_GEU_32>; 233defm JNE : J<BPF_JNE, "!=", BPF_CC_NE, BPF_CC_NE_32>; 234defm JSGT : J<BPF_JSGT, "s>", BPF_CC_GT, BPF_CC_GT_32>; 235defm JSGE : J<BPF_JSGE, "s>=", BPF_CC_GE, BPF_CC_GE_32>; 236defm JULT : J<BPF_JLT, "<", BPF_CC_LTU, BPF_CC_LTU_32>; 237defm JULE : J<BPF_JLE, "<=", BPF_CC_LEU, BPF_CC_LEU_32>; 238defm JSLT : J<BPF_JSLT, "s<", BPF_CC_LT, BPF_CC_LT_32>; 239defm JSLE : J<BPF_JSLE, "s<=", BPF_CC_LE, BPF_CC_LE_32>; 240} 241 242// ALU instructions 243class ALU_RI<BPFOpClass Class, BPFArithOp Opc, 244 dag outs, dag ins, string asmstr, list<dag> pattern> 245 : TYPE_ALU_JMP<Opc.Value, BPF_K.Value, outs, ins, asmstr, pattern> { 246 bits<4> dst; 247 bits<32> imm; 248 249 let Inst{51-48} = dst; 250 let Inst{31-0} = imm; 251 let BPFClass = Class; 252} 253 254class ALU_RR<BPFOpClass Class, BPFArithOp Opc, 255 dag outs, dag ins, string asmstr, list<dag> pattern> 256 : TYPE_ALU_JMP<Opc.Value, BPF_X.Value, outs, ins, asmstr, pattern> { 257 bits<4> dst; 258 bits<4> src; 259 260 let Inst{55-52} = src; 261 let Inst{51-48} = dst; 262 let BPFClass = Class; 263} 264 265multiclass ALU<BPFArithOp Opc, string OpcodeStr, SDNode OpNode> { 266 def _rr : ALU_RR<BPF_ALU64, Opc, 267 (outs GPR:$dst), 268 (ins GPR:$src2, GPR:$src), 269 "$dst "#OpcodeStr#" $src", 270 [(set GPR:$dst, (OpNode i64:$src2, i64:$src))]>; 271 def _ri : ALU_RI<BPF_ALU64, Opc, 272 (outs GPR:$dst), 273 (ins GPR:$src2, i64imm:$imm), 274 "$dst "#OpcodeStr#" $imm", 275 [(set GPR:$dst, (OpNode GPR:$src2, i64immSExt32:$imm))]>; 276 def _rr_32 : ALU_RR<BPF_ALU, Opc, 277 (outs GPR32:$dst), 278 (ins GPR32:$src2, GPR32:$src), 279 "$dst "#OpcodeStr#" $src", 280 [(set GPR32:$dst, (OpNode i32:$src2, i32:$src))]>; 281 def _ri_32 : ALU_RI<BPF_ALU, Opc, 282 (outs GPR32:$dst), 283 (ins GPR32:$src2, i32imm:$imm), 284 "$dst "#OpcodeStr#" $imm", 285 [(set GPR32:$dst, (OpNode GPR32:$src2, i32immSExt32:$imm))]>; 286} 287 288let Constraints = "$dst = $src2" in { 289let isAsCheapAsAMove = 1 in { 290 defm ADD : ALU<BPF_ADD, "+=", add>; 291 defm SUB : ALU<BPF_SUB, "-=", sub>; 292 defm OR : ALU<BPF_OR, "|=", or>; 293 defm AND : ALU<BPF_AND, "&=", and>; 294 defm SLL : ALU<BPF_LSH, "<<=", shl>; 295 defm SRL : ALU<BPF_RSH, ">>=", srl>; 296 defm XOR : ALU<BPF_XOR, "^=", xor>; 297 defm SRA : ALU<BPF_ARSH, "s>>=", sra>; 298} 299 defm MUL : ALU<BPF_MUL, "*=", mul>; 300 defm DIV : ALU<BPF_DIV, "/=", udiv>; 301} 302 303class NEG_RR<BPFOpClass Class, BPFArithOp Opc, 304 dag outs, dag ins, string asmstr, list<dag> pattern> 305 : TYPE_ALU_JMP<Opc.Value, 0, outs, ins, asmstr, pattern> { 306 bits<4> dst; 307 308 let Inst{51-48} = dst; 309 let BPFClass = Class; 310} 311 312let Constraints = "$dst = $src", isAsCheapAsAMove = 1 in { 313 def NEG_64: NEG_RR<BPF_ALU64, BPF_NEG, (outs GPR:$dst), (ins GPR:$src), 314 "$dst = -$src", 315 [(set GPR:$dst, (ineg i64:$src))]>; 316 def NEG_32: NEG_RR<BPF_ALU, BPF_NEG, (outs GPR32:$dst), (ins GPR32:$src), 317 "$dst = -$src", 318 [(set GPR32:$dst, (ineg i32:$src))]>; 319} 320 321class LD_IMM64<bits<4> Pseudo, string OpcodeStr> 322 : TYPE_LD_ST<BPF_IMM.Value, BPF_DW.Value, 323 (outs GPR:$dst), 324 (ins u64imm:$imm), 325 "$dst "#OpcodeStr#" ${imm} ll", 326 [(set GPR:$dst, (i64 imm:$imm))]> { 327 328 bits<4> dst; 329 bits<64> imm; 330 331 let Inst{51-48} = dst; 332 let Inst{55-52} = Pseudo; 333 let Inst{47-32} = 0; 334 let Inst{31-0} = imm{31-0}; 335 let BPFClass = BPF_LD; 336} 337 338let isReMaterializable = 1, isAsCheapAsAMove = 1 in { 339def LD_imm64 : LD_IMM64<0, "=">; 340def MOV_rr : ALU_RR<BPF_ALU64, BPF_MOV, 341 (outs GPR:$dst), 342 (ins GPR:$src), 343 "$dst = $src", 344 []>; 345def MOV_ri : ALU_RI<BPF_ALU64, BPF_MOV, 346 (outs GPR:$dst), 347 (ins i64imm:$imm), 348 "$dst = $imm", 349 [(set GPR:$dst, (i64 i64immSExt32:$imm))]>; 350def MOV_rr_32 : ALU_RR<BPF_ALU, BPF_MOV, 351 (outs GPR32:$dst), 352 (ins GPR32:$src), 353 "$dst = $src", 354 []>; 355def MOV_ri_32 : ALU_RI<BPF_ALU, BPF_MOV, 356 (outs GPR32:$dst), 357 (ins i32imm:$imm), 358 "$dst = $imm", 359 [(set GPR32:$dst, (i32 i32immSExt32:$imm))]>; 360} 361 362def FI_ri 363 : TYPE_LD_ST<BPF_IMM.Value, BPF_DW.Value, 364 (outs GPR:$dst), 365 (ins MEMri:$addr), 366 "lea\t$dst, $addr", 367 [(set i64:$dst, FIri:$addr)]> { 368 // This is a tentative instruction, and will be replaced 369 // with MOV_rr and ADD_ri in PEI phase 370 let Inst{51-48} = 0; 371 let Inst{55-52} = 2; 372 let Inst{47-32} = 0; 373 let Inst{31-0} = 0; 374 let BPFClass = BPF_LD; 375} 376 377def LD_pseudo 378 : TYPE_LD_ST<BPF_IMM.Value, BPF_DW.Value, 379 (outs GPR:$dst), 380 (ins i64imm:$pseudo, u64imm:$imm), 381 "ld_pseudo\t$dst, $pseudo, $imm", 382 [(set GPR:$dst, (int_bpf_pseudo imm:$pseudo, imm:$imm))]> { 383 384 bits<4> dst; 385 bits<64> imm; 386 bits<4> pseudo; 387 388 let Inst{51-48} = dst; 389 let Inst{55-52} = pseudo; 390 let Inst{47-32} = 0; 391 let Inst{31-0} = imm{31-0}; 392 let BPFClass = BPF_LD; 393} 394 395// STORE instructions 396class STORE<BPFWidthModifer SizeOp, string OpcodeStr, list<dag> Pattern> 397 : TYPE_LD_ST<BPF_MEM.Value, SizeOp.Value, 398 (outs), 399 (ins GPR:$src, MEMri:$addr), 400 "*("#OpcodeStr#" *)($addr) = $src", 401 Pattern> { 402 bits<4> src; 403 bits<20> addr; 404 405 let Inst{51-48} = addr{19-16}; // base reg 406 let Inst{55-52} = src; 407 let Inst{47-32} = addr{15-0}; // offset 408 let BPFClass = BPF_STX; 409} 410 411class STOREi64<BPFWidthModifer Opc, string OpcodeStr, PatFrag OpNode> 412 : STORE<Opc, OpcodeStr, [(OpNode i64:$src, ADDRri:$addr)]>; 413 414let Predicates = [BPFNoALU32] in { 415 def STW : STOREi64<BPF_W, "u32", truncstorei32>; 416 def STH : STOREi64<BPF_H, "u16", truncstorei16>; 417 def STB : STOREi64<BPF_B, "u8", truncstorei8>; 418} 419def STD : STOREi64<BPF_DW, "u64", store>; 420 421// LOAD instructions 422class LOAD<BPFWidthModifer SizeOp, string OpcodeStr, list<dag> Pattern> 423 : TYPE_LD_ST<BPF_MEM.Value, SizeOp.Value, 424 (outs GPR:$dst), 425 (ins MEMri:$addr), 426 "$dst = *("#OpcodeStr#" *)($addr)", 427 Pattern> { 428 bits<4> dst; 429 bits<20> addr; 430 431 let Inst{51-48} = dst; 432 let Inst{55-52} = addr{19-16}; 433 let Inst{47-32} = addr{15-0}; 434 let BPFClass = BPF_LDX; 435} 436 437class LOADi64<BPFWidthModifer SizeOp, string OpcodeStr, PatFrag OpNode> 438 : LOAD<SizeOp, OpcodeStr, [(set i64:$dst, (OpNode ADDRri:$addr))]>; 439 440let isCodeGenOnly = 1 in { 441 def CORE_MEM : TYPE_LD_ST<BPF_MEM.Value, BPF_W.Value, 442 (outs GPR:$dst), 443 (ins u64imm:$opcode, GPR:$src, u64imm:$offset), 444 "$dst = core_mem($opcode, $src, $offset)", 445 []>; 446 def CORE_ALU32_MEM : TYPE_LD_ST<BPF_MEM.Value, BPF_W.Value, 447 (outs GPR32:$dst), 448 (ins u64imm:$opcode, GPR:$src, u64imm:$offset), 449 "$dst = core_alu32_mem($opcode, $src, $offset)", 450 []>; 451 let Constraints = "$dst = $src" in { 452 def CORE_SHIFT : ALU_RR<BPF_ALU64, BPF_LSH, 453 (outs GPR:$dst), 454 (ins u64imm:$opcode, GPR:$src, u64imm:$offset), 455 "$dst = core_shift($opcode, $src, $offset)", 456 []>; 457 } 458} 459 460let Predicates = [BPFNoALU32] in { 461 def LDW : LOADi64<BPF_W, "u32", zextloadi32>; 462 def LDH : LOADi64<BPF_H, "u16", zextloadi16>; 463 def LDB : LOADi64<BPF_B, "u8", zextloadi8>; 464} 465 466def LDD : LOADi64<BPF_DW, "u64", load>; 467 468class BRANCH<BPFJumpOp Opc, string OpcodeStr, list<dag> Pattern> 469 : TYPE_ALU_JMP<Opc.Value, BPF_K.Value, 470 (outs), 471 (ins brtarget:$BrDst), 472 !strconcat(OpcodeStr, " $BrDst"), 473 Pattern> { 474 bits<16> BrDst; 475 476 let Inst{47-32} = BrDst; 477 let BPFClass = BPF_JMP; 478} 479 480class CALL<string OpcodeStr> 481 : TYPE_ALU_JMP<BPF_CALL.Value, BPF_K.Value, 482 (outs), 483 (ins calltarget:$BrDst), 484 !strconcat(OpcodeStr, " $BrDst"), 485 []> { 486 bits<32> BrDst; 487 488 let Inst{31-0} = BrDst; 489 let BPFClass = BPF_JMP; 490} 491 492class CALLX<string OpcodeStr> 493 : TYPE_ALU_JMP<BPF_CALL.Value, BPF_X.Value, 494 (outs), 495 (ins GPR:$BrDst), 496 !strconcat(OpcodeStr, " $BrDst"), 497 []> { 498 bits<32> BrDst; 499 500 let Inst{31-0} = BrDst; 501 let BPFClass = BPF_JMP; 502} 503 504// Jump always 505let isBranch = 1, isTerminator = 1, hasDelaySlot=0, isBarrier = 1 in { 506 def JMP : BRANCH<BPF_JA, "goto", [(br bb:$BrDst)]>; 507} 508 509// Jump and link 510let isCall=1, hasDelaySlot=0, Uses = [R11], 511 // Potentially clobbered registers 512 Defs = [R0, R1, R2, R3, R4, R5] in { 513 def JAL : CALL<"call">; 514 def JALX : CALLX<"callx">; 515} 516 517class NOP_I<string OpcodeStr> 518 : TYPE_ALU_JMP<BPF_MOV.Value, BPF_X.Value, 519 (outs), 520 (ins i32imm:$imm), 521 !strconcat(OpcodeStr, "\t$imm"), 522 []> { 523 // mov r0, r0 == nop 524 let Inst{55-52} = 0; 525 let Inst{51-48} = 0; 526 let BPFClass = BPF_ALU64; 527} 528 529let hasSideEffects = 0, isCodeGenOnly = 1 in 530 def NOP : NOP_I<"nop">; 531 532class RET<string OpcodeStr> 533 : TYPE_ALU_JMP<BPF_EXIT.Value, BPF_K.Value, 534 (outs), 535 (ins), 536 !strconcat(OpcodeStr, ""), 537 [(BPFretflag)]> { 538 let Inst{31-0} = 0; 539 let BPFClass = BPF_JMP; 540} 541 542let isReturn = 1, isTerminator = 1, hasDelaySlot=0, isBarrier = 1, 543 isNotDuplicable = 1 in { 544 def RET : RET<"exit">; 545} 546 547// ADJCALLSTACKDOWN/UP pseudo insns 548let Defs = [R11], Uses = [R11], isCodeGenOnly = 1 in { 549def ADJCALLSTACKDOWN : Pseudo<(outs), (ins i64imm:$amt1, i64imm:$amt2), 550 "#ADJCALLSTACKDOWN $amt1 $amt2", 551 [(BPFcallseq_start timm:$amt1, timm:$amt2)]>; 552def ADJCALLSTACKUP : Pseudo<(outs), (ins i64imm:$amt1, i64imm:$amt2), 553 "#ADJCALLSTACKUP $amt1 $amt2", 554 [(BPFcallseq_end timm:$amt1, timm:$amt2)]>; 555} 556 557let usesCustomInserter = 1, isCodeGenOnly = 1 in { 558 def Select : Pseudo<(outs GPR:$dst), 559 (ins GPR:$lhs, GPR:$rhs, i64imm:$imm, GPR:$src, GPR:$src2), 560 "# Select PSEUDO $dst = $lhs $imm $rhs ? $src : $src2", 561 [(set i64:$dst, 562 (BPFselectcc i64:$lhs, i64:$rhs, (i64 imm:$imm), i64:$src, i64:$src2))]>; 563 def Select_Ri : Pseudo<(outs GPR:$dst), 564 (ins GPR:$lhs, i64imm:$rhs, i64imm:$imm, GPR:$src, GPR:$src2), 565 "# Select PSEUDO $dst = $lhs $imm $rhs ? $src : $src2", 566 [(set i64:$dst, 567 (BPFselectcc i64:$lhs, (i64immSExt32:$rhs), (i64 imm:$imm), i64:$src, i64:$src2))]>; 568 def Select_64_32 : Pseudo<(outs GPR32:$dst), 569 (ins GPR:$lhs, GPR:$rhs, i64imm:$imm, GPR32:$src, GPR32:$src2), 570 "# Select PSEUDO $dst = $lhs $imm $rhs ? $src : $src2", 571 [(set i32:$dst, 572 (BPFselectcc i64:$lhs, i64:$rhs, (i64 imm:$imm), i32:$src, i32:$src2))]>; 573 def Select_Ri_64_32 : Pseudo<(outs GPR32:$dst), 574 (ins GPR:$lhs, i64imm:$rhs, i64imm:$imm, GPR32:$src, GPR32:$src2), 575 "# Select PSEUDO $dst = $lhs $imm $rhs ? $src : $src2", 576 [(set i32:$dst, 577 (BPFselectcc i64:$lhs, (i64immSExt32:$rhs), (i64 imm:$imm), i32:$src, i32:$src2))]>; 578 def Select_32 : Pseudo<(outs GPR32:$dst), 579 (ins GPR32:$lhs, GPR32:$rhs, i32imm:$imm, GPR32:$src, GPR32:$src2), 580 "# Select PSEUDO $dst = $lhs $imm $rhs ? $src : $src2", 581 [(set i32:$dst, 582 (BPFselectcc i32:$lhs, i32:$rhs, (i32 imm:$imm), i32:$src, i32:$src2))]>; 583 def Select_Ri_32 : Pseudo<(outs GPR32:$dst), 584 (ins GPR32:$lhs, i32imm:$rhs, i32imm:$imm, GPR32:$src, GPR32:$src2), 585 "# Select PSEUDO $dst = $lhs $imm $rhs ? $src : $src2", 586 [(set i32:$dst, 587 (BPFselectcc i32:$lhs, (i32immSExt32:$rhs), (i32 imm:$imm), i32:$src, i32:$src2))]>; 588 def Select_32_64 : Pseudo<(outs GPR:$dst), 589 (ins GPR32:$lhs, GPR32:$rhs, i32imm:$imm, GPR:$src, GPR:$src2), 590 "# Select PSEUDO $dst = $lhs $imm $rhs ? $src : $src2", 591 [(set i64:$dst, 592 (BPFselectcc i32:$lhs, i32:$rhs, (i32 imm:$imm), i64:$src, i64:$src2))]>; 593 def Select_Ri_32_64 : Pseudo<(outs GPR:$dst), 594 (ins GPR32:$lhs, i32imm:$rhs, i32imm:$imm, GPR:$src, GPR:$src2), 595 "# Select PSEUDO $dst = $lhs $imm $rhs ? $src : $src2", 596 [(set i64:$dst, 597 (BPFselectcc i32:$lhs, (i32immSExt32:$rhs), (i32 imm:$imm), i64:$src, i64:$src2))]>; 598} 599 600// load 64-bit global addr into register 601def : Pat<(BPFWrapper tglobaladdr:$in), (LD_imm64 tglobaladdr:$in)>; 602 603// 0xffffFFFF doesn't fit into simm32, optimize common case 604def : Pat<(i64 (and (i64 GPR:$src), 0xffffFFFF)), 605 (SRL_ri (SLL_ri (i64 GPR:$src), 32), 32)>; 606 607// Calls 608def : Pat<(BPFcall tglobaladdr:$dst), (JAL tglobaladdr:$dst)>; 609def : Pat<(BPFcall texternalsym:$dst), (JAL texternalsym:$dst)>; 610def : Pat<(BPFcall imm:$dst), (JAL imm:$dst)>; 611def : Pat<(BPFcall GPR:$dst), (JALX GPR:$dst)>; 612 613// Loads 614let Predicates = [BPFNoALU32] in { 615 def : Pat<(i64 (extloadi8 ADDRri:$src)), (i64 (LDB ADDRri:$src))>; 616 def : Pat<(i64 (extloadi16 ADDRri:$src)), (i64 (LDH ADDRri:$src))>; 617 def : Pat<(i64 (extloadi32 ADDRri:$src)), (i64 (LDW ADDRri:$src))>; 618} 619 620// Atomics 621class XADD<BPFWidthModifer SizeOp, string OpcodeStr, PatFrag OpNode> 622 : TYPE_LD_ST<BPF_XADD.Value, SizeOp.Value, 623 (outs GPR:$dst), 624 (ins MEMri:$addr, GPR:$val), 625 "lock *("#OpcodeStr#" *)($addr) += $val", 626 [(set GPR:$dst, (OpNode ADDRri:$addr, GPR:$val))]> { 627 bits<4> dst; 628 bits<20> addr; 629 630 let Inst{51-48} = addr{19-16}; // base reg 631 let Inst{55-52} = dst; 632 let Inst{47-32} = addr{15-0}; // offset 633 let BPFClass = BPF_STX; 634} 635 636class XADD32<BPFWidthModifer SizeOp, string OpcodeStr, PatFrag OpNode> 637 : TYPE_LD_ST<BPF_XADD.Value, SizeOp.Value, 638 (outs GPR32:$dst), 639 (ins MEMri:$addr, GPR32:$val), 640 "lock *("#OpcodeStr#" *)($addr) += $val", 641 [(set GPR32:$dst, (OpNode ADDRri:$addr, GPR32:$val))]> { 642 bits<4> dst; 643 bits<20> addr; 644 645 let Inst{51-48} = addr{19-16}; // base reg 646 let Inst{55-52} = dst; 647 let Inst{47-32} = addr{15-0}; // offset 648 let BPFClass = BPF_STX; 649} 650 651let Constraints = "$dst = $val" in { 652 let Predicates = [BPFNoALU32] in { 653 def XADDW : XADD<BPF_W, "u32", atomic_load_add_32>; 654 } 655 656 let Predicates = [BPFHasALU32], DecoderNamespace = "BPFALU32" in { 657 def XADDW32 : XADD32<BPF_W, "u32", atomic_load_add_32>; 658 } 659 660 def XADDD : XADD<BPF_DW, "u64", atomic_load_add_64>; 661} 662 663// bswap16, bswap32, bswap64 664class BSWAP<bits<32> SizeOp, string OpcodeStr, BPFSrcType SrcType, list<dag> Pattern> 665 : TYPE_ALU_JMP<BPF_END.Value, SrcType.Value, 666 (outs GPR:$dst), 667 (ins GPR:$src), 668 "$dst = "#OpcodeStr#" $src", 669 Pattern> { 670 bits<4> dst; 671 672 let Inst{51-48} = dst; 673 let Inst{31-0} = SizeOp; 674 let BPFClass = BPF_ALU; 675} 676 677 678let Constraints = "$dst = $src" in { 679 let Predicates = [BPFIsLittleEndian] in { 680 def BE16 : BSWAP<16, "be16", BPF_TO_BE, [(set GPR:$dst, (srl (bswap GPR:$src), (i64 48)))]>; 681 def BE32 : BSWAP<32, "be32", BPF_TO_BE, [(set GPR:$dst, (srl (bswap GPR:$src), (i64 32)))]>; 682 def BE64 : BSWAP<64, "be64", BPF_TO_BE, [(set GPR:$dst, (bswap GPR:$src))]>; 683 } 684 let Predicates = [BPFIsBigEndian] in { 685 def LE16 : BSWAP<16, "le16", BPF_TO_LE, [(set GPR:$dst, (srl (bswap GPR:$src), (i64 48)))]>; 686 def LE32 : BSWAP<32, "le32", BPF_TO_LE, [(set GPR:$dst, (srl (bswap GPR:$src), (i64 32)))]>; 687 def LE64 : BSWAP<64, "le64", BPF_TO_LE, [(set GPR:$dst, (bswap GPR:$src))]>; 688 } 689} 690 691let Defs = [R0, R1, R2, R3, R4, R5], Uses = [R6], hasSideEffects = 1, 692 hasExtraDefRegAllocReq = 1, hasExtraSrcRegAllocReq = 1, mayLoad = 1 in { 693class LOAD_ABS<BPFWidthModifer SizeOp, string OpcodeStr, Intrinsic OpNode> 694 : TYPE_LD_ST<BPF_ABS.Value, SizeOp.Value, 695 (outs), 696 (ins GPR:$skb, i64imm:$imm), 697 "r0 = *("#OpcodeStr#" *)skb[$imm]", 698 [(set R0, (OpNode GPR:$skb, i64immSExt32:$imm))]> { 699 bits<32> imm; 700 701 let Inst{31-0} = imm; 702 let BPFClass = BPF_LD; 703} 704 705class LOAD_IND<BPFWidthModifer SizeOp, string OpcodeStr, Intrinsic OpNode> 706 : TYPE_LD_ST<BPF_IND.Value, SizeOp.Value, 707 (outs), 708 (ins GPR:$skb, GPR:$val), 709 "r0 = *("#OpcodeStr#" *)skb[$val]", 710 [(set R0, (OpNode GPR:$skb, GPR:$val))]> { 711 bits<4> val; 712 713 let Inst{55-52} = val; 714 let BPFClass = BPF_LD; 715} 716} 717 718def LD_ABS_B : LOAD_ABS<BPF_B, "u8", int_bpf_load_byte>; 719def LD_ABS_H : LOAD_ABS<BPF_H, "u16", int_bpf_load_half>; 720def LD_ABS_W : LOAD_ABS<BPF_W, "u32", int_bpf_load_word>; 721 722def LD_IND_B : LOAD_IND<BPF_B, "u8", int_bpf_load_byte>; 723def LD_IND_H : LOAD_IND<BPF_H, "u16", int_bpf_load_half>; 724def LD_IND_W : LOAD_IND<BPF_W, "u32", int_bpf_load_word>; 725 726let isCodeGenOnly = 1 in { 727 def MOV_32_64 : ALU_RR<BPF_ALU, BPF_MOV, 728 (outs GPR:$dst), (ins GPR32:$src), 729 "$dst = $src", []>; 730} 731 732def : Pat<(i64 (sext GPR32:$src)), 733 (SRA_ri (SLL_ri (MOV_32_64 GPR32:$src), 32), 32)>; 734 735def : Pat<(i64 (zext GPR32:$src)), (MOV_32_64 GPR32:$src)>; 736 737// For i64 -> i32 truncation, use the 32-bit subregister directly. 738def : Pat<(i32 (trunc GPR:$src)), 739 (i32 (EXTRACT_SUBREG GPR:$src, sub_32))>; 740 741// For i32 -> i64 anyext, we don't care about the high bits. 742def : Pat<(i64 (anyext GPR32:$src)), 743 (INSERT_SUBREG (i64 (IMPLICIT_DEF)), GPR32:$src, sub_32)>; 744 745class STORE32<BPFWidthModifer SizeOp, string OpcodeStr, list<dag> Pattern> 746 : TYPE_LD_ST<BPF_MEM.Value, SizeOp.Value, 747 (outs), 748 (ins GPR32:$src, MEMri:$addr), 749 "*("#OpcodeStr#" *)($addr) = $src", 750 Pattern> { 751 bits<4> src; 752 bits<20> addr; 753 754 let Inst{51-48} = addr{19-16}; // base reg 755 let Inst{55-52} = src; 756 let Inst{47-32} = addr{15-0}; // offset 757 let BPFClass = BPF_STX; 758} 759 760class STOREi32<BPFWidthModifer Opc, string OpcodeStr, PatFrag OpNode> 761 : STORE32<Opc, OpcodeStr, [(OpNode i32:$src, ADDRri:$addr)]>; 762 763let Predicates = [BPFHasALU32], DecoderNamespace = "BPFALU32" in { 764 def STW32 : STOREi32<BPF_W, "u32", store>; 765 def STH32 : STOREi32<BPF_H, "u16", truncstorei16>; 766 def STB32 : STOREi32<BPF_B, "u8", truncstorei8>; 767} 768 769class LOAD32<BPFWidthModifer SizeOp, string OpcodeStr, list<dag> Pattern> 770 : TYPE_LD_ST<BPF_MEM.Value, SizeOp.Value, 771 (outs GPR32:$dst), 772 (ins MEMri:$addr), 773 "$dst = *("#OpcodeStr#" *)($addr)", 774 Pattern> { 775 bits<4> dst; 776 bits<20> addr; 777 778 let Inst{51-48} = dst; 779 let Inst{55-52} = addr{19-16}; 780 let Inst{47-32} = addr{15-0}; 781 let BPFClass = BPF_LDX; 782} 783 784class LOADi32<BPFWidthModifer SizeOp, string OpcodeStr, PatFrag OpNode> 785 : LOAD32<SizeOp, OpcodeStr, [(set i32:$dst, (OpNode ADDRri:$addr))]>; 786 787let Predicates = [BPFHasALU32], DecoderNamespace = "BPFALU32" in { 788 def LDW32 : LOADi32<BPF_W, "u32", load>; 789 def LDH32 : LOADi32<BPF_H, "u16", zextloadi16>; 790 def LDB32 : LOADi32<BPF_B, "u8", zextloadi8>; 791} 792 793let Predicates = [BPFHasALU32] in { 794 def : Pat<(truncstorei8 GPR:$src, ADDRri:$dst), 795 (STB32 (EXTRACT_SUBREG GPR:$src, sub_32), ADDRri:$dst)>; 796 def : Pat<(truncstorei16 GPR:$src, ADDRri:$dst), 797 (STH32 (EXTRACT_SUBREG GPR:$src, sub_32), ADDRri:$dst)>; 798 def : Pat<(truncstorei32 GPR:$src, ADDRri:$dst), 799 (STW32 (EXTRACT_SUBREG GPR:$src, sub_32), ADDRri:$dst)>; 800 def : Pat<(i32 (extloadi8 ADDRri:$src)), (i32 (LDB32 ADDRri:$src))>; 801 def : Pat<(i32 (extloadi16 ADDRri:$src)), (i32 (LDH32 ADDRri:$src))>; 802 def : Pat<(i64 (zextloadi8 ADDRri:$src)), 803 (SUBREG_TO_REG (i64 0), (LDB32 ADDRri:$src), sub_32)>; 804 def : Pat<(i64 (zextloadi16 ADDRri:$src)), 805 (SUBREG_TO_REG (i64 0), (LDH32 ADDRri:$src), sub_32)>; 806 def : Pat<(i64 (zextloadi32 ADDRri:$src)), 807 (SUBREG_TO_REG (i64 0), (LDW32 ADDRri:$src), sub_32)>; 808 def : Pat<(i64 (extloadi8 ADDRri:$src)), 809 (SUBREG_TO_REG (i64 0), (LDB32 ADDRri:$src), sub_32)>; 810 def : Pat<(i64 (extloadi16 ADDRri:$src)), 811 (SUBREG_TO_REG (i64 0), (LDH32 ADDRri:$src), sub_32)>; 812 def : Pat<(i64 (extloadi32 ADDRri:$src)), 813 (SUBREG_TO_REG (i64 0), (LDW32 ADDRri:$src), sub_32)>; 814} 815 816let usesCustomInserter = 1, isCodeGenOnly = 1 in { 817 def MEMCPY : Pseudo< 818 (outs), 819 (ins GPR:$dst, GPR:$src, i64imm:$len, i64imm:$align, variable_ops), 820 "#memcpy dst: $dst, src: $src, len: $len, align: $align", 821 [(BPFmemcpy GPR:$dst, GPR:$src, imm:$len, imm:$align)]>; 822} 823