Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "<FIXS>", "if", "(", "GET_CODE", "(", "or", "ig_x", ")", "==", "UNSPEC", ")", "switch", "(", "XINT", "(", "or", "ig_x", ",", "<NUM_LIT>", ")", ")", "{", "case", "UNSPEC_FUSION_GPR", ":", "case", "UNSPEC_PCREL_OPT_LD_ADDR", ":", "case", "UNSPEC_PCREL_OPT_LD_SAME_REG", ":", "case", "UNSPEC_PCREL_OPT_ST_ADDR", ":", "or", "ig_x", "=", "XVECEXP", "(", "or", "ig_x", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "break", ";", "default", ":", "break", ";", "}", "<FIXE>" ]

[ "{", "rtx", "x", ",", "y", ",", "offset", ";", "<BUGS>", "if", "(", "GET_CODE", "(", "or", "ig_x", ")", "==", "UNSPEC", "&&", "XINT", "(", "or", "ig_x", ",", "<NUM_LIT>", ")", "==", "UNSPEC_FUSION_GPR", ")", "or", "ig_x", "=", "XVECEXP", "(", "or", "ig_x", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "<BUGE>", "or", "ig_x", "=", "delegitimize_mem_from_attrs", "(", "or", "ig_x", ")", ";" ]

[ "<STR_LIT>", ".. identifier\\n", "<STR_LIT>", ")", ";" ]

