BPFInstrInfo.td revision 353358
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 440 441let Predicates = [BPFNoALU32] in { 442 def LDW : LOADi64<BPF_W, "u32", zextloadi32>; 443 def LDH : LOADi64<BPF_H, "u16", zextloadi16>; 444 def LDB : LOADi64<BPF_B, "u8", zextloadi8>; 445} 446 447def LDD : LOADi64<BPF_DW, "u64", load>; 448 449class BRANCH<BPFJumpOp Opc, string OpcodeStr, list<dag> Pattern> 450 : TYPE_ALU_JMP<Opc.Value, BPF_K.Value, 451 (outs), 452 (ins brtarget:$BrDst), 453 !strconcat(OpcodeStr, " $BrDst"), 454 Pattern> { 455 bits<16> BrDst; 456 457 let Inst{47-32} = BrDst; 458 let BPFClass = BPF_JMP; 459} 460 461class CALL<string OpcodeStr> 462 : TYPE_ALU_JMP<BPF_CALL.Value, BPF_K.Value, 463 (outs), 464 (ins calltarget:$BrDst), 465 !strconcat(OpcodeStr, " $BrDst"), 466 []> { 467 bits<32> BrDst; 468 469 let Inst{31-0} = BrDst; 470 let BPFClass = BPF_JMP; 471} 472 473class CALLX<string OpcodeStr> 474 : TYPE_ALU_JMP<BPF_CALL.Value, BPF_X.Value, 475 (outs), 476 (ins calltarget:$BrDst), 477 !strconcat(OpcodeStr, " $BrDst"), 478 []> { 479 bits<32> BrDst; 480 481 let Inst{31-0} = BrDst; 482 let BPFClass = BPF_JMP; 483} 484 485// Jump always 486let isBranch = 1, isTerminator = 1, hasDelaySlot=0, isBarrier = 1 in { 487 def JMP : BRANCH<BPF_JA, "goto", [(br bb:$BrDst)]>; 488} 489 490// Jump and link 491let isCall=1, hasDelaySlot=0, Uses = [R11], 492 // Potentially clobbered registers 493 Defs = [R0, R1, R2, R3, R4, R5] in { 494 def JAL : CALL<"call">; 495 def JALX : CALLX<"callx">; 496} 497 498class NOP_I<string OpcodeStr> 499 : TYPE_ALU_JMP<BPF_MOV.Value, BPF_X.Value, 500 (outs), 501 (ins i32imm:$imm), 502 !strconcat(OpcodeStr, "\t$imm"), 503 []> { 504 // mov r0, r0 == nop 505 let Inst{55-52} = 0; 506 let Inst{51-48} = 0; 507 let BPFClass = BPF_ALU64; 508} 509 510let hasSideEffects = 0 in 511 def NOP : NOP_I<"nop">; 512 513class RET<string OpcodeStr> 514 : TYPE_ALU_JMP<BPF_EXIT.Value, BPF_K.Value, 515 (outs), 516 (ins), 517 !strconcat(OpcodeStr, ""), 518 [(BPFretflag)]> { 519 let Inst{31-0} = 0; 520 let BPFClass = BPF_JMP; 521} 522 523let isReturn = 1, isTerminator = 1, hasDelaySlot=0, isBarrier = 1, 524 isNotDuplicable = 1 in { 525 def RET : RET<"exit">; 526} 527 528// ADJCALLSTACKDOWN/UP pseudo insns 529let Defs = [R11], Uses = [R11], isCodeGenOnly = 1 in { 530def ADJCALLSTACKDOWN : Pseudo<(outs), (ins i64imm:$amt1, i64imm:$amt2), 531 "#ADJCALLSTACKDOWN $amt1 $amt2", 532 [(BPFcallseq_start timm:$amt1, timm:$amt2)]>; 533def ADJCALLSTACKUP : Pseudo<(outs), (ins i64imm:$amt1, i64imm:$amt2), 534 "#ADJCALLSTACKUP $amt1 $amt2", 535 [(BPFcallseq_end timm:$amt1, timm:$amt2)]>; 536} 537 538let usesCustomInserter = 1, isCodeGenOnly = 1 in { 539 def Select : Pseudo<(outs GPR:$dst), 540 (ins GPR:$lhs, GPR:$rhs, i64imm:$imm, GPR:$src, GPR:$src2), 541 "# Select PSEUDO $dst = $lhs $imm $rhs ? $src : $src2", 542 [(set i64:$dst, 543 (BPFselectcc i64:$lhs, i64:$rhs, (i64 imm:$imm), i64:$src, i64:$src2))]>; 544 def Select_Ri : Pseudo<(outs GPR:$dst), 545 (ins GPR:$lhs, i64imm:$rhs, i64imm:$imm, GPR:$src, GPR:$src2), 546 "# Select PSEUDO $dst = $lhs $imm $rhs ? $src : $src2", 547 [(set i64:$dst, 548 (BPFselectcc i64:$lhs, (i64immSExt32:$rhs), (i64 imm:$imm), i64:$src, i64:$src2))]>; 549 def Select_64_32 : Pseudo<(outs GPR32:$dst), 550 (ins GPR:$lhs, GPR:$rhs, i64imm:$imm, GPR32:$src, GPR32:$src2), 551 "# Select PSEUDO $dst = $lhs $imm $rhs ? $src : $src2", 552 [(set i32:$dst, 553 (BPFselectcc i64:$lhs, i64:$rhs, (i64 imm:$imm), i32:$src, i32:$src2))]>; 554 def Select_Ri_64_32 : Pseudo<(outs GPR32:$dst), 555 (ins GPR:$lhs, i64imm:$rhs, i64imm:$imm, GPR32:$src, GPR32:$src2), 556 "# Select PSEUDO $dst = $lhs $imm $rhs ? $src : $src2", 557 [(set i32:$dst, 558 (BPFselectcc i64:$lhs, (i64immSExt32:$rhs), (i64 imm:$imm), i32:$src, i32:$src2))]>; 559 def Select_32 : Pseudo<(outs GPR32:$dst), 560 (ins GPR32:$lhs, GPR32:$rhs, i32imm:$imm, GPR32:$src, GPR32:$src2), 561 "# Select PSEUDO $dst = $lhs $imm $rhs ? $src : $src2", 562 [(set i32:$dst, 563 (BPFselectcc i32:$lhs, i32:$rhs, (i32 imm:$imm), i32:$src, i32:$src2))]>; 564 def Select_Ri_32 : Pseudo<(outs GPR32:$dst), 565 (ins GPR32:$lhs, i32imm:$rhs, i32imm:$imm, GPR32:$src, GPR32:$src2), 566 "# Select PSEUDO $dst = $lhs $imm $rhs ? $src : $src2", 567 [(set i32:$dst, 568 (BPFselectcc i32:$lhs, (i32immSExt32:$rhs), (i32 imm:$imm), i32:$src, i32:$src2))]>; 569 def Select_32_64 : Pseudo<(outs GPR:$dst), 570 (ins GPR32:$lhs, GPR32:$rhs, i32imm:$imm, GPR:$src, GPR:$src2), 571 "# Select PSEUDO $dst = $lhs $imm $rhs ? $src : $src2", 572 [(set i64:$dst, 573 (BPFselectcc i32:$lhs, i32:$rhs, (i32 imm:$imm), i64:$src, i64:$src2))]>; 574 def Select_Ri_32_64 : Pseudo<(outs GPR:$dst), 575 (ins GPR32:$lhs, i32imm:$rhs, i32imm:$imm, GPR:$src, GPR:$src2), 576 "# Select PSEUDO $dst = $lhs $imm $rhs ? $src : $src2", 577 [(set i64:$dst, 578 (BPFselectcc i32:$lhs, (i32immSExt32:$rhs), (i32 imm:$imm), i64:$src, i64:$src2))]>; 579} 580 581// load 64-bit global addr into register 582def : Pat<(BPFWrapper tglobaladdr:$in), (LD_imm64 tglobaladdr:$in)>; 583 584// 0xffffFFFF doesn't fit into simm32, optimize common case 585def : Pat<(i64 (and (i64 GPR:$src), 0xffffFFFF)), 586 (SRL_ri (SLL_ri (i64 GPR:$src), 32), 32)>; 587 588// Calls 589def : Pat<(BPFcall tglobaladdr:$dst), (JAL tglobaladdr:$dst)>; 590def : Pat<(BPFcall texternalsym:$dst), (JAL texternalsym:$dst)>; 591def : Pat<(BPFcall imm:$dst), (JAL imm:$dst)>; 592def : Pat<(BPFcall GPR:$dst), (JALX GPR:$dst)>; 593 594// Loads 595let Predicates = [BPFNoALU32] in { 596 def : Pat<(i64 (extloadi8 ADDRri:$src)), (i64 (LDB ADDRri:$src))>; 597 def : Pat<(i64 (extloadi16 ADDRri:$src)), (i64 (LDH ADDRri:$src))>; 598 def : Pat<(i64 (extloadi32 ADDRri:$src)), (i64 (LDW ADDRri:$src))>; 599} 600 601// Atomics 602class XADD<BPFWidthModifer SizeOp, string OpcodeStr, PatFrag OpNode> 603 : TYPE_LD_ST<BPF_XADD.Value, SizeOp.Value, 604 (outs GPR:$dst), 605 (ins MEMri:$addr, GPR:$val), 606 "lock *("#OpcodeStr#" *)($addr) += $val", 607 [(set GPR:$dst, (OpNode ADDRri:$addr, GPR:$val))]> { 608 bits<4> dst; 609 bits<20> addr; 610 611 let Inst{51-48} = addr{19-16}; // base reg 612 let Inst{55-52} = dst; 613 let Inst{47-32} = addr{15-0}; // offset 614 let BPFClass = BPF_STX; 615} 616 617class XADD32<BPFWidthModifer SizeOp, string OpcodeStr, PatFrag OpNode> 618 : TYPE_LD_ST<BPF_XADD.Value, SizeOp.Value, 619 (outs GPR32:$dst), 620 (ins MEMri:$addr, GPR32:$val), 621 "lock *("#OpcodeStr#" *)($addr) += $val", 622 [(set GPR32:$dst, (OpNode ADDRri:$addr, GPR32:$val))]> { 623 bits<4> dst; 624 bits<20> addr; 625 626 let Inst{51-48} = addr{19-16}; // base reg 627 let Inst{55-52} = dst; 628 let Inst{47-32} = addr{15-0}; // offset 629 let BPFClass = BPF_STX; 630} 631 632let Constraints = "$dst = $val" in { 633 let Predicates = [BPFNoALU32] in { 634 def XADDW : XADD<BPF_W, "u32", atomic_load_add_32>; 635 } 636 637 let Predicates = [BPFHasALU32], DecoderNamespace = "BPFALU32" in { 638 def XADDW32 : XADD32<BPF_W, "u32", atomic_load_add_32>; 639 } 640 641 def XADDD : XADD<BPF_DW, "u64", atomic_load_add_64>; 642} 643 644// bswap16, bswap32, bswap64 645class BSWAP<bits<32> SizeOp, string OpcodeStr, BPFSrcType SrcType, list<dag> Pattern> 646 : TYPE_ALU_JMP<BPF_END.Value, SrcType.Value, 647 (outs GPR:$dst), 648 (ins GPR:$src), 649 "$dst = "#OpcodeStr#" $src", 650 Pattern> { 651 bits<4> dst; 652 653 let Inst{51-48} = dst; 654 let Inst{31-0} = SizeOp; 655 let BPFClass = BPF_ALU; 656} 657 658 659let Constraints = "$dst = $src" in { 660 let Predicates = [BPFIsLittleEndian] in { 661 def BE16 : BSWAP<16, "be16", BPF_TO_BE, [(set GPR:$dst, (srl (bswap GPR:$src), (i64 48)))]>; 662 def BE32 : BSWAP<32, "be32", BPF_TO_BE, [(set GPR:$dst, (srl (bswap GPR:$src), (i64 32)))]>; 663 def BE64 : BSWAP<64, "be64", BPF_TO_BE, [(set GPR:$dst, (bswap GPR:$src))]>; 664 } 665 let Predicates = [BPFIsBigEndian] in { 666 def LE16 : BSWAP<16, "le16", BPF_TO_LE, [(set GPR:$dst, (srl (bswap GPR:$src), (i64 48)))]>; 667 def LE32 : BSWAP<32, "le32", BPF_TO_LE, [(set GPR:$dst, (srl (bswap GPR:$src), (i64 32)))]>; 668 def LE64 : BSWAP<64, "le64", BPF_TO_LE, [(set GPR:$dst, (bswap GPR:$src))]>; 669 } 670} 671 672let Defs = [R0, R1, R2, R3, R4, R5], Uses = [R6], hasSideEffects = 1, 673 hasExtraDefRegAllocReq = 1, hasExtraSrcRegAllocReq = 1, mayLoad = 1 in { 674class LOAD_ABS<BPFWidthModifer SizeOp, string OpcodeStr, Intrinsic OpNode> 675 : TYPE_LD_ST<BPF_ABS.Value, SizeOp.Value, 676 (outs), 677 (ins GPR:$skb, i64imm:$imm), 678 "r0 = *("#OpcodeStr#" *)skb[$imm]", 679 [(set R0, (OpNode GPR:$skb, i64immSExt32:$imm))]> { 680 bits<32> imm; 681 682 let Inst{31-0} = imm; 683 let BPFClass = BPF_LD; 684} 685 686class LOAD_IND<BPFWidthModifer SizeOp, string OpcodeStr, Intrinsic OpNode> 687 : TYPE_LD_ST<BPF_IND.Value, SizeOp.Value, 688 (outs), 689 (ins GPR:$skb, GPR:$val), 690 "r0 = *("#OpcodeStr#" *)skb[$val]", 691 [(set R0, (OpNode GPR:$skb, GPR:$val))]> { 692 bits<4> val; 693 694 let Inst{55-52} = val; 695 let BPFClass = BPF_LD; 696} 697} 698 699def LD_ABS_B : LOAD_ABS<BPF_B, "u8", int_bpf_load_byte>; 700def LD_ABS_H : LOAD_ABS<BPF_H, "u16", int_bpf_load_half>; 701def LD_ABS_W : LOAD_ABS<BPF_W, "u32", int_bpf_load_word>; 702 703def LD_IND_B : LOAD_IND<BPF_B, "u8", int_bpf_load_byte>; 704def LD_IND_H : LOAD_IND<BPF_H, "u16", int_bpf_load_half>; 705def LD_IND_W : LOAD_IND<BPF_W, "u32", int_bpf_load_word>; 706 707let isCodeGenOnly = 1 in { 708 def MOV_32_64 : ALU_RR<BPF_ALU, BPF_MOV, 709 (outs GPR:$dst), (ins GPR32:$src), 710 "$dst = $src", []>; 711} 712 713def : Pat<(i64 (sext GPR32:$src)), 714 (SRA_ri (SLL_ri (MOV_32_64 GPR32:$src), 32), 32)>; 715 716def : Pat<(i64 (zext GPR32:$src)), 717 (SRL_ri (SLL_ri (MOV_32_64 GPR32:$src), 32), 32)>; 718 719// For i64 -> i32 truncation, use the 32-bit subregister directly. 720def : Pat<(i32 (trunc GPR:$src)), 721 (i32 (EXTRACT_SUBREG GPR:$src, sub_32))>; 722 723// For i32 -> i64 anyext, we don't care about the high bits. 724def : Pat<(i64 (anyext GPR32:$src)), 725 (INSERT_SUBREG (i64 (IMPLICIT_DEF)), GPR32:$src, sub_32)>; 726 727class STORE32<BPFWidthModifer SizeOp, string OpcodeStr, list<dag> Pattern> 728 : TYPE_LD_ST<BPF_MEM.Value, SizeOp.Value, 729 (outs), 730 (ins GPR32:$src, MEMri:$addr), 731 "*("#OpcodeStr#" *)($addr) = $src", 732 Pattern> { 733 bits<4> src; 734 bits<20> addr; 735 736 let Inst{51-48} = addr{19-16}; // base reg 737 let Inst{55-52} = src; 738 let Inst{47-32} = addr{15-0}; // offset 739 let BPFClass = BPF_STX; 740} 741 742class STOREi32<BPFWidthModifer Opc, string OpcodeStr, PatFrag OpNode> 743 : STORE32<Opc, OpcodeStr, [(OpNode i32:$src, ADDRri:$addr)]>; 744 745let Predicates = [BPFHasALU32], DecoderNamespace = "BPFALU32" in { 746 def STW32 : STOREi32<BPF_W, "u32", store>; 747 def STH32 : STOREi32<BPF_H, "u16", truncstorei16>; 748 def STB32 : STOREi32<BPF_B, "u8", truncstorei8>; 749} 750 751class LOAD32<BPFWidthModifer SizeOp, string OpcodeStr, list<dag> Pattern> 752 : TYPE_LD_ST<BPF_MEM.Value, SizeOp.Value, 753 (outs GPR32:$dst), 754 (ins MEMri:$addr), 755 "$dst = *("#OpcodeStr#" *)($addr)", 756 Pattern> { 757 bits<4> dst; 758 bits<20> addr; 759 760 let Inst{51-48} = dst; 761 let Inst{55-52} = addr{19-16}; 762 let Inst{47-32} = addr{15-0}; 763 let BPFClass = BPF_LDX; 764} 765 766class LOADi32<BPFWidthModifer SizeOp, string OpcodeStr, PatFrag OpNode> 767 : LOAD32<SizeOp, OpcodeStr, [(set i32:$dst, (OpNode ADDRri:$addr))]>; 768 769let Predicates = [BPFHasALU32], DecoderNamespace = "BPFALU32" in { 770 def LDW32 : LOADi32<BPF_W, "u32", load>; 771 def LDH32 : LOADi32<BPF_H, "u16", zextloadi16>; 772 def LDB32 : LOADi32<BPF_B, "u8", zextloadi8>; 773} 774 775let Predicates = [BPFHasALU32] in { 776 def : Pat<(truncstorei8 GPR:$src, ADDRri:$dst), 777 (STB32 (EXTRACT_SUBREG GPR:$src, sub_32), ADDRri:$dst)>; 778 def : Pat<(truncstorei16 GPR:$src, ADDRri:$dst), 779 (STH32 (EXTRACT_SUBREG GPR:$src, sub_32), ADDRri:$dst)>; 780 def : Pat<(truncstorei32 GPR:$src, ADDRri:$dst), 781 (STW32 (EXTRACT_SUBREG GPR:$src, sub_32), ADDRri:$dst)>; 782 def : Pat<(i32 (extloadi8 ADDRri:$src)), (i32 (LDB32 ADDRri:$src))>; 783 def : Pat<(i32 (extloadi16 ADDRri:$src)), (i32 (LDH32 ADDRri:$src))>; 784 def : Pat<(i64 (zextloadi8 ADDRri:$src)), 785 (SUBREG_TO_REG (i64 0), (LDB32 ADDRri:$src), sub_32)>; 786 def : Pat<(i64 (zextloadi16 ADDRri:$src)), 787 (SUBREG_TO_REG (i64 0), (LDH32 ADDRri:$src), sub_32)>; 788 def : Pat<(i64 (zextloadi32 ADDRri:$src)), 789 (SUBREG_TO_REG (i64 0), (LDW32 ADDRri:$src), sub_32)>; 790 def : Pat<(i64 (extloadi8 ADDRri:$src)), 791 (SUBREG_TO_REG (i64 0), (LDB32 ADDRri:$src), sub_32)>; 792 def : Pat<(i64 (extloadi16 ADDRri:$src)), 793 (SUBREG_TO_REG (i64 0), (LDH32 ADDRri:$src), sub_32)>; 794 def : Pat<(i64 (extloadi32 ADDRri:$src)), 795 (SUBREG_TO_REG (i64 0), (LDW32 ADDRri:$src), sub_32)>; 796} 797 798let usesCustomInserter = 1, isCodeGenOnly = 1 in { 799 def MEMCPY : Pseudo< 800 (outs), 801 (ins GPR:$dst, GPR:$src, i64imm:$len, i64imm:$align, variable_ops), 802 "#memcpy dst: $dst, src: $src, len: $len, align: $align", 803 [(BPFmemcpy GPR:$dst, GPR:$src, imm:$len, imm:$align)]>; 804} 805