[ "MipsAsmParser", "::", "OperandMatchResultTy", "MipsAsmParser", "::", "MatchAnyRegisterWithoutDollar", "(", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ",", "SMLoc", "S", ")", "{", "auto", "Token", "=", "Parser", ".", "getLexer", "(", ")", ".", "peekTok", "(", "false", ")", ";", "if", "(", "Token", ".", "is", "(", "AsmToken", "::", "Identifier", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<" ]

[ "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":" ]

[ "case", "ISD", "::", "FP_TO_UINT", ":", "return", "LowerFP_TO_INT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FCOPYSIGN", ":", "return", "LowerFCOPYSIGN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAME_TO_ARGS_OFFSET", ":", "return", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", "*", "<NUM_LIT>", ")", ";", "case", "ISD", "::", "EH_RETURN", ":", "return", "LowerEH_RETURN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GLOBAL_OFFSET_TABLE", ":", "return", "LowerGLOBAL_OFFSET_TABLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_SJLJ_SETJMP", ":", "return", "LowerEH_SJLJ_SETJMP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_SJLJ_LONGJMP", ":", "return", "LowerEH_SJLJ_LONGJMP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "BITCAST", ":", "return", "ExpandBITCAST", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "return", "LowerShift", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "LowerShiftLeftParts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "case", "ISD", "::", "SRA_PARTS", ":", "return", "LowerShiftRightParts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CTTZ", ":", "return", "LowerCTTZ", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "CTPOP", ":", "return", "LowerCTPOP", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerVSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantFP", ":", "return", "LowerConstantFP", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "LowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "LowerINSERT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "LowerEXTRACT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "LowerCONCAT_VECTORS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FLT_ROUNDS_", ":", "return", "LowerFLT_ROUNDS_", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "LowerMUL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SDIV", ":", "return", "LowerSDIV", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UDIV", ":", "return", "LowerUDIV", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADDC", ":", "case", "ISD", "::", "ADDE", ":", "case", "ISD", "::", "SUBC", ":", "case", "ISD", "::", "SUBE", ":", "return", "LowerADDC_ADDE_SUBC_SUBE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SADDO", ":", "case", "ISD", "::", "UADDO", ":", "case", "ISD", "::", "SSUBO", ":", "case", "ISD", "::", "USUBO", ":", "return", "LowerXALUO", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD", ":", "case", "ISD", "::", "ATOMIC_STORE", ":", "return", "LowerAtomicLoadStore", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FSINCOS", ":", "return", "LowerFSINCOS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SDIVREM", ":", "case", "ISD", "::", "UDIVREM", ":", "return", "LowerDivRem", "(", "Op", ",", "DAG", ")", ";" ]

[ "}" ]

[ "}", "]", ",", "fpimm64XForm", ">", "{", "let", "ParserMatchClass", "=", "FPImmOperand", ";", "let", "PrintMethod", "=", "<STR_LIT>", ";" ]

[ ")", ")", ";" ]

[ "bool", "AArch64AsmPrinter", "::", "printAsmRegInClass", "(", "const", "MachineOperand", "&", "MO", ",", "const", "TargetRegisterClass", "*", "RC", ",", "bool", "isVector", ",", "raw_ostream", "&", "O", ")", "{", "assert", "(", "MO", ".", "isReg", "(", ")", "&&", "<STR_LIT>", "Should only get here with a register!", "<STR_LIT>", ")", ";", "const", "AArch64RegisterInfo", "*", "RI", "=", "static_cast", "<", "const", "AArch64RegisterInfo", "*", ">", "(", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getRegisterInfo", "(", ")", ")", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "unsigned", "RegToPrint", "=", "RC", "->", "getRegister", "(", "RI", "->", "getEncodingValue", "(", "Reg" ]

[ "let", "hasNewValue", "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "<STR_LIT>", ";", "break", ";" ]

[ "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "P", ".", "MMI", "->", "getObjFileInfo", "<", "MachineModuleInfoMachO", ">", "(", ")", ".", "getGVStubEntry", "(", "Sym", ")", ";", "if", "(", "!", "StubSym", ".", "getPointer", "(", ")", ")", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "P", ".", "getSymbol", "(", "GV", ")", ",", "!", "GV", "->", "hasInternalLinkage", "(", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "MCSymbol", "*", "Sym", "=", "P", ".", "getSymbolWithGlobalValueBase", "(", "GV", ",", "<STR_LIT>", "$stub", "<STR_LIT>", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "P", ".", "MMI", "->", "getObjFileInfo", "<", "MachineModuleInfoMachO", ">", "(", ")", ".", "getFnStubEntry", "(", "Sym", ")", ";", "if", "(", "!", "StubSym", ".", "getPointer", "(", ")", ")", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "P", ".", "getSymbol", "(", "GV", ")", ",", "!", "GV", "->", "hasInternalLinkage", "(", ")", ")", ";", "}", "if", "(", "GVSym", "->", "getName", "(", ")", "[", "<NUM_LIT>", "]", "!=", "'", "$", "'", ")", "GVSym", "->", "print", "(", "O", ",", "P", ".", "MAI", ")", ";", "else", "{", "O", "<<", "'", "(", "'", ";", "GVSym", "->", "print", "(", "O", ",", "P", ".", "MAI", ")", ";", "O", "<<", "'", ")", "'", ";", "}", "P", ".", "printOffset", "(", "MO", ".", "getOffset", "(", ")", ",", "O", ")", ";", "break", ";", "}", "}", "switch", "(", "MO", ".", "getTargetFlags", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown target flag on GV operand", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", " + [.-", "<STR_LIT>", ";", "P", ".", "MF", "->", "getPICBaseSymbol", "(", ")", "->", "print", "(", "O", ",", "P", ".", "MAI", ")", ";", "O", "<<", "'", "]", "'", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "'", "-", "'", ";", "P", ".", "MF", "->", "getPICBaseSymbol", "(", ")", "->", "print", "(", "O", ",", "P", ".", "MAI", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "@TLSGD", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "@TLSLD", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "@TLSLDM", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "@GOTTPOFF", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "@INDNTPOFF", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "@TPOFF", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "@DTPOFF", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "@NTPOFF", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "@GOTNTPOFF", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "@GOTPCREL" ]

[ "bool", "AArch64RegisterInfo", "::", "useFPForScavengingIndex", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "AArch64FrameLowering", "&", "TFI", "=", "*", "getFrameLowering", "(", "MF", ")", ";", "const", "AArch64FunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "assert", "(", "(", "!", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "hasSVE", "(", ")", "||", "AFI", "->", "hasCalculatedStackSizeSVE", "(", ")", ")", "&&", "<STR_LIT>", "Expected SVE area to be calculated by this point", "<STR_LIT>", ")", ";", "return", "TFI", ".", "hasFP", "(", "MF", ")", "&&", "!", "hasStackRealignment", "(", "MF", ")", "&&", "!", "AFI", "->", "getStackSizeSVE", "(", ")", ";", "}" ]

[ "Returns", "true", "if", "the", "target", "wants", "to", "use", "frame", "pointer", "based", "accesses", "to", "spill", "to", "the", "scavenger", "emergency", "spill", "slot", "." ]

[ "reportError", "(", "Twine", "(", "<STR_LIT>", "invalid instruction packet: slot error", "<STR_LIT>", ")", ")", ";" ]

[ "}", "if", "(", "store1", "&&", "stores", ">", "<NUM_LIT>", ")", "{", "reportError", "(", "Twine", "(", "<STR_LIT>", "invalid instruction packet: too many stores", "<STR_LIT>", ")", ")", ";", "return", "false", ";", "}", "}", "if", "(", "ISJ", "->", "Core", ".", "getUnits", "(", ")", "==", "slotThree", ")", "bOnlySlot3", "=", "true", ";", "if", "(", "!", "ISJ", "->", "Core", ".", "getUnits", "(", ")", ")", "{", "reportError", "(", "Twine", "(", "<STR_LIT>", "invalid instruction packet: out of slots", "<STR_LIT>", ")", ")", ";", "return", "false", ";", "}", "}", "bool", "validateSlots", "=", "true", ";", "if", "(", "foundBranches", ".", "size", "(", ")", ">", "<NUM_LIT>", ")", "{", "if", "(", "foundBranches", ".", "size", "(", ")", ">", "<NUM_LIT>", ")", "{", "reportError", "(", "Twine", "(", "<STR_LIT>", "too many branches in packet", "<STR_LIT>", ")", ")", ";", "return", "false", ";", "}", "for", "(", "unsigned", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "MAX_JUMP_SLOTS", ";", "++", "i", ")", "{", "if", "(", "!", "(", "jumpSlots", "[", "i", "]", ".", "first", "&", "foundBranches", "[", "<NUM_LIT>", "]", "->", "Core", ".", "getUnits", "(", ")", ")", ")", "continue", ";", "if", "(", "!", "(", "jumpSlots", "[", "i", "]", ".", "second", "&", "foundBranches", "[", "<NUM_LIT>", "]", "->", "Core", ".", "getUnits", "(", ")", ")", ")", "continue", ";", "PacketSave", "=", "Packet", ";", "foundBranches", "[", "<NUM_LIT>", "]", "->", "Core", ".", "setUnits", "(", "jumpSlots", "[", "i", "]", ".", "first", ")", ";", "foundBranches", "[", "<NUM_LIT>", "]", "->", "Core", ".", "setUnits", "(", "jumpSlots", "[", "i", "]", ".", "second", ")", ";", "HexagonUnitAuction", "AuctionCore", "(", "reservedSlots", ")", ";", "std", "::", "stable_sort", "(", "begin", "(", ")", ",", "end", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "bool", "bFail", "=", "false", ";", "for", "(", "iterator", "I", "=", "begin", "(", ")", ";", "I", "!=", "end", "(", ")", "&&", "!", "bFail", ";", "++", "I", ")", "if", "(", "!", "AuctionCore", ".", "bid", "(", "I", "->", "Core", ".", "getUnits", "(", ")", ")", ")", "bFail", "=", "true", ";", "if", "(", "!", "bFail", ")", "{", "validateSlots", "=", "false", ";", "break", ";", "}", "else", "Packet", "=", "PacketSave", ";", "}", "if", "(", "validateSlots", ")", "{", "reportError", "(", "Twine", "(", "<STR_LIT>", "invalid instruction packet: out of slots", "<STR_LIT>", ")", ")", ";", "return", "false", ";", "}", "}", "if", "(", "foundBranches", ".", "size", "(", ")", "<=", "<NUM_LIT>", "&&", "bOnlySlot3", "==", "false", "&&", "pSlot3Cnt", "==", "<NUM_LIT>", "&&", "slot3ISJ", "!=", "end", "(", ")", ")", "{", "validateSlots", "=", "true", ";", "unsigned", "saveUnits", "=", "slot3ISJ", "->", "Core", ".", "getUnits", "(", ")", ";", "slot3ISJ", "->", "Core", ".", "setUnits", "(", "saveUnits", "&", "slotThree", ")", ";", "HexagonUnitAuction", "AuctionCore", "(", "reservedSlots", ")", ";", "std", "::", "stable_sort", "(", "begin", "(", ")", ",", "end", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "bool", "bFail", "=", "false", ";", "for", "(", "iterator", "I", "=", "begin", "(", ")", ";", "I", "!=", "end", "(", ")", "&&", "!", "bFail", ";", "++", "I", ")", "if", "(", "!", "AuctionCore", ".", "bid", "(", "I", "->", "Core", ".", "getUnits", "(", ")", ")", ")", "bFail", "=", "true", ";", "if", "(", "!", "bFail", ")", "validateSlots", "=", "false", ";", "else", "for", "(", "iterator", "ISJ", "=", "begin", "(", ")", ";", "ISJ", "!=", "end", "(", ")", ";", "++", "ISJ", ")", "{", "MCInst", "const", "&", "ID", "=", "ISJ", "->", "getDesc", "(", ")", ";", "if", "(", "HexagonMCInstrInfo", "::", "prefersSlot3", "(", "MCII", ",", "ID", ")", ")", "ISJ", "->", "Core", ".", "setUnits", "(", "saveUnits", ")", ";", "}", "}", "if", "(", "validateSlots", ")", "{", "HexagonUnitAuction", "AuctionCore", "(", "reservedSlots", ")", ";", "std", "::", "stable_sort", "(", "begin", "(", ")", ",", "end", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "for", "(", "iterator", "I", "=", "begin", "(", ")", ";", "I", "!=", "end", "(", ")", ";", "++", "I", ")", "if", "(", "!", "AuctionCore", ".", "bid", "(", "I", "->", "Core", ".", "getUnits", "(", ")", ")", ")", "{", "reportError", "(", "Twine", "(", "<STR_LIT>", "invalid instruction packet: slot error", "<STR_LIT>", ")", ")", ";", "return", "false", ";", "}", "}", "std", "::", "stable_sort", "(", "begin", "(", ")", ",", "end", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "HVXInstsT", "hvxInsts", ";", "hvxInsts", ".", "clear", "(", ")", ";", "for", "(", "iterator", "I", "=", "begin", "(", ")", ";", "I", "!=", "end", "(", ")", ";", "++", "I", ")", "{", "struct", "CVIUnits", "inst", ";", "inst", ".", "Units", "=", "I", "->", "CVI", ".", "getUnits", "(", ")", ";", "inst", ".", "Lanes", "=", "I", "->", "CVI", ".", "getLanes", "(", ")", ";", "if", "(", "inst", ".", "Units", "==", "<NUM_LIT>", ")", "continue", ";", "hvxInsts", ".", "push_back", "(", "inst", ")", ";", "}", "if", "(", "hvxInsts", ".", "size", "(", ")", ">", "<NUM_LIT>", ")", "{", "unsigned", "startIdx", ",", "usedUnits", ";", "startIdx", "=", "usedUnits", "=", "<NUM_LIT>", ";", "if", "(", "!", "checkHVXPipes", "(", "hvxInsts", ",", "startIdx", ",", "usedUnits", ")", ")", "{" ]

[ ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ";" ]

[ "vrev32q_s8", "(", "int8x16_t", "_", "_", "a", ")", "{", "return", "(", "int8x16_t", ")", "_", "_", "builtin_shuffle", "(", "_", "_", "a", ",", "(", "uint8x16_t", ")", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>" ]

[ "<STR_LIT>", ")" ]

[ "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ "$", "vz", ",", "(", "ULO7", "$", "N", ")", ",", "i32", ":", "$", "vl", ",", "v256f64", ":", "$", "pt", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "int_ve_vl_vsral_vvsvl", "v256f64", ":", "$", "vz", ",", "uimm6", ":", "$", "N", ",", "v256f64", ":", "$", "pt", ",", "i32", ":", "$", "vl", ")", ",", "(", "VSRALvil_v", "v256f64", ":" ]

[ "=", "_", "_", "A", "}", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m256h", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_castph512_ph256", "(", "_", "_", "m512h", "_", "_", "A", ")", "{", "union", "{", "_", "_", "m256h", "_", "_", "a", "[", "<NUM_LIT>", "]", ";", "_", "_", "m512h", "_", "_", "v", ";", "}", "_", "_", "u", "=", "{", ".", "_", "_", "v" ]

[ "setTargetDAGCombine", "(", "ISD", "::", "SDIVREM", ")", ";" ]

[ "bool", "isVLIWEnabled", "=", "static_cast", "<", "rvexTargetMachine", "*", ">", "(", "&", "TM", ")", "->", "getSubtargetImpl", "(", ")", "->", "isVLIWEnabled", "(", ")", ";", "setSchedulingPreference", "(", "isVLIWEnabled", "?", "Sched", "::", "VLIW", ":", "Sched", "::", "Hybrid", ")", ";", "setOperationAction", "(", "ISD", "::", "SDIV", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SREM", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UDIV", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UREM", ",", "MVT", "::", "i32", ",", "Expand", ")", ";" ]

[ "=", "operands", "[", "<NUM_LIT>", "]", ";" ]

[ "operands", "[", "<NUM_LIT>", "]", "=", "force_reg", "(", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "op", "=", "gen_rtx_fmt_ee", "(", "code", ",", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "}", "if", "(", "register_operand", "(", "operands", "[", "<NUM_LIT>", "]", ",", "VOIDmode", ")", ")", "dest" ]

[ "}" ]

[ "def", "A2_vcmpbeq", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss32", ",", "DoubleRegs", ":", "$", "Rtt32", ")", ",", "<STR_LIT>", ",", "tc_85d5d03f", ",", "TypeALU64", ">", ",", "Enc_fcf7a7", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "for", "(", "auto", "*", "Blk", ":", "Predicator", ".", "getOrderedList", "(", ")", ")", "{", "EmitBlock", "(", "Blk", ",", "OS", ")", ";" ]

[ "setAvailableFeatures", "(", "ComputeAvailableFeatures", "(", "STI", ".", "getFeatureBits", "(", ")", ")", ")", ";" ]

[ "AMDGPUAsmParser", "(", "MCSubtargetInfo", "&", "STI", ",", "MCAsmParser", "&", "_", "Parser", ",", "const", "MCInstrInfo", "&", "MII", ",", "const", "MCTargetOptions", "&", "Options", ")", ":", "MCTargetAsmParser", "(", ")", ",", "STI", "(", "STI", ")", ",", "MII", "(", "MII", ")", ",", "Parser", "(", "_", "Parser", ")", ",", "ForcedEncodingSize", "(", "<NUM_LIT>", ")", "{", "if", "(", "STI", ".", "getFeatureBits", "(", ")", ".", "none", "(", ")", ")", "{", "STI", ".", "ToggleFeature", "(", "<STR_LIT>", "SOUTHERN_ISLANDS", "<STR_LIT>", ")", ";", "}" ]

[ ")", ")", ";" ]

[ "uint32_t", "VLen", "=", "Elements", ".", "size", "(", ")", ";", "if", "(", "VLen", ">", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", ";", "bool", "HasBitField", "=", "false", ";", "for", "(", "const", "auto", "*", "Element", ":", "Elements", ")", "{", "auto", "E", "=", "cast", "<", "DIDerivedType", ">", "(", "Element", ")", ";", "if", "(", "E", "->", "isBitField", "(", ")", ")", "{", "HasBitField", "=", "true", ";", "break", ";", "}", "}", "auto", "TypeEntry", "=", "llvm", "::", "make_unique", "<", "BTFTypeStruct", ">", "(", "CTy", ",", "IsStruct", ",", "HasBitField", ",", "VLen", ")", ";", "StructTypes", ".", "push_back", "(", "TypeEntry", ".", "get", "(" ]

[ "<FIXS>", "<STR_LIT>", "<FIXE>" ]

[ "VCVTAQ", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "<FIXS>", "NewDUP", "=", "DAG", ".", "getNode", "(", "N", ".", "getOpcode", "(", ")", ",", "dl", ",", "NewDUPVT", ",", "N", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "<FIXE>", "<FIXS>", "NewDUP", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "NewDUPVT", ",", "N", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "<FIXE>", "<FIXS>", "return", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "dl", ",", "NarrowTy", ",", "NewDUP", ",", "DAG", ".", "getConstant", "(", "NumElems", ",", "dl", ",", "MVT", "::", "i64", ")", ")", ";", "<FIXE>" ]

[ "unsigned", "NumElems", "=", "NarrowTy", ".", "getVectorNumElements", "(", ")", ";", "MVT", "NewDUPVT", "=", "MVT", "::", "getVectorVT", "(", "ElementTy", ",", "NumElems", "*", "<NUM_LIT>", ")", ";", "SDValue", "NewDUP", ";", "if", "(", "IsDUPLANE", ")", "<BUGS>", "NewDUP", "=", "DAG", ".", "getNode", "(", "N", ".", "getOpcode", "(", ")", ",", "SDLoc", "(", "N", ")", ",", "NewDUPVT", ",", "N", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "<BUGE>", "N", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "else", "<BUGS>", "NewDUP", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "SDLoc", "(", "N", ")", ",", "NewDUPVT", ",", "N", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "<BUGE>", "<BUGS>", "return", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "SDLoc", "(", "N", ".", "getNode", "(", ")", ")", ",", "NarrowTy", ",", "NewDUP", ",", "DAG", ".", "getConstant", "(", "NumElems", ",", "MVT", "::", "i64", ")", ")", ";", "<BUGE>", "}", "static", "bool", "isEssentiallyExtractSubvector", "(", "SDValue", "N", ")", "{" ]

[ "]", ",", "[", "]", ">", ";" ]

[ "def", "ADDRGA_VAR_OFFSET", ":", "ComplexPattern", "<", "i32", ",", "<NUM_LIT>", ",", "<STR_LIT>", ",", "[" ]

[ ")", "]" ]

[ "[", "(", "use", "(", "match_operand", ":", "MODEF", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "use", "(", "match_operand", ":", "MODEF", "<NUM_LIT>", "<STR_LIT>", ")" ]

[ ",", "O", ")", ";" ]

[ "void", "AMDGPUInstPrinter", "::", "printRowMask", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNo", ",", "raw_ostream", "&", "O", ")", "{", "O", "<<", "<STR_LIT>", " row_mask:", "<STR_LIT>", ";", "printU4ImmOperand", "(", "MI", ",", "OpNo" ]

[ "if", "(", "VecTy", "!=", "ViaVecTy", ")", "Result", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "VecTy", ",", "Result", ")", ";" ]

[ "SplatValueB", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "MVT", "::", "i32", ",", "SplatValueB", ")", ";", "}", "if", "(", "BigEndian", ")", "std", "::", "swap", "(", "SplatValueA", ",", "SplatValueB", ")", ";", "SDValue", "Ops", "[", "<NUM_LIT>", "]", "=", "{", "SplatValueA", ",", "SplatValueB", ",", "SplatValueA", ",", "SplatValueB", ",", "SplatValueA", ",", "SplatValueB", ",", "SplatValueA", ",", "SplatValueB", ",", "SplatValueA", ",", "SplatValueB", ",", "SplatValueA", ",", "SplatValueB", ",", "SplatValueA", ",", "SplatValueB", ",", "SplatValueA", ",", "SplatValueB", "}", ";", "SDValue", "Result", "=", "DAG", ".", "getBuildVector", "(", "ViaVecTy", ",", "DL", ",", "makeArrayRef", "(", "Ops", ",", "ViaVecTy", ".", "getVectorNumElements", "(", ")", ")", ")", ";" ]

[ "&", "TM", ")", "{" ]

[ "void", "SNESTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine" ]

[ "}" ]

[ "vhsub_s32", "(", "int32x2_t", "_", "_", "a", ",", "int32x2_t", "_", "_", "b", ")", "{", "return", "(", "int32x2_t", ")", "_", "_", "builtin_aarch64_shsubv2si", "(", "_", "_", "a", ",", "_", "_", "b", ")", ";" ]

[ "=", "<NUM_LIT>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "match_parallel", "<NUM_LIT>", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_operand", ":", "CC", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_MOVESI_FROM_CR", ")", ")", "]", ")", "]", "<STR_LIT>", "{", "int", "mask" ]

[ "def_reg", ")", ";" ]

[ "bool", "e8_consumed_by_addr_in_p", "(", "rtx_insn", "*", "consumer", ",", "rtx", "def_reg", ")", "{", "return", "n8_consumed_by_addr_in_p", "(", "consumer", "," ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<NUM_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":" ]

[ "default", ":" ]

[ "case", "MODE_FLOAT", ":", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", ")", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "r", ",", "x", ")", ";", "switch", "(", "mode", ")", "{", "case", "SFmode", ":", "REAL_VALUE_TO_TARGET_SINGLE", "(", "r", ",", "value_long", "[", "<NUM_LIT>", "]", ")", ";", "if", "(", "HOST_BITS_PER_LONG", ">", "<NUM_LIT>", ")", "value_long", "[", "<NUM_LIT>", "]", "&=", "<NUM_LIT>", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "value_long", "[", "<NUM_LIT>", "]", ")", ";", "break", ";", "case", "DFmode", ":", "REAL_VALUE_TO_TARGET_DOUBLE", "(", "r", ",", "value_long", ")", ";", "if", "(", "HOST_BITS_PER_LONG", ">", "<NUM_LIT>", ")", "{", "value_long", "[", "<NUM_LIT>", "]", "&=", "<NUM_LIT>", ";", "value_long", "[", "<NUM_LIT>", "]", "&=", "<NUM_LIT>", ";", "}", "fprintf", "(", "file", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "value_long", "[", "<NUM_LIT>", "]", ",", "value_long", "[", "<NUM_LIT>", "]", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "case", "MODE_INT", ":", "case", "MODE_PARTIAL_INT", ":", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "switch", "(", "size", ")", "{", "case", "<NUM_LIT>", ":", "output_addr_const", "(", "file", ",", "x", ")", ";", "fputs", "(", "<STR_LIT>", "\\n", "<STR_LIT>", ",", "file", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "split_double", "(", "x", ",", "&", "first", ",", "&", "second", ")", ";", "output_addr_const", "(", "file", ",", "first", ")", ";", "fputs", "(", "<STR_LIT>", ", ", "<STR_LIT>", ",", "file", ")", ";", "output_addr_const", "(", "file", ",", "second", ")", ";", "fputs", "(", "<STR_LIT>", "\\n", "<STR_LIT>", ",", "file", ")", ";", "break", ";" ]

[ "<FIXS>", "(", "define_insn", "<STR_LIT>", "<FIXE>" ]

[ "st", "%", ",", "%", "R1", ",", "%", "<NUM_LIT>", "<STR_LIT>", "type", "<STR_LIT>", "ilog", ",", "iadd", ",", "iadd", ",", "ldsym", ",", "ild", ",", "ist", ",", "fcpys", ",", "fld", ",", "fst", "<STR_LIT>", "<STR_LIT>", "register_operand", "<STR_LIT>", "=", "r", ",", "r", "<STR_LIT>", "input_operand", "<STR_LIT>", "rJ", ",", "n", "<STR_LIT>", "!", "TARGET_BWX" ]

[ ",", "SDT_ARMBFI", ">", ";" ]

[ "def", "ARMbfi", ":", "SDNode", "<", "<STR_LIT>" ]

[ "}" ]

[ "if", "(", "(", "Cmp", "&", "L", ")", "||", "(", "Cmp", "&", "G", ")", ")", "return", "(", "Kind", ")", "(", "(", "Cmp", "^", "(", "L", "|", "G", ")", ")", "^", "EQ", ")", ";", "if", "(", "(", "Cmp", "&", "NE", ")", "||", "(", "Cmp", "&", "EQ", ")", ")", "return", "(", "Kind", ")", "(", "Cmp", "^", "(", "EQ", "|", "NE", ")", ")", ";", "return", "(", "Kind", ")", "<NUM_LIT>", ";" ]

[ ";", "i", "++", ")", "{" ]

[ "static", "void", "setGroupSize", "(", "MVT", "VT", ",", "SmallVectorImpl", "<", "uint32_t", ">", "&", "SizeInfo", ")", "{", "int", "VectorSize", "=", "VT", ".", "getSizeInBits", "(", ")", ";", "int", "VF", "=", "VT", ".", "getVectorNumElements", "(", ")", "/", "std", "::", "max", "(", "VectorSize", "/", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ",", "FirstGroupElement", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>" ]

[ "<FIXS>", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "<FIXE>" ]

[ "rtx", "s0rtx", "bcomprtx", "loc_ref", "<BUGS>", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "<BUGE>", "if", "(", "mode", "!", "=", "SImode", "&", "&", "mode", "!", "=", "DImode", ")" ]

[ "::", "get", "(", "Ctx", ",", "NoAliasList", ")", ";" ]

[ "}", "}", "std", "::", "vector", "<", "Type", "*", ">", "LocalVarTypes", ";", "LocalVarTypes", ".", "reserve", "(", "LocalVars", ".", "size", "(", ")", ")", ";", "std", "::", "transform", "(", "LocalVars", ".", "cbegin", "(", ")", ",", "LocalVars", ".", "cend", "(", ")", ",", "std", "::", "back_inserter", "(", "LocalVarTypes", ")", ",", "[", "]", "(", "const", "GlobalVariable", "*", "V", ")", "->", "Type", "*", "{", "return", "V", "->", "getValueType", "(", ")", ";", "}", ")", ";", "std", "::", "string", "VarName", "(", "F", "?", "(", "Twine", "(", "<STR_LIT>", "llvm.amdgcn.kernel.", "<STR_LIT>", ")", "+", "F", "->", "getName", "(", ")", "+", "<STR_LIT>", ".lds", "<STR_LIT>", ")", ".", "str", "(", ")", ":", "<STR_LIT>", "llvm.amdgcn.module.lds", "<STR_LIT>", ")", ";", "StructType", "*", "LDSTy", "=", "StructType", "::", "create", "(", "Ctx", ",", "LocalVarTypes", ",", "VarName", "+", "<STR_LIT>", ".t", "<STR_LIT>", ")", ";", "Align", "StructAlign", "=", "AMDGPU", "::", "getAlign", "(", "DL", ",", "LocalVars", "[", "<NUM_LIT>", "]", ")", ";", "GlobalVariable", "*", "SGV", "=", "new", "GlobalVariable", "(", "M", ",", "LDSTy", ",", "false", ",", "GlobalValue", "::", "InternalLinkage", ",", "UndefValue", "::", "get", "(", "LDSTy", ")", ",", "VarName", ",", "nullptr", ",", "GlobalValue", "::", "NotThreadLocal", ",", "AMDGPUAS", "::", "LOCAL_ADDRESS", ",", "false", ")", ";", "SGV", "->", "setAlignment", "(", "StructAlign", ")", ";", "if", "(", "!", "F", ")", "{", "appendToCompilerUsed", "(", "M", ",", "{", "static_cast", "<", "GlobalValue", "*", ">", "(", "ConstantExpr", "::", "getPointerBitCastOrAddrSpaceCast", "(", "cast", "<", "Constant", ">", "(", "SGV", ")", ",", "Type", "::", "getInt8PtrTy", "(", "Ctx", ")", ")", ")", "}", ")", ";", "}", "removeFromUsedLists", "(", "M", ",", "LocalVars", ")", ";", "SmallVector", "<", "MDNode", "*", ">", "AliasScopes", ";", "SmallVector", "<", "Metadata", "*", ">", "NoAliasList", ";", "if", "(", "LocalVars", ".", "size", "(", ")", ">", "<NUM_LIT>", ")", "{", "MDBuilder", "MDB", "(", "Ctx", ")", ";", "AliasScopes", ".", "reserve", "(", "LocalVars", ".", "size", "(", ")", ")", ";", "MDNode", "*", "Domain", "=", "MDB", ".", "createAnonymousAliasScopeDomain", "(", ")", ";", "for", "(", "size_t", "I", "=", "<NUM_LIT>", ";", "I", "<", "LocalVars", ".", "size", "(", ")", ";", "I", "++", ")", "{", "MDNode", "*", "Scope", "=", "MDB", ".", "createAnonymousAliasScope", "(", "Domain", ")", ";", "AliasScopes", ".", "push_back", "(", "Scope", ")", ";", "}", "NoAliasList", ".", "append", "(", "&", "AliasScopes", "[", "<NUM_LIT>", "]", ",", "AliasScopes", ".", "end", "(", ")", ")", ";", "}", "Type", "*", "I32", "=", "Type", "::", "getInt32Ty", "(", "Ctx", ")", ";", "for", "(", "size_t", "I", "=", "<NUM_LIT>", ";", "I", "<", "LocalVars", ".", "size", "(", ")", ";", "I", "++", ")", "{", "GlobalVariable", "*", "GV", "=", "LocalVars", "[", "I", "]", ";", "Constant", "*", "GEPIdx", "[", "]", "=", "{", "ConstantInt", "::", "get", "(", "I32", ",", "<NUM_LIT>", ")", ",", "ConstantInt", "::", "get", "(", "I32", ",", "I", ")", "}", ";", "Constant", "*", "GEP", "=", "ConstantExpr", "::", "getGetElementPtr", "(", "LDSTy", ",", "SGV", ",", "GEPIdx", ")", ";", "if", "(", "F", ")", "{", "for", "(", "User", "*", "U", ":", "make_early_inc_range", "(", "GV", "->", "users", "(", ")", ")", ")", "{", "if", "(", "ConstantExpr", "*", "C", "=", "dyn_cast", "<", "ConstantExpr", ">", "(", "U", ")", ")", "AMDGPU", "::", "replaceConstantUsesInFunction", "(", "C", ",", "F", ")", ";", "}", "GV", "->", "removeDeadConstantUsers", "(", ")", ";", "GV", "->", "replaceUsesWithIf", "(", "GEP", ",", "[", "F", "]", "(", "Use", "&", "U", ")", "{", "Instruction", "*", "I", "=", "dyn_cast", "<", "Instruction", ">", "(", "U", ".", "getUser", "(", ")", ")", ";", "return", "I", "&&", "I", "->", "getFunction", "(", ")", "==", "F", ";", "}", ")", ";", "}", "else", "{", "GV", "->", "replaceAllUsesWith", "(", "GEP", ")", ";", "}", "if", "(", "GV", "->", "use_empty", "(", ")", ")", "{", "UsedList", ".", "erase", "(", "GV", ")", ";", "GV", "->", "eraseFromParent", "(", ")", ";", "}", "uint64_t", "Off", "=", "DL", ".", "getStructLayout", "(", "LDSTy", ")", "->", "getElementOffset", "(", "I", ")", ";", "Align", "A", "=", "commonAlignment", "(", "StructAlign", ",", "Off", ")", ";", "if", "(", "I", ")", "NoAliasList", "[", "I", "-", "<NUM_LIT>", "]", "=", "AliasScopes", "[", "I", "-", "<NUM_LIT>", "]", ";", "MDNode", "*", "NoAlias", "=", "NoAliasList", ".", "empty", "(", ")", "?", "nullptr", ":", "MDNode" ]

[ "<FIXS>", "auto", "&", "ExpOps", "=", "getActionDefinitionsBuilder", "(", "G_FPOW", ")", ";", "<FIXE>" ]

[ ".", "scalarize", "(", "<NUM_LIT>", ")", ";", "<BUGS>", "auto", "&", "ExpOps", "=", "getActionDefinitionsBuilder", "(", "{", "G_FEXP", ",", "G_FPOW", "}", ")", ";", "<BUGE>", "if", "(", "ST", ".", "has16BitInsts", "(", ")", ")", "ExpOps", ".", "customFor", "(", "{", "{", "S32", "}", ",", "{", "S16", "}", "}", ")", ";", "else" ]

[ "(", ")", ";" ]

[ "bool", "X86InstrInfo", "::", "getMemOperandWithOffset", "(", "const", "MachineInstr", "&", "MemOp", ",", "const", "MachineOperand", "*", "&", "BaseOp", ",", "int64_t", "&", "Offset", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MemOp", ".", "getDesc", "(", ")", ";", "int", "MemRefBegin", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", "Desc", ".", "TSFlags", ")", ";", "if", "(", "MemRefBegin", "<", "<NUM_LIT>", ")", "return", "false", ";", "MemRefBegin", "+=", "<STR_LIT>", "::", "<STR_LIT>", "(", "Desc", ")", ";", "BaseOp", "=", "&", "MemOp", ".", "getOperand", "(", "MemRefBegin", "+", "X86", "::", "AddrBaseReg", ")", ";", "if", "(", "!", "BaseOp", "->", "isReg", "(", ")", ")", "return", "false", ";", "if", "(", "MemOp", ".", "getOperand", "(", "MemRefBegin", "+", "X86", "::", "AddrScaleAmt", ")", ".", "getImm", "(", ")", "!=", "<NUM_LIT>", ")", "return", "false", ";", "if", "(", "MemOp", ".", "getOperand", "(", "MemRefBegin", "+", "X86", "::", "AddrIndexReg", ")", ".", "getReg", "(", ")", "!=", "X86", "::", "NoRegister", ")", "return", "false", ";", "const", "MachineOperand", "&", "DispMO", "=", "MemOp", ".", "getOperand", "(", "MemRefBegin", "+", "X86", "::", "AddrDisp", ")", ";", "if", "(", "!", "DispMO", ".", "isImm", "(", ")", ")", "return", "false", ";", "Offset", "=", "DispMO", ".", "getImm" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":" ]

[ "<FIXS>", "ld_fenv", "=", "build4", "(", "TARGET_EXPR", ",", "unsigned_type_node", ",", "fenv_var", ",", "build_call_expr", "(", "get_fpscr", ",", "<NUM_LIT>", ")", ",", "NULL_TREE", ",", "NULL_TREE", ")", ";", "<FIXE>" ]

[ "mask", "=", "build_int_cst", "(", "unsigned_type_node", ",", "~", "(", "(", "ARM_FE_ALL_EXCEPT", "<<", "ARM_FE_EXCEPT_SHIFT", ")", "|", "ARM_FE_ALL_EXCEPT", ")", ")", ";", "<BUGS>", "ld_fenv", "=", "build2", "(", "MODIFY_EXPR", ",", "unsigned_type_node", ",", "fenv_var", ",", "build_call_expr", "(", "get_fpscr", ",", "<NUM_LIT>", ")", ")", ";", "<BUGE>", "masked_fenv", "=", "build2", "(", "BIT_AND_EXPR", ",", "unsigned_type_node", ",", "fenv_var", ",", "mask", ")", ";", "hold_fnclex", "=", "build_call_expr", "(", "set_fpscr", ",", "<NUM_LIT>", ",", "masked_fenv", ")", ";", "*", "hold", "=", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", "," ]

[ "return", "false", ";" ]

[ "isGuaranteedNotToBeUndefOrPoisonForTargetNode", "(", "SDValue", "Op", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "bool", "PoisonOnly", ",", "unsigned", "Depth", ")", "const", "{", "switch", "(", "Op", "->", "getOpcode", "(", ")", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "true", ";", "}" ]

[ ".", "q", ")", ";" ]

[ "int", "i", "[", "<NUM_LIT>", "]", ";", "}", "x", ";", "x", ".", "i", "[", "<NUM_LIT>", "]", "=", "i", ";", "return", "(", "x" ]

[ "}" ]

[ "vsetq_lane_f32", "(", "float32_t", "_", "_", "elem", ",", "float32x4_t", "_", "_", "vec", ",", "const", "int", "_", "_", "index", ")", "{", "return", "_", "_", "aarch64_vset_lane_any", "(", "_", "_", "elem", ",", "_", "_", "vec", ",", "_", "_", "index", ")", ";" ]

[ ")", ")" ]

[ "(", "eq_attr", "<STR_LIT>", "<STR_LIT>" ]

[ ")", ",", "sub_32", ")", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "i32", "(", "vector_extract", "v4i32", ":", "$", "S", ",", "<NUM_LIT>", ")", ")", ",", "(", "i32", "(", "EXTRACT_SUBREG", "(", "VEXTUWRX", "(", "LI8", "<NUM_LIT>", ")", ",", "$", "S" ]

[ "++", "i", ")", "{" ]

[ "MachineModuleInfoELF", "&", "MMIELF", "=", "MMI", "->", "getObjFileInfo", "<", "MachineModuleInfoELF", ">", "(", ")", ";", "MachineModuleInfoELF", "::", "SymbolListTy", "Stubs", "=", "MMIELF", ".", "GetGVStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "{", "OutStreamer", ".", "SwitchSection", "(", "TLOFELF", ".", "getDataRelSection", "(", ")", ")", ";", "const", "DataLayout", "*", "TD", "=", "TM", ".", "getDataLayout", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "Stubs", ".", "size", "(", ")", ";", "i", "!=", "e", ";" ]

[ "PtrReg", ",", "*", "MMO", ")", ";" ]

[ "LLT", "PtrTy", "=", "LLT", "::", "pointer", "(", "SplitArg", ".", "Flags", "[", "<NUM_LIT>", "]", ".", "getPointerAddrSpace", "(", ")", ",", "ArgTy", ".", "getScalarSizeInBits", "(", ")", ")", ";", "ArgTy", "=", "ArgTy", ".", "isVector", "(", ")", "?", "LLT", "::", "vector", "(", "ArgTy", ".", "getElementCount", "(", ")", ",", "PtrTy", ")", ":", "PtrTy", ";", "}", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOLoad", "|", "MachineMemOperand", "::", "MODereferenceable", "|", "MachineMemOperand", "::", "MOInvariant", ",", "ArgTy", ",", "commonAlignment", "(", "Alignment", ",", "FieldOffsets", "[", "Idx", "]", ")", ")", ";", "assert", "(", "SplitArg", ".", "Regs", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", ";", "B", ".", "buildLoad", "(", "SplitArg", ".", "Regs", "[", "<NUM_LIT>", "]", "," ]

[ ",", "SDTIntUnaryOp", ">", ";" ]

[ "def", "LanaiHi", ":", "SDNode", "<", "<STR_LIT>" ]

[ "<STR_LIT>", "no", "<STR_LIT>", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";" ]

[ "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Illegal add imm ", "<STR_LIT>", "<<", "Immed", "<<", "<STR_LIT>", ": avoid UB for INT64_MIN\\n", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "Immed", "=", "std", "::", "abs", "(", "Immed", ")", ";", "bool", "IsLegal", "=", "(", "(", "Immed", ">>", "<NUM_LIT>", ")", "==", "<NUM_LIT>", "||", "(", "(", "Immed", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", "&&", "Immed", ">>", "<NUM_LIT>", "==", "<NUM_LIT>", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Is ", "<STR_LIT>", "<<", "Immed", "<<", "<STR_LIT>", " legal add imm: ", "<STR_LIT>", "<<", "(", "IsLegal", "?", "<STR_LIT>", "yes", "<STR_LIT>", ":" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "idx", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "Simm", ";" ]

[ "def", "_8H", ":", "NeonI_1VModImm", "<", "<NUM_LIT>", ",", "op", ",", "(", "outs", "VPR128", ":", "$", "Rd", ")", ",", "(", "ins", "neon_uimm8", ":", "$", "Imm", ",", "neon_mov_imm_LSLH_operand", ":", "$", "Simm", ")", ",", "!", "strconcat", "(", "asmop", ",", "<STR_LIT>", ")", ",", "[", "(", "set", "(", "v8i16", "VPR128", ":", "$", "Rd", ")", ",", "(", "v8i16", "(", "opnode", "(", "timm", ":", "$", "Imm", ")", ",", "(", "neon_mov_imm_LSLH_operand", ":", "$", "Simm", ")", ")", ")", ")", "]", ",", "NoItinerary", ">", "{", "bit" ]

[ "<STR_LIT>", ")" ]

[ "(", "unspec", ":", "SI", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "MVE_2", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "MVE_2", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "VMLSDAVAXQ_S", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>" ]

[ ")", ")", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "CC", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "compare", ":", "CC", "(", "zero_extend", ":", "SI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "const_int", "<NUM_LIT>" ]

[ ")" ]

[ "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>" ]

[ "}" ]

[ "MachineInstr", "*", "SystemZInstrInfo", "::", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "*", "MI", ",", "ArrayRef", "<", "unsigned", ">", "Ops", ",", "MachineInstr", "*", "LoadMI", ")", "const", "{", "return", "nullptr", ";" ]

[ "case", "ARM", "::", "R12", ":", "return", "ARM", "::", "SP", ";", "case", "ARM", "::", "SP", ":", "return", "ARM", "::", "LR", ";" ]

[ "case", "ARM", "::", "R4", ":", "return", "ARM", "::", "R5", ";", "case", "ARM", "::", "R5", ":", "return", "ARM", "::", "R6", ";", "case", "ARM", "::", "R6", ":", "return", "ARM", "::", "R7", ";", "case", "ARM", "::", "R7", ":", "return", "ARM", "::", "R8", ";", "case", "ARM", "::", "R8", ":", "return", "ARM", "::", "R9", ";", "case", "ARM", "::", "R9", ":", "return", "ARM", "::", "R10", ";", "case", "ARM", "::", "R10", ":", "return", "ARM", "::", "R11", ";", "case", "ARM", "::", "R11", ":", "return", "ARM", "::", "R12", ";" ]

[ "return", "(", "x", ".", "q", ")", ";" ]

[ "}", "x", ";", "x", ".", "l", "[", "<NUM_LIT>", "]", "=", "l", ";" ]

[ "<FIXS>", "abort", "(", ")", ";", "<FIXE>" ]

[ "||", "code", "==", "UNEQ", "||", "code", "==", "LTGT", "||", "code", "==", "UNGT", "||", "code", "==", "UNLT", "||", "code", "==", "UNGE", "||", "code", "==", "UNLE", ")", ")", "<BUGS>", "abort", "(", ")", ";", "<BUGE>" ]

[ "<STR_LIT>", ")", ";" ]

[ "SDValue", "Op0", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Op0", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "EXTRACT_SUBVECTOR", "&&", "!", "(", "Op0", "->", "isMachineOpcode", "(", ")", "&&", "Op0", "->", "getMachineOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "return", "SDValue", "(", ")", ";", "uint64_t", "idx", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op0", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ";", "if", "(", "Op0", "->", "getOpcode", "(", ")", "==", "ISD", "::", "EXTRACT_SUBVECTOR", ")", "{", "if", "(", "Op0", "->", "getValueType", "(", "<NUM_LIT>", ")", ".", "getVectorNumElements", "(", ")", "!=", "idx", "&&", "idx", "!=", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "}", "else", "if", "(", "Op0", "->", "getMachineOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "if", "(", "idx", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "SDValue", "(", ")", ";", "idx", "=", "<NUM_LIT>", ";", "}", "if", "(", "Op0", "->", "getOperand", "(", "<NUM_LIT>", ")", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "BITCAST", ")", "return", "SDValue", "(", ")", ";", "SDValue", "Source", "=", "Op0", "->", "getOperand", "(", "<NUM_LIT>", ")", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "EVT", "SVT", "=", "Source", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "if", "(", "SVT", ".", "getVectorNumElements", "(", ")", "!=", "VT", ".", "getVectorNumElements", "(", ")", "*", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "arm64-lower: bitcast extract_subvector simplification\\n" ]

[ "}" ]

[ "X86AddressMode", "AM", ";", "assert", "(", "DI", "->", "getAddress", "(", ")", "&&", "<STR_LIT>", "Null address should be checked earlier!", "<STR_LIT>", ")", ";", "if", "(", "!", "X86SelectAddress", "(", "DI", "->", "getAddress", "(", ")", ",", "AM", ")", ")", "return", "false", ";", "const", "MCInstrDesc", "&", "II", "=", "TII", ".", "get", "(", "TargetOpcode", "::", "DBG_VALUE", ")", ";", "addFullAddress", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ")", ",", "AM", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMetadata", "(", "DI", "->", "getVariable", "(", ")", ")", ";", "return", "true", ";", "}", "case", "Intrinsic", "::", "trap", ":", "{", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "X86", "::", "TRAP", ")", ")", ";", "return", "true", ";", "}", "case", "Intrinsic", "::", "sadd_with_overflow", ":", "case", "Intrinsic", "::", "uadd_with_overflow", ":", "{", "const", "Function", "*", "Callee", "=", "I", ".", "getCalledFunction", "(", ")", ";", "Type", "*", "RetTy", "=", "cast", "<", "StructType", ">", "(", "Callee", "->", "getReturnType", "(", ")", ")", "->", "getTypeAtIndex", "(", "unsigned", "(", "<NUM_LIT>", ")", ")", ";", "MVT", "VT", ";", "if", "(", "!", "isTypeLegal", "(", "RetTy", ",", "VT", ")", ")", "return", "false", ";", "const", "Value", "*", "Op1", "=", "I", ".", "getArgOperand", "(", "<NUM_LIT>", ")", ";", "const", "Value", "*", "Op2", "=", "I", ".", "getArgOperand", "(", "<NUM_LIT>", ")", ";", "unsigned", "Reg1", "=", "getRegForValue", "(", "Op1", ")", ";", "unsigned", "Reg2", "=", "getRegForValue", "(", "Op2", ")", ";", "if", "(", "Reg1", "==", "<NUM_LIT>", "||", "Reg2", "==", "<NUM_LIT>", ")", "return", "false", ";", "unsigned", "OpC", "=", "<NUM_LIT>", ";", "if", "(", "VT", "==", "MVT", "::", "i32", ")", "OpC", "=", "X86", "::", "ADD32rr", ";", "else", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "OpC", "=", "X86", "::", "ADD64rr", ";", "else", "return", "false", ";", "unsigned", "ResultReg", "=", "FuncInfo", ".", "CreateRegs", "(", "I", ".", "getType", "(", ")", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "OpC", ")", ",", "ResultReg", ")", ".", "addReg", "(", "Reg1", ")", ".", "addReg", "(", "Reg2", ")", ";", "unsigned", "Opc", "=", "X86", "::", "SETBr", ";", "if", "(", "I", ".", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "sadd_with_overflow", ")", "Opc", "=", "X86", "::", "SETOr", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "ResultReg", "+", "<NUM_LIT>", ")", ";", "UpdateValueMap", "(", "&", "I", ",", "ResultReg", ",", "<NUM_LIT>", ")", ";", "return", "true", ";" ]

[ "HasV8_4a", "]", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Predicates", "=", "[" ]

[ "<FIXS>", "rtx_code_label", "*", "label", ";", "rtx", "src_reg", ",", "dest_reg", ",", "final_src", ",", "test", ";", "<FIXE>" ]

[ "mips_block_move_loop", "(", "rtx", "dest", ",", "rtx", "src", ",", "HOST_WIDE_INT", "length", ",", "HOST_WIDE_INT", "bytes_per_iter", ")", "{", "<BUGS>", "rtx", "label", ",", "src_reg", ",", "dest_reg", ",", "final_src", ",", "test", ";", "<BUGE>", "HOST_WIDE_INT", "leftover", ";", "leftover", "=", "length", "%", "bytes_per_iter", ";" ]

[ "<FIXS>", "&&", "aarch_ra_sign_key", "==", "AARCH_KEY_B", ")", "<FIXE>" ]

[ "aarch64_post_cfi_startproc", "(", "FILE", "*", "f", ",", "tree", "ignored", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "cfun", "->", "machine", "->", "frame", ".", "laid_out", "&&", "aarch64_return_address_signing_enabled", "(", ")", "<BUGS>", "&&", "aarch64_ra_sign_key", "==", "AARCH64_KEY_B", ")", "<BUGE>", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "\\t.cfi_b_key_frame\\n", "<STR_LIT>", ")", ";", "}" ]

[ "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "+", "<NUM_LIT>", ")", "return", "<STR_LIT>", "}" ]

[ "e", "->", "dest", ")", ",", "<NUM_LIT>", ")", ")", "{" ]

[ "if", "(", "bitmap_bit_p", "(", "edge_components", ",", "<NUM_LIT>", ")", "&&", "bitmap_bit_p", "(", "DF_LIVE_IN", "(" ]

[ "if", "(", "FirstReg", "==", "SecondReg", ")", "return", "false", ";" ]

[ "int", "OffImm", "=", "getMemoryOpOffset", "(", "*", "Op0", ")", ";", "if", "(", "isT2", ")", "{", "int", "Limit", "=", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", "*", "Scale", ";", "if", "(", "OffImm", ">=", "Limit", "||", "(", "OffImm", "<=", "-", "Limit", ")", "||", "(", "OffImm", "&", "(", "Scale", "-", "<NUM_LIT>", ")", ")", ")", "return", "false", ";", "Offset", "=", "OffImm", ";", "}", "else", "{", "<STR_LIT>", "::", "<STR_LIT>", "AddSub", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "OffImm", "<", "<NUM_LIT>", ")", "{", "AddSub", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "OffImm", "=", "-", "OffImm", ";", "}", "int", "Limit", "=", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", "*", "Scale", ";", "if", "(", "OffImm", ">=", "Limit", "||", "(", "OffImm", "&", "(", "Scale", "-", "<NUM_LIT>", ")", ")", ")", "return", "false", ";", "Offset", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", "AddSub", ",", "OffImm", ")", ";", "}", "FirstReg", "=", "Op0", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "SecondReg", "=", "Op1", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";" ]

[ "let", "opExtendable", "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "isCompare", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";" ]

[ "CastOpc", "=", "ISD", "::", "SIGN_EXTEND", ";" ]

[ "static", "SDValue", "LowerVectorINT_TO_FP", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "{", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "SDLoc", "dl", "(", "Op", ")", ";", "if", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i32", ")", "{", "if", "(", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "f32", ")", "return", "Op", ";", "return", "DAG", ".", "UnrollVectorOp", "(", "Op", ".", "getNode", "(", ")", ")", ";", "}", "assert", "(", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "v4i16", "||", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "v8i16", ")", "&&", "<STR_LIT>", "Invalid type for custom lowering!", "<STR_LIT>", ")", ";", "const", "bool", "HasFullFP16", "=", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "DAG", ".", "getSubtarget", "(", ")", ")", ".", "hasFullFP16", "(", ")", ";", "EVT", "DestVecType", ";", "if", "(", "VT", "==", "MVT", "::", "v4f32", ")", "DestVecType", "=", "MVT", "::", "v4i32", ";", "else", "if", "(", "VT", "==", "MVT", "::", "v4f16", "&&", "HasFullFP16", ")", "DestVecType", "=", "MVT", "::", "v4i16", ";", "else", "if", "(", "VT", "==", "MVT", "::", "v8f16", "&&", "HasFullFP16", ")", "DestVecType", "=", "MVT", "::", "v8i16", ";", "else", "return", "DAG", ".", "UnrollVectorOp", "(", "Op", ".", "getNode", "(", ")", ")", ";", "unsigned", "CastOpc", ";", "unsigned", "Opc", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Invalid opcode!", "<STR_LIT>", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":" ]

[ "return", "false", ";" ]

[ "bool", "addPreISel", "(", ")", "override", "{", "addPass", "(", "createFlattenCFGPass", "(", ")", ")", ";", "addPass", "(", "createStructurizeCFGPass", "(", ")", ")", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "def", "C4_and_or", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "PredRegs", ":", "$", "Ps4", ",", "PredRegs", ":", "$", "Pt4", ",", "PredRegs", ":", "$", "Pu4", ")", ",", "<STR_LIT>", ",", "tc_b31c2e97", ",", "TypeCR", ">", ",", "Enc_9ac432", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "(", ")", ";" ]

[ "}", "else", "{", "if", "(", "Bytes", "<=", "<NUM_LIT>", ")", "{", "SDValue", "Chain1", "=", "DAG", ".", "getStore", "(", "Chain", ",", "DL", ",", "Byte", ",", "Dst", ",", "DstPtrInfo", ",", "false", ",", "false", ",", "Align", ")", ";", "if", "(", "Bytes", "==", "<NUM_LIT>", ")", "return", "Chain1", ";", "SDValue", "Dst2", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "PtrVT", ",", "Dst", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "PtrVT", ")", ")", ";", "SDValue", "Chain2", "=", "DAG", ".", "getStore", "(", "Chain", ",", "DL", ",", "Byte", ",", "Dst2", ",", "DstPtrInfo", ".", "getWithOffset", "(", "<NUM_LIT>", ")", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "DL", ",", "MVT", "::", "Other", ",", "Chain1", ",", "Chain2", ")", ";", "}", "}", "assert", "(", "Bytes", ">=", "<NUM_LIT>", "&&", "<STR_LIT>", "Should have dealt with 0- and 1-byte cases already", "<STR_LIT>", ")", ";", "auto", "*", "CByte", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Byte", ")", ";", "if", "(", "CByte", "&&", "CByte", "->", "getZExtValue", "(", ")", "==", "<NUM_LIT>", ")", "return", "emitMemMem", "(", "DAG", ",", "DL", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "Chain", ",", "Dst", ",", "Dst", ",", "Bytes", ")", ";", "Chain", "=", "DAG", ".", "getStore", "(", "Chain", ",", "DL", ",", "Byte", ",", "Dst", ",", "DstPtrInfo", ",", "false", ",", "false", ",", "Align", ")", ";", "SDValue", "DstPlus1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "PtrVT", ",", "Dst", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "PtrVT", ")", ")", ";", "return", "emitMemMem", "(", "DAG", ",", "DL", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "Chain", ",", "DstPlus1", ",", "Dst", ",", "Bytes", "-", "<NUM_LIT>", ")", ";", "}", "return", "SDValue" ]

[ "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-" ]

[ "case", "Intrinsic", "::", "x86_xtest", ":", "{" ]

[ "case", "Intrinsic", "::", "x86_rdrand_64", ":", "case", "Intrinsic", "::", "x86_rdseed_16", ":", "case", "Intrinsic", "::", "x86_rdseed_32", ":", "case", "Intrinsic", "::", "x86_rdseed_64", ":", "{", "unsigned", "Opcode", "=", "(", "IntNo", "==", "Intrinsic", "::", "x86_rdseed_16", "||", "IntNo", "==", "Intrinsic", "::", "x86_rdseed_32", "||", "IntNo", "==", "Intrinsic", "::", "x86_rdseed_64", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "Op", "->", "getValueType", "(", "<NUM_LIT>", ")", ",", "MVT", "::", "Glue", ",", "MVT", "::", "Other", ")", ";", "SDValue", "Result", "=", "DAG", ".", "getNode", "(", "Opcode", ",", "dl", ",", "VTs", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "DAG", ".", "getZExtOrTrunc", "(", "Result", ",", "dl", ",", "Op", "->", "getValueType", "(", "<NUM_LIT>", ")", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "Op", "->", "getValueType", "(", "<NUM_LIT>", ")", ")", ",", "DAG", ".", "getConstant", "(", "X86", "::", "COND_B", ",", "MVT", "::", "i32", ")", ",", "SDValue", "(", "Result", ".", "getNode", "(", ")", ",", "<NUM_LIT>", ")", "}", ";", "SDValue", "isValid", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "DAG", ".", "getVTList", "(", "Op", "->", "getValueType", "(", "<NUM_LIT>", ")", ",", "MVT", "::", "Glue", ")", ",", "Ops", ",", "array_lengthof", "(", "Ops", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "MERGE_VALUES", ",", "dl", ",", "Op", "->", "getVTList", "(", ")", ",", "Result", ",", "isValid", ",", "SDValue", "(", "Result", ".", "getNode", "(", ")", ",", "<NUM_LIT>", ")", ")", ";", "}" ]

[ "return", "!", "isPredicated", "(", "MI", ")", ";" ]

[ "if", "(", "MI", ".", "isBranch", "(", ")", "&&", "!", "MI", ".", "isBarrier", "(", ")", ")", "return", "true", ";", "if", "(", "!", "MI", ".", "isPredicable", "(", ")", ")", "return", "true", ";" ]

[ ")", ")" ]

[ "(", "eq_attr", "<STR_LIT>", "<STR_LIT>" ]

[ "<FIXS>", "void", "PatmosFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "<FIXE>", "<FIXS>", "const", "TargetInstrInfo", "*", "TII", "=", "TM", ".", "getInstrInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "TM", ".", "getRegisterInfo", "(", ")", ";", "<FIXE>" ]

[ "}", "}", "<BUGS>", "void", "PatmosFrameLowering", "::", "processFunctionBeforeCalleeSavedScan", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "<BUGE>", "<BUGS>", "const", "TargetInstrInfo", "*", "TII", "=", "STC", ".", "getInstrInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "STC", ".", "getRegisterInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "<BUGE>", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "PatmosMachineFunctionInfo", "&", "PMFI", "=", "*", "MF", ".", "getInfo", "PatmosMachineFunctionInfo", ">", "(", ")", ";" ]

[ "!=", "NoCand", ";" ]

[ "TryCand", ".", "Reason", "=", "NodeOrder", ";", "return", "true", ";", "}", "if", "(", "tryLess", "(", "Top", ".", "getLatencyStallCycles", "(", "TryCand", ".", "SU", ")", ",", "Top", ".", "getLatencyStallCycles", "(", "Cand", ".", "SU", ")", ",", "TryCand", ",", "Cand", ",", "Stall", ")", ")", "return", "TryCand", ".", "Reason", "!=", "NoCand", ";", "if", "(", "tryGreater", "(", "TryCand", ".", "SU", "==", "DAG", "->", "getNextClusterSucc", "(", ")", ",", "Cand", ".", "SU", "==", "DAG", "->", "getNextClusterSucc", "(", ")", ",", "TryCand", ",", "Cand", ",", "Cluster", ")", ")", "return", "TryCand", ".", "Reason", "!=", "NoCand", ";", "if", "(", "tryLess", "(", "TryCand", ".", "ResDelta", ".", "CritResources", ",", "Cand", ".", "ResDelta", ".", "CritResources", ",", "TryCand", ",", "Cand", ",", "ResourceReduce", ")", ")", "return", "TryCand", ".", "Reason", "!=", "NoCand", ";", "if", "(", "tryGreater", "(", "TryCand", ".", "ResDelta", ".", "DemandedResources", ",", "Cand", ".", "ResDelta", ".", "DemandedResources", ",", "TryCand", ",", "Cand", ",", "ResourceDemand", ")", ")", "return", "TryCand", ".", "Reason", "!=", "NoCand", ";", "if", "(", "Cand", ".", "Policy", ".", "ReduceLatency", "&&", "tryLatency", "(", "TryCand", ",", "Cand", ",", "Top", ")", ")", "{", "return", "TryCand", ".", "Reason" ]

[ "let", "Switches", "=", "sw", ";" ]

[ "let", "Itinerary", "=", "IIC_LoadScalGlobalMask", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "dest", ";", "bits", "<", "<NUM_LIT>", ">", "addr", ";", "bits", "<", "<NUM_LIT>", ">", "dimmask", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "SrcA", "=", "addr", ";", "let", "SrcExtra", "=", "{", "<NUM_LIT>", ",", "dimmask", ",", "<NUM_LIT>", "}", ";", "let", "Dest", "=", "dest", ";" ]

[ "<FIXS>", "M", "L", "P", "MV", "P", "P", "J", "E", "M", "t", "a", "R", "s", "c", "<FIXE>" ]

[ "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "avr1", "<STR_LIT>", "}", "," ]

[ "<FIXS>", "(", "define_insn_and_split", "<STR_LIT>", "<FIXE>", "<FIXS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<FIXE>", "<FIXS>", "(", "define_insn_and_split", "<STR_LIT>", "<FIXE>", "<FIXS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<FIXE>" ]

[ "avr_fix_inputs", "(", "operands", ",", "<NUM_LIT>", "<NUM_LIT>", ",", "regmask", "(", "QImode", ",", "<NUM_LIT>", ")", ")", "}", ")", "<BUGS>", "(", "define_insn", "<STR_LIT>", "<BUGE>", "[", "(", "set", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "HI", "[", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_FMULS", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<BUGS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>", "<BUGS>", "(", "define_insn", "<STR_LIT>", "<BUGE>", "[", "(", "set", "(", "reg", ":", "HI", "<NUM_LIT>", ")", "(", "unspec", ":", "HI", "[", "(", "reg", ":", "QI", "<NUM_LIT>", ")", "(", "reg", ":", "QI", "<NUM_LIT>", ")", "]", "UNSPEC_FMULS", ")", ")", "(", "clobber", "(", "reg", ":", "HI", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<BUGS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_expand", "<STR_LIT>" ]

[ "let", "cofMax1", "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "AVX5128IBase", ",", "EVEX", ",", "VVVV", ",", "Sched", "[", "sched", "]", ">", ";", "<FIXE>", "<FIXS>", "AVX5128IBase", ",", "EVEX", ",", "VVVV", ",", "EVEX_CD8", "_", ".", "EltSize", ",", "CD8VF", ">", ",", "<FIXE>" ]

[ "(", "ins", "_", ".", "RC", ":", "$", "src1", ",", "_", ".", "RC", ":", "$", "src2", ")", ",", "OpcodeStr", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "(", "_", ".", "VT", "(", "OpNode", "_", ".", "RC", ":", "$", "src1", ",", "(", "_", ".", "VT", "_", ".", "RC", ":", "$", "src2", ")", ")", ")", ">", ",", "<BUGS>", "AVX5128IBase", ",", "EVEX_4V", ",", "Sched", "[", "sched", "]", ">", ";", "<BUGE>", "defm", "rm", ":", "AVX512_maskable", "opc", ",", "MRMSrcMem", ",", "_", ",", "(", "outs", "_", ".", "RC", ":", "$", "dst", ")", ",", "(", "ins", "_", ".", "RC", ":", "$", "src1", ",", "_", ".", "MemOp", ":", "$", "src2", ")", ",", "OpcodeStr", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "(", "_", ".", "VT", "(", "OpNode", "_", ".", "RC", ":", "$", "src1", ",", "(", "_", ".", "VT", "(", "_", ".", "LdFrag", "addr", ":", "$", "src2", ")", ")", ")", ")", ">", ",", "<BUGS>", "AVX5128IBase", ",", "EVEX_4V", ",", "EVEX_CD8", "_", ".", "EltSize", ",", "CD8VF", ">", ",", "<BUGE>", "Sched", "[", "sched", ".", "Folded", ",", "sched", ".", "ReadAfterFold", "]", ">", ";", "}", "}" ]

[ "_", "imm", ")", "{" ]

[ "_", "_", "arm_vqshrntq", "(", "uint16x8_t", "_", "_", "a", ",", "uint32x4_t", "_", "_", "b", ",", "const", "int", "_" ]

[ "break", ";" ]

[ "break", ";", "case", "UNSPEC_TPOFF", ":", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "x", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ";", "fputs", "(", "<STR_LIT>", "@TPOFF", "<STR_LIT>", ",", "file", ")", ";", "break", ";", "case", "UNSPEC_CALLER", ":", "{", "char", "name", "[", "<NUM_LIT>", "]", ";", "targetm", ".", "asm_out", ".", "generate_internal_label", "(", "name", ",", "<STR_LIT>", "LPCS", "<STR_LIT>", ",", "INTVAL", "(", "XVECEXP", "(", "x", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ")", ";", "assemble_name", "(", "file", ",", "name", ")", ";", "}", "break", ";", "case", "UNSPEC_SYMOFF", ":", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "x", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ";", "fputc", "(", "'", "-", "'", ",", "file", ")", ";", "if", "(", "GET_CODE", "(", "XVECEXP", "(", "x", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "==", "CONST", ")", "{", "fputc", "(", "'", "(", "'", ",", "file", ")", ";", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "x", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ";", "fputc", "(", "'", ")", "'", ",", "file", ")", ";", "}", "else", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "x", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ";", "break", ";", "case", "UNSPEC_PCREL_SYMOFF", ":", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "x", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ";", "fputs", "(", "<STR_LIT>", "-(", "<STR_LIT>", ",", "file", ")", ";", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "x", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ";", "fputs", "(", "<STR_LIT>", "-.)", "<STR_LIT>", ",", "file", ")", ";" ]

[ "let", "prefersSlot3", "=", "<NUM_LIT>", ";" ]

[ "def", "A2_vminh", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rtt32", ",", "DoubleRegs", ":", "$", "Rss32", ")", ",", "<STR_LIT>", ",", "tc_779080bf", ",", "TypeALU64", ">", ",", "Enc_ea23e4", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ ")", "return", "false", ";" ]

[ "bool", "HexagonLoopIdiomRecognize", "::", "isLegalStore", "(", "Loop", "*", "CurLoop", ",", "StoreInst", "*", "SI", ")", "{", "if", "(", "!", "(", "SI", "->", "isVolatile", "(", ")", "&&", "HexagonVolatileMemcpy", ")", "&&", "!", "SI", "->", "isSimple", "(", ")", ")", "return", "false", ";", "Value", "*", "StoredVal", "=", "SI", "->", "getValueOperand", "(", ")", ";", "Value", "*", "StorePtr", "=", "SI", "->", "getPointerOperand", "(", ")", ";", "uint64_t", "SizeInBits", "=", "DL", "->", "getTypeSizeInBits", "(", "StoredVal", "->", "getType", "(", ")", ")", ";", "if", "(", "(", "SizeInBits", "&", "<NUM_LIT>", ")", "||", "(", "SizeInBits", ">>", "<NUM_LIT>", ")", "!=", "<NUM_LIT>", ")", "return", "false", ";", "auto", "*", "StoreEv", "=", "dyn_cast", "<", "SCEVAddRecExpr", ">", "(", "SE", "->", "getSCEV", "(", "StorePtr", ")", ")", ";", "if", "(", "!", "StoreEv", "||", "StoreEv", "->", "getLoop", "(", ")", "!=", "CurLoop", "||", "!", "StoreEv", "->", "isAffine", "(", ")", ")", "return", "false", ";", "int", "Stride", "=", "getSCEVStride", "(", "StoreEv", ")", ";", "if", "(", "Stride", "==", "<NUM_LIT>" ]

[ "true", ";" ]

[ "rtx", "mem", "[", "num_insns", "]", ",", "reg", "[", "num_insns", "]", ",", "base", "[", "num_insns", "]", ",", "offset", "[", "num_insns", "]", ";", "if", "(", "load", ")", "{", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "num_insns", ";", "i", "++", ")", "{", "reg", "[", "i", "]", "=", "operands", "[", "<NUM_LIT>", "*", "i", "]", ";", "mem", "[", "i", "]", "=", "operands", "[", "<NUM_LIT>", "*", "i", "+", "<NUM_LIT>", "]", ";", "gcc_assert", "(", "REG_P", "(", "reg", "[", "i", "]", ")", ")", ";", "}", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "+=", "<NUM_LIT>", ")", "for", "(", "int", "j", "=", "i", "+", "<NUM_LIT>", ";", "j", "<", "<NUM_LIT>", ";", "j", "+=", "<NUM_LIT>", ")", "if", "(", "reg_overlap_mentioned_p", "(", "operands", "[", "i", "]", ",", "operands", "[", "j", "]", ")", ")", "return", "false", ";", "}", "else", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "num_insns", ";", "i", "++", ")", "{", "mem", "[", "i", "]", "=", "operands", "[", "<NUM_LIT>", "*", "i", "]", ";", "reg", "[", "i", "]", "=", "operands", "[", "<NUM_LIT>", "*", "i", "+", "<NUM_LIT>", "]", ";", "}", "if", "(", "!", "MEM_P", "(", "mem", "[", "<NUM_LIT>", "]", ")", "||", "aarch64_mem_pair_operand", "(", "mem", "[", "<NUM_LIT>", "]", ",", "mode", ")", ")", "return", "false", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "num_insns", ";", "i", "++", ")", "{", "if", "(", "MEM_VOLATILE_P", "(", "mem", "[", "i", "]", ")", ")", "return", "false", ";", "extract_base_offset_in_addr", "(", "mem", "[", "i", "]", ",", "base", "+", "i", ",", "offset", "+", "i", ")", ";", "if", "(", "base", "[", "i", "]", "==", "NULL_RTX", "||", "offset", "[", "i", "]", "==", "NULL_RTX", ")", "return", "false", ";", "}", "rclass", "=", "REG_P", "(", "reg", "[", "<NUM_LIT>", "]", ")", "&&", "FP_REGNUM_P", "(", "REGNO", "(", "reg", "[", "<NUM_LIT>", "]", ")", ")", "?", "FP_REGS", ":", "GENERAL_REGS", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "num_insns", ";", "i", "++", ")", "if", "(", "REG_P", "(", "reg", "[", "i", "]", ")", "&&", "FP_REGNUM_P", "(", "REGNO", "(", "reg", "[", "i", "]", ")", ")", ")", "{", "if", "(", "rclass", "!=", "FP_REGS", ")", "return", "false", ";", "}", "else", "{", "if", "(", "rclass", "!=", "GENERAL_REGS", ")", "return", "false", ";", "}", "if", "(", "rclass", "==", "GENERAL_REGS", "&&", "load", ")", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "num_insns", "-", "<NUM_LIT>", ";", "i", "++", ")", "if", "(", "reg_mentioned_p", "(", "reg", "[", "i", "]", ",", "mem", "[", "i", "]", ")", ")", "return", "false", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "num_insns", "-", "<NUM_LIT>", ";", "i", "++", ")", "if", "(", "!", "rtx_equal_p", "(", "base", "[", "i", "]", ",", "base", "[", "i", "+", "<NUM_LIT>", "]", ")", ")", "return", "false", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "num_insns", ";", "i", "++", ")", "offvals", "[", "i", "]", "=", "INTVAL", "(", "offset", "[", "i", "]", ")", ";", "msize", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "qsort", "(", "offvals", ",", "num_insns", ",", "sizeof", "(", "HOST_WIDE_INT", ")", ",", "aarch64_host_wide_int_compare", ")", ";", "if", "(", "!", "(", "offvals", "[", "<NUM_LIT>", "]", "==", "offvals", "[", "<NUM_LIT>", "]", "+", "msize", "&&", "offvals", "[", "<NUM_LIT>", "]", "==", "offvals", "[", "<NUM_LIT>", "]", "+", "msize", ")", ")", "return", "false", ";", "if", "(", "offvals", "[", "<NUM_LIT>", "]", "-", "offvals", "[", "<NUM_LIT>", "]", ">=", "msize", "*", "<NUM_LIT>", ")", "return", "false", ";", "if", "(", "offvals", "[", "<NUM_LIT>", "]", "%", "msize", "!=", "offvals", "[", "<NUM_LIT>", "]", "%", "msize", ")", "return", "false", ";", "if", "(", "mode", "==", "SImode", "&&", "(", "aarch64_tune_params", ".", "extra_tuning_flags", "&", "AARCH64_EXTRA_TUNE_SLOW_UNALIGNED_LDPW", ")", "&&", "!", "optimize_size", "&&", "MEM_ALIGN", "(", "mem", "[", "<NUM_LIT>", "]", ")", "<", "<NUM_LIT>", "*", "BITS_PER_UNIT", ")", "return", "false", ";", "return" ]

[ "<NUM_LIT>", ")", ")", ";" ]

[ "tree", "hold_ldfsr", "=", "build_call_expr", "(", "ldfsr", ",", "<NUM_LIT>", ",", "tmp1_addr", ")", ";", "*", "hold", "=", "compound_expr", "(", "compound_expr", "(", "hold_stfsr", ",", "hold_mask", ")", ",", "hold_ldfsr", ")", ";", "*", "clear", "=", "build_call_expr", "(", "ldfsr", ",", "<NUM_LIT>", ",", "tmp1_addr", ")", ";", "tree", "tmp2_var", "=", "create_tmp_var_raw", "(", "unsigned_type_node", ")", ";", "TREE_ADDRESSABLE", "(", "tmp2_var", ")", "=", "<NUM_LIT>", ";", "tree", "tmp2_addr", "=", "build_fold_addr_expr", "(", "tmp2_var", ")", ";", "tree", "update_stfsr", "=", "build4", "(", "TARGET_EXPR", ",", "unsigned_type_node", ",", "tmp2_var", ",", "build_call_expr", "(", "stfsr", ",", "<NUM_LIT>", ",", "tmp2_addr", ")", ",", "NULL_TREE", ",", "NULL_TREE", ")", ";", "tree", "update_ldfsr", "=", "build_call_expr", "(", "ldfsr", ",", "<NUM_LIT>", ",", "fenv_addr", ")", ";", "tree", "atomic_feraiseexcept", "=", "builtin_decl_implicit", "(", "BUILT_IN_ATOMIC_FERAISEEXCEPT", ")", ";", "tree", "update_call", "=", "build_call_expr", "(", "atomic_feraiseexcept", ",", "<NUM_LIT>", ",", "fold_convert", "(", "integer_type_node", ",", "tmp2_var", ")", ")", ";", "if", "(", "SPARC_LOW_FE_EXCEPT_VALUES", ")", "{", "tree", "shifted_tmp2_var", "=", "build2", "(", "RSHIFT_EXPR", ",", "unsigned_type_node", ",", "tmp2_var", ",", "build_int_cst", "(", "unsigned_type_node", "," ]

[ "<FIXS>", "Register", "DestSub0", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "Register", "DestSub1", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "<FIXE>" ]

[ "MachineOperand", "&", "Src0", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "MachineOperand", "&", "Src1", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "<BUGS>", "unsigned", "DestSub0", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "unsigned", "DestSub1", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "<BUGE>", "MachineOperand", "Src0Sub0", "=", "TII", "->", "buildExtractSubRegOrImm", "(", "MI", ",", "MRI", ",", "Src0", ",", "BoolRC", ",", "AMDGPU", "::", "sub0", "," ]

[ "}" ]

[ "if", "(", "!", "MRI", "->", "hasOneDef", "(", "Reg", ")", ")", "{", "LLVM_DEBUG", "(", "this", "->", "getEntry", "(", ")", "->", "getParent", "(", ")", "->", "dump", "(", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "printReg", "(", "Reg", ",", "TRI", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "}", "if", "(", "MRI", "->", "def_begin", "(", "Reg", ")", "==", "MRI", "->", "def_end", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Register ", "<STR_LIT>", "<<", "printReg", "(", "Reg", ",", "MRI", "->", "getTargetRegisterInfo", "(", ")", ")", "<<", "<STR_LIT>", " has NO defs\\n", "<STR_LIT>", ")", ";", "}", "else", "if", "(", "!", "MRI", "->", "hasOneDef", "(", "Reg", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Register ", "<STR_LIT>", "<<", "printReg", "(", "Reg", ",", "MRI", "->", "getTargetRegisterInfo", "(", ")", ")", "<<", "<STR_LIT>", " has multiple defs\\n", "<STR_LIT>", ")", ";", "}", "assert", "(", "MRI", "->", "hasOneDef", "(", "Reg", ")", "&&", "<STR_LIT>", "Register has multiple definitions", "<STR_LIT>", ")", ";", "MachineOperand", "*", "Def", "=", "&", "(", "*", "(", "MRI", "->", "def_begin", "(", "Reg", ")", ")", ")", ";", "MachineOperand", "*", "UseOperand", "=", "&", "(", "RI", ")", ";", "bool", "UseIsOutsideDefMBB", "=", "Def", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "!=", "MBB", ";", "if", "(", "UseIsOutsideDefMBB", "&&", "UseOperand", "->", "isKill", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Removing kill flag on register: ", "<STR_LIT>", "<<", "printReg", "(", "Reg", ",", "TRI", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "UseOperand", "->", "setIsKill", "(", "false", ")", ";", "}", "}", "}", "}", "}" ]

[ ")", "_", "_", "a", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_castph_si128", "(", "_", "_", "m128h", "_", "_", "a", ")", "{", "return", "(", "_", "_", "m128i" ]

[ "CLI", ".", "NumResultRegs", "=", "<NUM_LIT>", ";" ]

[ "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "AdjStackUp", ")", ")", ".", "addImm", "(", "NumBytes", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "if", "(", "RetVT", "!=", "MVT", "::", "isVoid", ")", "{", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CC", ",", "false", ",", "*", "FuncInfo", ".", "MF", ",", "RVLocs", ",", "*", "Context", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "RetVT", ",", "CCAssignFnForCall", "(", "CC", ")", ")", ";", "if", "(", "RVLocs", ".", "size", "(", ")", "!=", "<NUM_LIT>", ")", "return", "false", ";", "MVT", "CopyVT", "=", "RVLocs", "[", "<NUM_LIT>", "]", ".", "getValVT", "(", ")", ";", "if", "(", "CopyVT", ".", "isVector", "(", ")", "&&", "!", "Subtarget", "->", "isLittleEndian", "(", ")", ")", "return", "false", ";", "unsigned", "ResultReg", "=", "createResultReg", "(", "TLI", ".", "getRegClassFor", "(", "CopyVT", ")", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "ResultReg", ")", ".", "addReg", "(", "RVLocs", "[", "<NUM_LIT>", "]", ".", "getLocReg", "(", ")", ")", ";", "CLI", ".", "InRegs", ".", "push_back", "(", "RVLocs", "[", "<NUM_LIT>", "]", ".", "getLocReg", "(", ")", ")", ";", "CLI", ".", "ResultReg", "=", "ResultReg", ";" ]

[ "false", ";" ]

[ "void", "initPacketizerState", "(", ")", "{", "ConsideredInstUsesAlreadyWrittenVectorElement", "=" ]

[ "_", "X", ",", "(", "_", "_", "v4si", ")", "_", "_", "Y", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_srlv_epi32", "(", "_", "_", "m128i", "_", "_", "X", ",", "_", "_", "m128i", "_", "_", "Y", ")", "{", "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_psrlv4si", "(", "(", "_", "_", "v4si", ")", "_" ]

[ "true", ")", ";" ]

[ "setOperationAction", "(", "ISD", "::", "MULHU", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "MULHU", ",", "MVT", "::", "v2i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "MULHS", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "MULHS", ",", "MVT", "::", "v2i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ADD", ",", "MVT", "::", "v2i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SREM", ",", "MVT", "::", "v2i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "Constant", ",", "MVT", "::", "i64", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SDIV", ",", "MVT", "::", "v2i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "TRUNCATE", ",", "MVT", "::", "v2i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND", ",", "MVT", "::", "v2i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ZERO_EXTEND", ",", "MVT", "::", "v2i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ANY_EXTEND", ",", "MVT", "::", "v2i64", ",", "Expand", ")", ";", "if", "(", "STM", ".", "hasHWFP64", "(", ")", ")", "{", "setOperationAction", "(", "ISD", "::", "FADD", ",", "MVT", "::", "v2f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FSUB", ",", "MVT", "::", "v2f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FMUL", ",", "MVT", "::", "v2f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FP_ROUND_INREG", ",", "MVT", "::", "v2f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FP_EXTEND", ",", "MVT", "::", "v2f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ConstantFP", ",", "MVT", "::", "f64", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "TRUNCATE", ",", "MVT", "::", "v2f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND", ",", "MVT", "::", "v2f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ZERO_EXTEND", ",", "MVT", "::", "v2f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ANY_EXTEND", ",", "MVT", "::", "v2f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FABS", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FABS", ",", "MVT", "::", "v2f64", ",", "Expand", ")", ";", "}", "setOperationAction", "(", "ISD", "::", "UDIV", ",", "MVT", "::", "v2i8", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UDIV", ",", "MVT", "::", "v4i8", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UDIV", ",", "MVT", "::", "v2i16", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UDIV", ",", "MVT", "::", "v4i16", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SUBC", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ADDE", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ADDC", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "BRCOND", ",", "MVT", "::", "Other", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "BR_JT", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "BRIND", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ConstantFP", ",", "MVT", "::", "f32", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "Constant", ",", "MVT", "::", "i32", ",", "Legal", ")", ";", "setSchedulingPreference", "(", "Sched", "::", "RegPressure", ")", ";", "setPow2DivIsCheap", "(", "false", ")", ";", "setSelectIsExpensive", "(" ]

[ "bool", "TVMPrepareForLiveIntervals", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "{", "dbgs", "(", ")", "<<", "<STR_LIT>", "********** Prepare For LiveIntervals **********\\n", "<STR_LIT>", "<<", "<STR_LIT>", "********** Function: ", "<STR_LIT>", "<<", "MF", ".", "getName", "(", ")", "<<", "'", "\\n", "'", ";", "}", ")", ";", "bool", "Changed", "=", "false", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "MachineBasicBlock", "&", "Entry", "=", "*", "MF", ".", "begin", "(", ")", ";", "assert", "(", "!", "mustPreserveAnalysisID", "(", "LiveIntervalsID", ")", "&&", "<STR_LIT>", "LiveIntervals shouldn't be active yet!", "<STR_LIT>", ")", ";", "MRI", ".", "leaveSSA", "(", ")", ";", "for", "(", "auto", "MII", "=", "Entry", ".", "begin", "(", ")", ",", "MIE", "=", "Entry", ".", "end", "(", ")", ";", "MII", "!=", "MIE", ";", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MII", "++", ";", "if", "(", "TVM", "::", "isArgument", "(", "MI", ")", ")", "{", "MI", ".", "removeFromParent", "(", ")", ";", "Entry", ".", "insert", "(", "Entry", ".", "begin", "(", ")", ",", "&", "MI", ")", ";", "}", "}", "MF", ".", "getProperties", "(", ")", ".", "set", "(", "MachineFunctionProperties", "::", "Property", "::", "TracksLiveness", ")", ";", "return", "Changed", ";", "}" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "AU", ")", ";" ]

[ "AU", ".", "setPreservesCFG", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "s1", ";" ]

[ "class", "RR2", "<", "bits", "<", "<NUM_LIT>", ">", "op1", ",", "bits", "<", "<NUM_LIT>", ">", "op2", ",", "dag", "outs", ",", "dag", "ins", ",", "string", "asmstr", ",", "list", "<", "dag", ">", "pattern", ">", ":", "T32", "<", "outs", ",", "ins", ",", "asmstr", ",", "pattern", ">", "{", "bits", "<", "<NUM_LIT>", ">", "d", ";", "bits", "<", "<NUM_LIT>", ">", "s2", ";", "bits", "<", "<NUM_LIT>", ">", "s1", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "d", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "s2", ";" ]

[ "false", ";" ]

[ "auto", "IsAllOpsVirtualReg", "=", "[", "]", "(", "const", "MachineInstr", "&", "Instr", ")", "{", "for", "(", "const", "auto", "&", "MO", ":", "Instr", ".", "explicit_operands", "(", ")", ")", "if", "(", "!", "(", "MO", ".", "isReg", "(", ")", "&&", "Register", "::", "isVirtualRegister", "(", "MO", ".", "getReg", "(", ")", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", ";", "auto", "IsReassociableAdd", "=", "[", "&", "]", "(", "const", "MachineInstr", "&", "Instr", ")", "{", "if", "(", "Instr", ".", "getOpcode", "(", ")", "!=", "FMAOpIdxInfo", "[", "getFMAOpIdxInfo", "(", "Root", ".", "getOpcode", "(", ")", ")", "]", "[", "InfoArrayIdxFAddInst", "]", ")", "return", "false", ";", "if", "(", "!", "(", "Instr", ".", "getFlag", "(", "MachineInstr", "::", "MIFlag", "::", "FmReassoc", ")", "&&", "Instr", ".", "getFlag", "(", "MachineInstr", "::", "MIFlag", "::", "FmNsz", ")", ")", ")", "return", "false", ";", "if", "(", "!", "IsAllOpsVirtualReg", "(", "Instr", ")", ")", "return", "false", ";", "return", "true", ";", "}", ";", "auto", "IsReassociableFMA", "=", "[", "&", "]", "(", "const", "MachineInstr", "&", "Instr", ",", "int16_t", "&", "AddOpIdx", ",", "bool", "IsLeaf", ")", "{", "int16_t", "Idx", "=", "getFMAOpIdxInfo", "(", "Instr", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "Idx", "<", "<NUM_LIT>", ")", "return", "false", ";", "if", "(", "!", "(", "Instr", ".", "getFlag", "(", "MachineInstr", "::", "MIFlag", "::", "FmReassoc", ")", "&&", "Instr", ".", "getFlag", "(", "MachineInstr", "::", "MIFlag", "::", "FmNsz", ")", ")", ")", "return", "false", ";", "if", "(", "!", "IsAllOpsVirtualReg", "(", "Instr", ")", ")", "return", "false", ";", "if", "(", "IsLeaf", ")", "return", "true", ";", "AddOpIdx", "=", "FMAOpIdxInfo", "[", "Idx", "]", "[", "InfoArrayIdxAddOpIdx", "]", ";", "const", "MachineOperand", "&", "OpAdd", "=", "Instr", ".", "getOperand", "(", "AddOpIdx", ")", ";", "MachineInstr", "*", "MIAdd", "=", "MRI", ".", "getUniqueVRegDef", "(", "OpAdd", ".", "getReg", "(", ")", ")", ";", "if", "(", "!", "MIAdd", "||", "MIAdd", "->", "getParent", "(", ")", "!=", "MBB", ")", "return", "false", ";", "return", "IsLeaf", "?", "true", ":", "MRI", ".", "hasOneNonDBGUse", "(", "OpAdd", ".", "getReg", "(", ")", ")", ";", "}", ";", "int16_t", "AddOpIdx", "=", "-", "<NUM_LIT>", ";", "if", "(", "!", "IsReassociableFMA", "(", "Root", ",", "AddOpIdx", ",", "false", ")", ")", "return", "false", ";", "assert", "(", "(", "AddOpIdx", ">=", "<NUM_LIT>", ")", "&&", "<STR_LIT>", "add operand index not right!", "<STR_LIT>", ")", ";", "Register", "RegB", "=", "Root", ".", "getOperand", "(", "AddOpIdx", ")", ".", "getReg", "(", ")", ";", "MachineInstr", "*", "Prev", "=", "MRI", ".", "getUniqueVRegDef", "(", "RegB", ")", ";", "AddOpIdx", "=", "-", "<NUM_LIT>", ";", "if", "(", "!", "IsReassociableFMA", "(", "*", "Prev", ",", "AddOpIdx", ",", "false", ")", ")", "return", "false", ";", "assert", "(", "(", "AddOpIdx", ">=", "<NUM_LIT>", ")", "&&", "<STR_LIT>", "add operand index not right!", "<STR_LIT>", ")", ";", "Register", "RegA", "=", "Prev", "->", "getOperand", "(", "AddOpIdx", ")", ".", "getReg", "(", ")", ";", "MachineInstr", "*", "Leaf", "=", "MRI", ".", "getUniqueVRegDef", "(", "RegA", ")", ";", "AddOpIdx", "=", "-", "<NUM_LIT>", ";", "if", "(", "IsReassociableFMA", "(", "*", "Leaf", ",", "AddOpIdx", ",", "true", ")", ")", "{", "Patterns", ".", "push_back", "(", "MachineCombinerPattern", "::", "REASSOC_XMM_AMM_BMM", ")", ";", "return", "true", ";", "}", "if", "(", "IsReassociableAdd", "(", "*", "Leaf", ")", ")", "{", "Patterns", ".", "push_back", "(", "MachineCombinerPattern", "::", "REASSOC_XY_AMM_BMM", ")", ";", "return", "true", ";", "}", "return" ]