Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "if", "(", "real_equal", "(", "r", ",", "&", "value_fp0", ")", ")", "return", "<NUM_LIT>", ";" ]

[ "const", "REAL_VALUE_TYPE", "*", "r", ";", "if", "(", "!", "fp_consts_inited", ")", "init_fp_table", "(", ")", ";", "r", "=", "CONST_DOUBLE_REAL_VALUE", "(", "x", ")", ";", "if", "(", "REAL_VALUE_MINUS_ZERO", "(", "*", "r", ")", ")", "return", "<NUM_LIT>", ";" ]

[ "<FIXS>", "case", "Hexagon", "::", "SL1_loadrub_io", ":", "<FIXE>" ]

[ "operand", "=", "(", "inst", "&", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "HexagonMCInstrInfo", "::", "addConstant", "(", "*", "MI", ",", "operand", ",", "getContext", "(", ")", ")", ";", "break", ";", "<BUGS>", "case", "Hexagon", "::", "V4_SL1_loadrub_io", ":", "<BUGE>", "operand", "=", "getRegFromSubinstEncoding", "(", "inst", "&", "<NUM_LIT>", ")", ";", "Op", "=", "MCOperand", "::", "createReg", "(", "operand", ")", ";" ]

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

[ "INVALID_REGNUM", ",", "NULL_RTX", ",", "s390_indirect_branch_type_jump", ")", "return", "<STR_LIT>", "}", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "dest", "=", "gen_reg_rtx", "(", "Pmode", ")", ";" ]

[ "m68k_libcall_value_in_a0_p", "=", "true", ";", "a0", "=", "emit_library_call_value", "(", "m68k_get_m68k_read_tp", "(", ")", ",", "NULL_RTX", ",", "LCT_PURE", ",", "Pmode", ",", "<NUM_LIT>", ")", ";", "m68k_libcall_value_in_a0_p", "=", "false", ";", "insns", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "eqv", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "const1_rtx", ")", ",", "UNSPEC_RELOC32", ")", ";", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";" ]

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

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

[ "<FIXS>", "#", "include", "<STR_LIT>", "llvm/Support/Debug.h", "<STR_LIT>", "<FIXE>" ]

[ "#", "include", "<STR_LIT>", "llvm/CodeGen/MachineCodeEmitter.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/CodeGen/MachineFunctionPass.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/CodeGen/Passes.h", "<STR_LIT>", "<BUGS>", "#", "include", "<STR_LIT>", "Support/Debug.h", "<STR_LIT>", "<BUGE>", "namespace", "llvm", "{" ]

[ "void", "AArch64PassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableAtomicTidy", ")", "addPass", "(", "createCFGSimplificationPass", "(", "<NUM_LIT>", ",", "true", ",", "true", ",", "false", ",", "true", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "EnableLoopDataPrefetch", ")", "addPass", "(", "createLoopDataPrefetchPass", "(", ")", ")", ";", "if", "(", "EnableFalkorHWPFFix", ")", "addPass", "(", "createFalkorMarkStridedAccessesPass", "(", ")", ")", ";", "}", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createInterleavedLoadCombinePass", "(", ")", ")", ";", "addPass", "(", "createInterleavedAccessPass", "(", ")", ")", ";", "}", "if", "(", "TM", "->", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "Aggressive", "&&", "EnableGEPOpt", ")", "{", "addPass", "(", "createSeparateConstOffsetFromGEPPass", "(", "true", ")", ")", ";", "addPass", "(", "createEarlyCSEPass", "(", ")", ")", ";", "addPass", "(", "createLICMPass", "(", ")", ")", ";", "}", "addPass", "(", "createAArch64StackTaggingPass", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", ")", ";", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSWindows", "(", ")", ")", "addPass", "(", "createCFGuardCheckPass", "(", ")", ")", ";", "}" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

[ "opc", ",", "asm", ",", "ZPR32", ">", ";" ]

[ "def", "_S", ":", "sve_int_count_v", "<", "<NUM_LIT>", "," ]

[ "else", "return", "(", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "MSP430_INTR", "?", "CalleeSavedRegsIntr", ":", "CalleeSavedRegs", ")", ";" ]

[ "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", "}", ";", "static", "const", "MCPhysReg", "CalleeSavedRegsIntrFP", "[", "]", "=", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", "}", ";", "if", "(", "TFI", "->", "hasFP", "(", "*", "MF", ")", ")", "return", "(", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "MSP430_INTR", "?", "CalleeSavedRegsIntrFP", ":", "CalleeSavedRegsFP", ")", ";" ]

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

[ ":", "N3V", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "op21_20", ",", "op11_8", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "QPR", ":", "$", "dst", ")", ",", "(", "ins", "QPR", ":", "$", "src1", ",", "QPR", ":", "$", "src2", ",", "DPR_VFP2", ":", "$", "src3", ",", "nohash_imm", ":", "$", "lane", ")", ",", "itin", ",", "<BUGS>", "!", "strconcat", "(", "OpcodeStr", ",", "<STR_LIT>", ")", ",", "<STR_LIT>", ",", "<BUGE>", "[", "(", "set", "(", "ResTy", "QPR", ":", "$", "dst", ")", ",", "(", "ResTy", "(", "ShOp", "(", "ResTy", "QPR", ":", "$", "src1", ")", ",", "(", "ResTy", "(", "MulOp", "QPR", ":", "$", "src2", "," ]

[ "<FIXS>", "fractional_cost", "sve_nonpred_issue_cycles_per_iter", "<FIXE>" ]

[ "{", "<BUGS>", "fractional_cost", "sve_nonpred_cycles_per_iter", "<BUGE>", "aarch64_estimate_min_cycles_per_iter", "(", "&", "costs", "->", "sve_ops", ",", "issue_info", "->", "sve", ")", ";", "fractional_cost", "sve_pred_issue_cycles_per_iter" ]

[ ")" ]

[ "(", "float_extend", ":", "VCVTF", "(", "vec_select", ":", "<", "VFMLSEL", ">", "(", "match_operand", ":", "<", "VFML", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "<", "VFML", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "match_operand", ":", "VCVTF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]" ]

[ "void", "SystemZELFFrameLowering", "::", "inlineStackProbe", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "PrologMBB", ")", "const", "{", "auto", "*", "ZII", "=", "static_cast", "<", "const", "SystemZInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "const", "SystemZSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "SystemZSubtarget", ">", "(", ")", ";", "const", "SystemZTargetLowering", "&", "TLI", "=", "*", "STI", ".", "getTargetLowering", "(", ")", ";", "MachineInstr", "*", "StackAllocMI", "=", "nullptr", ";", "for", "(", "MachineInstr", "&", "MI", ":", "PrologMBB", ")", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "StackAllocMI", "=", "&", "MI", ";", "break", ";", "}", "if", "(", "StackAllocMI", "==", "nullptr", ")", "return", ";", "uint64_t", "StackSize", "=", "StackAllocMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "const", "unsigned", "ProbeSize", "=", "TLI", ".", "getStackProbeSize", "(", "MF", ")", ";", "uint64_t", "NumFullBlocks", "=", "StackSize", "/", "ProbeSize", ";", "uint64_t", "Residual", "=", "StackSize", "%", "ProbeSize", ";", "int64_t", "SPOffsetFromCFA", "=", "-", "<STR_LIT>", "::", "<STR_LIT>", ";", "MachineBasicBlock", "*", "MBB", "=", "&", "PrologMBB", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "StackAllocMI", ";", "const", "DebugLoc", "DL", "=", "StackAllocMI", "->", "getDebugLoc", "(", ")", ";", "auto", "allocateAndProbe", "=", "[", "&", "]", "(", "MachineBasicBlock", "&", "InsMBB", ",", "MachineBasicBlock", "::", "iterator", "InsPt", ",", "unsigned", "Size", ",", "bool", "EmitCFI", ")", "->", "void", "{", "emitIncrement", "(", "InsMBB", ",", "InsPt", ",", "DL", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "-", "int64_t", "(", "Size", ")", ",", "ZII", ")", ";", "if", "(", "EmitCFI", ")", "{", "SPOffsetFromCFA", "-=", "Size", ";", "buildCFAOffs", "(", "InsMBB", ",", "InsPt", ",", "DL", ",", "SPOffsetFromCFA", ",", "ZII", ")", ";", "}", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "(", ")", ",", "MachineMemOperand", "::", "MOVolatile", "|", "MachineMemOperand", "::", "MOLoad", ",", "<NUM_LIT>", ",", "Align", "(", "<NUM_LIT>", ")", ")", ";", "BuildMI", "(", "InsMBB", ",", "InsPt", ",", "DL", ",", "ZII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "RegState", "::", "Undef", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "Size", "-", "<NUM_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", ";", "bool", "StoreBackchain", "=", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "<STR_LIT>", "backchain", "<STR_LIT>", ")", ";", "if", "(", "StoreBackchain", ")", "BuildMI", "(", "*", "MBB", ",", "MBBI", ",", "DL", ",", "ZII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "MachineBasicBlock", "*", "DoneMBB", "=", "nullptr", ";", "MachineBasicBlock", "*", "LoopMBB", "=", "nullptr", ";", "if", "(", "NumFullBlocks", "<", "<NUM_LIT>", ")", "{", "for", "(", "unsigned", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "NumFullBlocks", ";", "i", "++", ")", "allocateAndProbe", "(", "*", "MBB", ",", "MBBI", ",", "ProbeSize", ",", "true", ")", ";", "}", "else", "{", "uint64_t", "LoopAlloc", "=", "ProbeSize", "*", "NumFullBlocks", ";", "SPOffsetFromCFA", "-=", "LoopAlloc", ";", "BuildMI", "(", "*", "MBB", ",", "MBBI", ",", "DL", ",", "ZII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "buildDefCFAReg", "(", "*", "MBB", ",", "MBBI", ",", "DL", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "ZII", ")", ";", "emitIncrement", "(", "*", "MBB", ",", "MBBI", ",", "DL", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "-", "int64_t", "(", "LoopAlloc", ")", ",", "ZII", ")", ";", "buildCFAOffs", "(", "*", "MBB", ",", "MBBI", ",", "DL", ",", "-", "int64_t", "(", "<STR_LIT>", "::", "<STR_LIT>", "+", "LoopAlloc", ")", ",", "ZII", ")", ";", "DoneMBB", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", "MBBI", ",", "MBB", ")", ";", "LoopMBB", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", "MBB", ")", ";", "MBB", "->", "addSuccessor", "(", "LoopMBB", ")", ";", "LoopMBB", "->", "addSuccessor", "(", "LoopMBB", ")", ";", "LoopMBB", "->", "addSuccessor", "(", "DoneMBB", ")", ";", "MBB", "=", "LoopMBB", ";", "allocateAndProbe", "(", "*", "MBB", ",", "MBB", "->", "end", "(", ")", ",", "ProbeSize", ",", "false", ")", ";", "BuildMI", "(", "*", "MBB", ",", "MBB", "->", "end", "(", ")", ",", "DL", ",", "ZII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "BuildMI", "(", "*", "MBB", ",", "MBB", "->", "end", "(", ")", ",", "DL", ",", "ZII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addMBB", "(", "MBB", ")", ";", "MBB", "=", "DoneMBB", ";", "MBBI", "=", "DoneMBB", "->", "begin", "(", ")", ";", "buildDefCFAReg", "(", "*", "MBB", ",", "MBBI", ",", "DL", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "ZII", ")", ";", "}", "if", "(", "Residual", ")", "allocateAndProbe", "(", "*", "MBB", ",", "MBBI", ",", "Residual", ",", "true", ")", ";", "if", "(", "StoreBackchain", ")", "BuildMI", "(", "*", "MBB", ",", "MBBI", ",", "DL", ",", "ZII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "getBackchainOffset", "(", "MF", ")", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ";", "StackAllocMI", "->", "eraseFromParent", "(", ")", ";", "if", "(", "DoneMBB", "!=", "nullptr", ")", "{", "recomputeLiveIns", "(", "*", "DoneMBB", ")", ";", "recomputeLiveIns", "(", "*", "LoopMBB", ")", ";", "}", "}" ]

[ "Replace", "a", "StackProbe", "inline-stub", "with", "the", "actual", "probe", "code", "inline", "." ]

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

[ "rtx_insn", "*", "insn", ";", "rtx", "pat", ",", "target", ";", "rtx", "*", "label", ";", "shorten_branches", "(", "get_insns", "(", ")", ")", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "!", "JUMP_P", "(", "insn", ")", "||", "tablejump_p", "(", "insn", ",", "NULL", ",", "NULL", ")", ")", "continue", ";", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "pat", "=", "XVECEXP", "(", "pat", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "!=", "SET", "||", "SET_DEST", "(", "pat", ")", "!=", "pc_rtx", ")", "continue", ";", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "pat", ")", ")", "==", "LABEL_REF", ")", "{", "label", "=", "&", "SET_SRC", "(", "pat", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "pat", ")", ")", "==", "IF_THEN_ELSE", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "pat", ")", ",", "<NUM_LIT>", ")", ")", "==", "LABEL_REF", ")", "label", "=", "&", "XEXP", "(", "SET_SRC", "(", "pat", ")", ",", "<NUM_LIT>", ")", ";", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "pat", ")", ",", "<NUM_LIT>", ")", ")", "==", "LABEL_REF", ")", "label", "=", "&", "XEXP", "(", "SET_SRC", "(", "pat", ")", ",", "<NUM_LIT>", ")", ";", "else", "continue", ";", "}", "else", "continue", ";", "if", "(", "get_attr_length", "(", "insn", ")", "<=", "<NUM_LIT>", ")", "continue", ";", "cfun_frame_layout", ".", "save_return_addr_p", "=", "<NUM_LIT>", ";", "if", "(", "!", "flag_pic", ")", "{", "new", "_", "literal", "=", "<NUM_LIT>", ";", "rtx", "mem", "=", "force_const_mem", "(", "Pmode", ",", "*", "label", ")", ";", "rtx_insn", "*", "set_insn", "=", "emit_insn_before", "(", "gen_rtx_SET", "(", "Pmode", ",", "temp_reg", ",", "mem" ]

[ "}" ]

[ "ResourceBase", "::", "ResourceBase", "(", "uint32_t", "I", ",", "hlsl", "::", "FrontendResource", "R", ")", ":", "ID", "(", "I", ")", ",", "GV", "(", "R", ".", "getGlobalVariable", "(", ")", ")", ",", "Name", "(", "<STR_LIT>", "<STR_LIT>", ")", ",", "Space", "(", "R", ".", "getSpace", "(", ")", ")", ",", "LowerBound", "(", "R", ".", "getResourceIndex", "(", ")", ")", ",", "RangeSize", "(", "<NUM_LIT>", ")", "{", "if", "(", "auto", "*", "ArrTy", "=", "dyn_cast", "<", "ArrayType", ">", "(", "GV", "->", "getValueType", "(", ")", ")", ")", "RangeSize", "=", "ArrTy", "->", "getNumElements", "(", ")", ";" ]

[ "F", ",", "const", "TargetSubtargetInfo", "*", "STI", ")", "const", "{" ]

[ "MachineFunctionInfo", "*", "SystemZTargetMachine", "::", "createMachineFunctionInfo", "(", "BumpPtrAllocator", "&", "Allocator", ",", "const", "Function", "&" ]

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

[ "let", "SrcA", "=", "addr", ";", "let", "SrcB", "=", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "SrcExtra", "=", "value", ";", "let", "Switches", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "VectorPred", "=", "<NUM_LIT>", ";", "let", "PredPolarity", "=", "pred" ]

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

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

[ "::", "YMM8", "&&", "SrcReg", "<=", "X86", "::", "YMM15", ")", ")", "SrcRegNum", "+=", "<NUM_LIT>", ";" ]

[ "unsigned", "SrcReg", "=", "MI", ".", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", ";", "unsigned", "SrcRegNum", "=", "GetX86RegNum", "(", "MI", ".", "getOperand", "(", "OpNum", ")", ")", ";", "if", "(", "(", "SrcReg", ">=", "X86", "::", "XMM8", "&&", "SrcReg", "<=", "X86", "::", "XMM15", ")", "||", "(", "SrcReg", ">=", "X86" ]

[ ">", "RM", ")", "{" ]

[ "static", "Reloc", "::", "Model", "getEffectiveRelocModel", "(", "std", "::", "optional", "<", "Reloc", "::", "Model" ]

[ "return", "vbsl_p8", "(", "_", "_", "mask", ",", "_", "_", "tbl", ",", "_", "_", "r", ")", ";" ]

[ "vtbx3_p8", "(", "poly8x8_t", "_", "_", "r", ",", "poly8x8x3_t", "_", "_", "tab", ",", "uint8x8_t", "_", "_", "idx", ")", "{", "uint8x8_t", "_", "_", "mask", "=", "vclt_u8", "(", "_", "_", "idx", ",", "vmov_n_u8", "(", "<NUM_LIT>", ")", ")", ";", "poly8x8_t", "_", "_", "tbl", "=", "vtbl3_p8", "(", "_", "_", "tab", ",", "_", "_", "idx", ")", ";" ]

[ ")", "const", "{" ]

[ "void", "addSPRRegListOperands", "(", "MCInst", "&", "Inst", ",", "unsigned", "N" ]

[ "<NUM_LIT>", ";" ]

[ "def", "_4H", ":", "N2VShiftAdd", "<", "<NUM_LIT>", ",", "u", ",", "opcode", ",", "asmop", ",", "<STR_LIT>", ",", "VPR64", ",", "v4i16", ",", "shr_imm16", ",", "OpNode", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "I2", ";", "bits", "<", "<NUM_LIT>", ">", "M3", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "V1", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "I2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "M3", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "V1", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "iop", ";" ]

[ "def", "_D", ":", "sve_fp_fma_by_indexed_elem", "<", "<NUM_LIT>", ",", "opc", ",", "asm", ",", "ZPR64", ",", "ZPR4b64", ",", "VectorIndexD", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Zm", ";", "bit" ]

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

[ "(", "define_automaton", "<STR_LIT>", ")", "(", "define_cpu_unit", "<STR_LIT>", "<STR_LIT>", ")" ]

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

[ "class", "sve_int_sel_vvv", "<", "bits", "<", "<NUM_LIT>", ">", "sz8_64", ",", "string", "asm", ",", "ZPRRegOp", "zprty", ">", ":", "I", "<", "(", "outs", "zprty", ":", "$", "Zd", ")", ",", "(", "ins", "PPRAny", ":", "$", "Pg", ",", "zprty", ":", "$", "Zn", ",", "zprty", ":", "$", "Zm", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Sched", "<", "[", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Pg", ";", "bits", "<", "<NUM_LIT>", ">", "Zd", ";", "bits", "<", "<NUM_LIT>", ">", "Zm", ";", "bits", "<", "<NUM_LIT>", ">", "Zn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sz8_64", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zm", ";" ]

[ "const", "{" ]

[ "bool", "callsEhReturn", "(", ")" ]

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

[ "def", "A2_notp", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss32", ")", ",", "<STR_LIT>", ",", "tc_0ae0825c", ",", "TypeS_2op", ">", ",", "Enc_b9c5fb", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "return", ";" ]

[ "str", "=", "(", "char", "*", ")", "alloca", "(", "i", "+", "<NUM_LIT>", ")", ";", "memcpy", "(", "str", ",", "const_str", ",", "i", "+", "<NUM_LIT>", ")", ";", "while", "(", "<NUM_LIT>", ")", "{", "dash", "=", "strchr", "(", "str", ",", "'", "-", "'", ")", ";", "if", "(", "!", "dash", ")", "{", "warning", "(", "<NUM_LIT>", ",", "<STR_LIT>", "value of %<-mfixed-range%> must have form REG1-REG2", "<STR_LIT>", ")", ";", "return", ";", "}", "*", "dash", "=", "'", "\\0", "'", ";", "comma", "=", "strchr", "(", "dash", "+", "<NUM_LIT>", ",", "'", ",", "'", ")", ";", "if", "(", "comma", ")", "*", "comma", "=", "'", "\\0", "'", ";", "first", "=", "decode_reg_name", "(", "str", ")", ";", "if", "(", "first", "<", "<NUM_LIT>", ")", "{", "warning", "(", "<NUM_LIT>", ",", "<STR_LIT>", "unknown register name: %s", "<STR_LIT>", ",", "str", ")", ";", "return", ";", "}", "last", "=", "decode_reg_name", "(", "dash", "+", "<NUM_LIT>", ")", ";", "if", "(", "last", "<", "<NUM_LIT>", ")", "{", "warning", "(", "<NUM_LIT>", ",", "<STR_LIT>", "unknown register name: %s", "<STR_LIT>", ",", "dash", "+", "<NUM_LIT>", ")", ";" ]

[ "(", "UseMI", "->", "getOperand", "(", "i", ")", ")", ";" ]

[ "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "[MI <BB#", "<STR_LIT>", "<<", "UseMI", "->", "getParent", "(", ")", "->", "getNumber", "(", ")", "<<", "<STR_LIT>", ">]: ", "<STR_LIT>", "<<", "*", "UseMI", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "const", "MCInstrDesc", "&", "UseMID", "=", "UseMI", "->", "getDesc", "(", ")", ";", "assert", "(", "HII", "->", "getAddrMode", "(", "UseMI", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "auto", "UsePos", "=", "MachineBasicBlock", "::", "iterator", "(", "UseMI", ")", ";", "MachineBasicBlock", "::", "instr_iterator", "InsertPt", "=", "UsePos", ".", "getInstrIterator", "(", ")", ";", "short", "NewOpCode", "=", "getBaseWithLongOffset", "(", "UseMI", ")", ";", "assert", "(", "NewOpCode", ">=", "<NUM_LIT>", "&&", "<STR_LIT>", "Invalid New opcode\\n", "<STR_LIT>", ")", ";", "unsigned", "OpStart", ";", "unsigned", "OpEnd", "=", "UseMI", "->", "getNumOperands", "(", ")", ";", "MachineBasicBlock", "*", "BB", "=", "UseMI", "->", "getParent", "(", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "BB", ",", "InsertPt", ",", "UseMI", "->", "getDebugLoc", "(", ")", ",", "HII", "->", "get", "(", "NewOpCode", ")", ")", ";", "if", "(", "UseMID", ".", "mayLoad", "(", ")", ")", "{", "MIB", ".", "addOperand", "(", "UseMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "MIB", ".", "addOperand", "(", "AddAslMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "MIB", ".", "addOperand", "(", "AddAslMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "const", "GlobalValue", "*", "GV", "=", "ImmOp", ".", "getGlobal", "(", ")", ";", "MIB", ".", "addGlobalAddress", "(", "GV", ",", "UseMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ",", "ImmOp", ".", "getTargetFlags", "(", ")", ")", ";", "OpStart", "=", "<NUM_LIT>", ";", "}", "else", "if", "(", "UseMID", ".", "mayStore", "(", ")", ")", "{", "MIB", ".", "addOperand", "(", "AddAslMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "MIB", ".", "addOperand", "(", "AddAslMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "const", "GlobalValue", "*", "GV", "=", "ImmOp", ".", "getGlobal", "(", ")", ";", "MIB", ".", "addGlobalAddress", "(", "GV", ",", "UseMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ",", "ImmOp", ".", "getTargetFlags", "(", ")", ")", ";", "MIB", ".", "addOperand", "(", "UseMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "OpStart", "=", "<NUM_LIT>", ";", "}", "else", "llvm_unreachable", "(", "<STR_LIT>", "Unhandled instruction", "<STR_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "OpStart", ";", "i", "<", "OpEnd", ";", "++", "i", ")", "MIB", ".", "addOperand" ]

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

[ "IntegerType", "*", "Ty", "=", "dyn_cast", "<", "IntegerType", ">", "(", "CI", "->", "getType", "(", ")", ")", ";", "if", "(", "!", "Ty", "||", "Ty", "->", "getBitWidth", "(", ")", "%", "<NUM_LIT>", "!=", "<NUM_LIT>", ")", "return", "false", ";", "SmallVector", "<", "StringRef", ",", "<NUM_LIT>", ">", "AsmPieces", ";", "SplitString", "(", "AsmStr", ",", "AsmPieces", ",", "<STR_LIT>", ";\\n", "<STR_LIT>", ")", ";", "switch", "(", "AsmPieces", ".", "size", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "<NUM_LIT>", ":", "if", "(", "matchAsm", "(", "AsmPieces", "[", "<NUM_LIT>", "]", ",", "{", "<STR_LIT>", "bswap", "<STR_LIT>", ",", "<STR_LIT>", "$0", "<STR_LIT>", "}", ")", "||", "matchAsm", "(", "AsmPieces", "[", "<NUM_LIT>", "]", ",", "{", "<STR_LIT>", "bswapl", "<STR_LIT>", ",", "<STR_LIT>", "$0", "<STR_LIT>", "}", ")", "||", "matchAsm", "(", "AsmPieces", "[", "<NUM_LIT>", "]", ",", "{", "<STR_LIT>", "bswapq", "<STR_LIT>", ",", "<STR_LIT>", "$0", "<STR_LIT>", "}", ")", "||", "matchAsm", "(", "AsmPieces", "[", "<NUM_LIT>", "]", ",", "{", "<STR_LIT>", "bswap", "<STR_LIT>", ",", "<STR_LIT>", "${0:q}", "<STR_LIT>", "}", ")", "||", "matchAsm", "(", "AsmPieces", "[", "<NUM_LIT>", "]", ",", "{", "<STR_LIT>", "bswapl", "<STR_LIT>", ",", "<STR_LIT>", "${0:q}", "<STR_LIT>", "}", ")", "||", "matchAsm", "(", "AsmPieces", "[", "<NUM_LIT>", "]", ",", "{", "<STR_LIT>", "bswapq", "<STR_LIT>", ",", "<STR_LIT>", "${0:q}", "<STR_LIT>", "}", ")", ")", "{", "return", "IntrinsicLowering", "::", "LowerToByteSwap", "(", "CI", ")", ";", "}", "if", "(", "CI", "->", "getType", "(", ")", "->", "isIntegerTy", "(", "<NUM_LIT>", ")", "&&", "IA", "->", "getConstraintString", "(", ")", ".", "compare", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<STR_LIT>", "=r,0,", "<STR_LIT>", ")", "==", "<NUM_LIT>", "&&", "(", "matchAsm", "(", "AsmPieces", "[", "<NUM_LIT>", "]", ",", "{", "<STR_LIT>", "rorw", "<STR_LIT>", ",", "<STR_LIT>", "$$8,", "<STR_LIT>", ",", "<STR_LIT>", "${0:w}", "<STR_LIT>", "}", ")", "||", "matchAsm", "(", "AsmPieces", "[", "<NUM_LIT>", "]", ",", "{", "<STR_LIT>", "rolw", "<STR_LIT>", ",", "<STR_LIT>", "$$8,", "<STR_LIT>", ",", "<STR_LIT>", "${0:w}", "<STR_LIT>", "}", ")", ")", ")", "{", "AsmPieces", ".", "clear", "(", ")", ";", "StringRef", "ConstraintsStr", "=", "IA", "->", "getConstraintString", "(", ")", ";", "SplitString", "(", "StringRef", "(", "ConstraintsStr", ")", ".", "substr", "(", "<NUM_LIT>", ")", ",", "AsmPieces", ",", "<STR_LIT>", ",", "<STR_LIT>", ")", ";", "array_pod_sort", "(", "AsmPieces", ".", "begin", "(", ")", ",", "AsmPieces", ".", "end", "(", ")", ")", ";", "if", "(", "clobbersFlagRegisters", "(", "AsmPieces", ")", ")", "return", "IntrinsicLowering", "::", "LowerToByteSwap" ]

[ "_", "B", ")", ";" ]

[ "static", "_", "_", "inline", "_", "_", "m64", "_", "mm_macz_pi16", "(", "_", "_", "m64", "_", "_", "A", ",", "_", "_", "m64", "_", "_", "B", ")", "{", "return", "_", "_", "builtin_arm_wmacsz", "(", "(", "_", "_", "v4hi", ")", "_", "_", "A", ",", "(", "_", "_", "v4hi", ")", "_" ]

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

[ "<STR_LIT>", "(", "and", "(", "match_code", "<STR_LIT>", ")", "(", "match_test", "<STR_LIT>" ]

[ "bool", "ARMAsmPrinter", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCOperand", "&", "MCOp", ")", "{", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "unknown operand type", "<STR_LIT>", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "if", "(", "MO", ".", "isImplicit", "(", ")", ")", "return", "false", ";", "assert", "(", "!", "MO", ".", "getSubReg", "(", ")", "&&", "<STR_LIT>", "Subregs should be eliminated!", "<STR_LIT>", ")", ";", "MCOp", "=", "MCOperand", "::", "createReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "createImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "MCSymbolRefExpr", "::", "create", "(", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "OutContext", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "GetARMGVSymbol", "(", "MO", ".", "getGlobal", "(", ")", ",", "MO", ".", "getTargetFlags", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "GetJTISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "if", "(", "Subtarget", "->", "genExecuteOnly", "(", ")", ")", "llvm_unreachable", "(", "<STR_LIT>", "execute-only should not generate constant pools", "<STR_LIT>", ")", ";", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "GetCPISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "MCOp", "=", "GetSymbolRef", "(", "MO", ",", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_FPImmediate", ":", "{", "APFloat", "Val", "=", "MO", ".", "getFPImm", "(", ")", "->", "getValueAPF", "(", ")", ";", "bool", "ignored", ";", "Val", ".", "convert", "(", "APFloat", "::", "IEEEdouble", "(", ")", ",", "APFloat", "::", "rmTowardZero", ",", "&", "ignored", ")", ";", "MCOp", "=", "MCOperand", "::", "createDFPImm", "(", "bit_cast", "<", "uint64_t", ">", "(", "Val", ".", "convertToDouble", "(", ")", ")", ")", ";", "break", ";", "}", "case", "MachineOperand", "::", "MO_RegisterMask", ":", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "Wrapper", "for", "MCInstLowering.lowerOperand", "(", ")", "for", "the", "tblgen'erated", "pseudo", "lowering", "." ]

[ "=", "isSigned", ";" ]

[ "class", "BaseDiv", "<", "bit", "isSigned", ",", "RegisterClass", "regtype", ",", "string", "asm", ",", "SDPatternOperator", "OpNode", ">", ":", "BaseTwoOperand", "<", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "?", "}", ",", "regtype", ",", "asm", ",", "OpNode", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}" ]

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

[ "def", "SWHri", ":", "BaseIntegerToFP", "<", "isUnsigned", ",", "GPR32", ",", "FPR16", ",", "fixedpoint_f16_i32", ",", "asm", ",", "[", "(", "set", "(", "f16", "FPR16", ":", "$", "Rd", ")", ",", "(", "fdiv", "(", "node", "GPR32", ":", "$", "Rn", ")", ",", "fixedpoint_f16_i32", ":", "$", "scale", ")", ")", "]", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "O", ")", "{" ]

[ "void", "AArch64InstPrinter", "::", "printImmHex", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNo", "," ]

[ "<FIXS>", "a29k_set_memflags_1", "(", "insn", ",", "in_struct_p", ",", "scalar_p", ",", "volatile_p", ",", "unchanging_p", ")", ";", "<FIXE>" ]

[ "||", "(", "!", "in_struct_p", "&&", "!", "volatile_p", "&&", "!", "unchanging_p", ")", ")", "return", ";", "<BUGS>", "a29k_set_memflags_1", "(", "insn", ",", "in_struct_p", ",", "volatile_p", ",", "unchanging_p", ")", ";", "<BUGE>", "}" ]

[ "void", "mt_split_words", "(", "enum", "machine_mode", "nmode", ",", "enum", "machine_mode", "omode", ",", "rtx", "*", "operands", ")", "{", "rtx", "dl", ",", "dh", ";", "rtx", "sl", ",", "sh", ";", "int", "move_high_first", "=", "<NUM_LIT>", ";", "switch", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "{", "case", "SUBREG", ":", "case", "REG", ":", "if", "(", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "REG", "||", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "SUBREG", ")", "&&", "true_regnum", "(", "operands", "[", "<NUM_LIT>", "]", ")", "<=", "true_regnum", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "move_high_first", "=", "<NUM_LIT>", ";", "if", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "SUBREG", ")", "{", "dl", "=", "gen_rtx_SUBREG", "(", "nmode", ",", "SUBREG_REG", "(", "operands", "[", "<NUM_LIT>", "]", ")", ",", "SUBREG_BYTE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "+", "GET_MODE_SIZE", "(", "nmode", ")", ")", ";", "dh", "=", "gen_rtx_SUBREG", "(", "nmode", ",", "SUBREG_REG", "(", "operands", "[", "<NUM_LIT>", "]", ")", ",", "SUBREG_BYTE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "REG", "&&", "!", "IS_PSEUDO_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "{", "int", "r", "=", "REGNO", "(", "operands", "[", "<NUM_LIT>", "]", ")", ";", "dh", "=", "gen_rtx_REG", "(", "nmode", ",", "r", ")", ";", "dl", "=", "gen_rtx_REG", "(", "nmode", ",", "r", "+", "HARD_REGNO_NREGS", "(", "r", ",", "nmode", ")", ")", ";", "}", "else", "{", "dh", "=", "gen_rtx_SUBREG", "(", "nmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ";", "dl", "=", "gen_rtx_SUBREG", "(", "nmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "GET_MODE_SIZE", "(", "nmode", ")", ")", ";", "}", "break", ";", "case", "MEM", ":", "switch", "(", "GET_CODE", "(", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ")", ")", "{", "case", "POST_INC", ":", "case", "POST_DEC", ":", "gcc_unreachable", "(", ")", ";", "default", ":", "dl", "=", "operand_subword", "(", "operands", "[", "<NUM_LIT>", "]", ",", "GET_MODE_SIZE", "(", "nmode", ")", "/", "UNITS_PER_WORD", ",", "<NUM_LIT>", ",", "omode", ")", ";", "dh", "=", "operand_subword", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "omode", ")", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "{", "case", "REG", ":", "if", "(", "!", "IS_PSEUDO_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "{", "int", "r", "=", "REGNO", "(", "operands", "[", "<NUM_LIT>", "]", ")", ";", "sh", "=", "gen_rtx_REG", "(", "nmode", ",", "r", ")", ";", "sl", "=", "gen_rtx_REG", "(", "nmode", ",", "r", "+", "HARD_REGNO_NREGS", "(", "r", ",", "nmode", ")", ")", ";", "}", "else", "{", "sh", "=", "gen_rtx_SUBREG", "(", "nmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ";", "sl", "=", "gen_rtx_SUBREG", "(", "nmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "GET_MODE_SIZE", "(", "nmode", ")", ")", ";", "}", "break", ";", "case", "CONST_DOUBLE", ":", "if", "(", "operands", "[", "<NUM_LIT>", "]", "==", "const0_rtx", ")", "sh", "=", "sl", "=", "const0_rtx", ";", "else", "split_double", "(", "operands", "[", "<NUM_LIT>", "]", ",", "&", "sh", ",", "&", "sl", ")", ";", "break", ";", "case", "CONST_INT", ":", "if", "(", "operands", "[", "<NUM_LIT>", "]", "==", "const0_rtx", ")", "sh", "=", "sl", "=", "const0_rtx", ";", "else", "{", "int", "vl", ",", "vh", ";", "switch", "(", "nmode", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "sl", "=", "GEN_INT", "(", "vl", ")", ";", "sh", "=", "GEN_INT", "(", "vh", ")", ";", "}", "break", ";", "case", "SUBREG", ":", "sl", "=", "gen_rtx_SUBREG", "(", "nmode", ",", "SUBREG_REG", "(", "operands", "[", "<NUM_LIT>", "]", ")", ",", "SUBREG_BYTE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "+", "GET_MODE_SIZE", "(", "nmode", ")", ")", ";", "sh", "=", "gen_rtx_SUBREG", "(", "nmode", ",", "SUBREG_REG", "(", "operands", "[", "<NUM_LIT>", "]", ")", ",", "SUBREG_BYTE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", ";", "break", ";", "case", "MEM", ":", "switch", "(", "GET_CODE", "(", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ")", ")", "{", "case", "POST_DEC", ":", "case", "POST_INC", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "default", ":", "sl", "=", "operand_subword", "(", "operands", "[", "<NUM_LIT>", "]", ",", "GET_MODE_SIZE", "(", "nmode", ")", "/", "UNITS_PER_WORD", ",", "<NUM_LIT>", ",", "omode", ")", ";", "sh", "=", "operand_subword", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "omode", ")", ";", "if", "(", "GET_CODE", "(", "dl", ")", "==", "REG", "&&", "true_regnum", "(", "dl", ")", "==", "true_regnum", "(", "XEXP", "(", "XEXP", "(", "sl", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ")", "move_high_first", "=", "<NUM_LIT>", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "move_high_first", ")", "{", "operands", "[", "<NUM_LIT>", "]", "=", "dh", ";", "operands", "[", "<NUM_LIT>", "]", "=", "sh", ";", "operands", "[", "<NUM_LIT>", "]", "=", "dl", ";", "operands", "[", "<NUM_LIT>", "]", "=", "sl", ";", "}", "else", "{", "operands", "[", "<NUM_LIT>", "]", "=", "dl", ";", "operands", "[", "<NUM_LIT>", "]", "=", "sl", ";", "operands", "[", "<NUM_LIT>", "]", "=", "dh", ";", "operands", "[", "<NUM_LIT>", "]", "=", "sh", ";", "}", "return", ";", "}" ]

[ "Split", "a", "move", "into", "two", "smaller", "pieces", ".", "MODE", "indicates", "the", "reduced", "mode", ".", "OPERANDS", "[", "0", "]", "is", "the", "original", "destination", "OPERANDS", "[", "1", "]", "is", "the", "original", "src", ".", "The", "new", "destinations", "are", "OPERANDS", "[", "2", "]", "and", "OPERANDS", "[", "4", "]", ",", "while", "the", "new", "sources", "are", "OPERANDS", "[", "3", "]", "and", "OPERANDS", "[", "5", "]", "." ]

[ "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";" ]

[ "return", "false", ";", "}", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "case", "'", "b", "'", ":", "case", "'", "h", "'", ":", "case", "'", "s", "'", ":", "case", "'", "d", "'", ":", "case", "'", "q", "'", ":", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "const", "TargetRegisterClass", "*", "RC", ";", "switch", "(", "ExtraCode", "[", "<NUM_LIT>", "]", ")", "{", "case", "'", "b", "'", ":", "RC", "=", "&", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "'", "h", "'", ":", "RC", "=", "&", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "'", "s", "'", ":", "RC", "=", "&", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "'", "d", "'", ":", "RC", "=", "&", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "'", "q", "'", ":", "RC", "=", "&", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "default", ":", "return", "true", ";", "}", "return", "printAsmRegInClass", "(", "MO", ",", "RC", ",", "false", ",", "O", ")", ";", "}", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "}", "}", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{" ]

[ "Rn", ",", "VectorIndexD", ":", "$", "imm", ",", "(", "v2f64", "(", "INSERT_SUBREG", "(", "v2f64", "(", "IMPLICIT_DEF", ")", ")", ",", "FPR64", ":", "$", "Rm", ",", "dsub", ")", ")", ",", "(", "i64", "<NUM_LIT>", ")", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v2f64", "(", "vector_insert", "(", "v2f64", "V128", ":", "$", "Rn", ")", ",", "(", "f64", "FPR64", ":", "$", "Rm", ")", ",", "(", "i64", "VectorIndexD", ":", "$", "imm", ")", ")", ")", ",", "(", "INSvi64lane", "V128", ":", "$" ]

[ "return", "FrameAddr", ";" ]

[ "SDLoc", "DL", "(", "Op", ")", ";", "SDValue", "FrameAddr", "=", "DAG", ".", "getCopyFromReg", "(", "DAG", ".", "getEntryNode", "(", ")", ",", "DL", ",", "IsN64", "?", "Mips", "::", "FP_64", ":", "Mips", "::", "FP", ",", "VT", ")", ";" ]

[ "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i32", ",", "Op0", ",", "Op1", ")", ";" ]

[ "unsigned", "ExtendOp", "=", "isX86CCUnsigned", "(", "X86CC", ")", "?", "ISD", "::", "ZERO_EXTEND", ":", "ISD", "::", "SIGN_EXTEND", ";", "Op0", "=", "DAG", ".", "getNode", "(", "ExtendOp", ",", "dl", ",", "MVT", "::", "i32", ",", "Op0", ")", ";", "Op1", "=", "DAG", ".", "getNode", "(", "ExtendOp", ",", "dl", ",", "MVT", "::", "i32", ",", "Op1", ")", ";", "}", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "Op0", ".", "getValueType", "(", ")", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Sub", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VTs", ",", "Op0", ",", "Op1", ")", ";", "return", "SDValue", "(", "Sub", ".", "getNode", "(", ")", ",", "<NUM_LIT>", ")", ";", "}" ]

[ "}" ]

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

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

[ "temp", ".", "val", "[", "<NUM_LIT>", "]", "=", "vcombine_p8", "(", "_", "_", "tab", ".", "val", "[", "<NUM_LIT>", "]", ",", "_", "_", "tab", ".", "val", "[", "<NUM_LIT>", "]", ")", ";", "_", "_", "o", "=", "_", "_", "builtin_aarch64_set_qregoiv16qi", "(", "_", "_", "o", ",", "(", "int8x16_t", ")", "temp", ".", "val", "[", "<NUM_LIT>", "]" ]

[ ")", ";" ]

[ "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "GuaranteedTailCallOpt", "&&", "I", "->", "getOpcode", "(", ")", "==", "PPC", "::", "ADJCALLSTACKUP", ")", "{", "if", "(", "int", "CalleeAmt", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", "{", "bool", "is64Bit", "=", "Subtarget", ".", "isPPC64", "(", ")", ";", "CalleeAmt", "*=", "-", "<NUM_LIT>", ";", "unsigned", "StackReg", "=", "is64Bit", "?", "PPC", "::", "X1", ":", "PPC", "::", "R1", ";", "unsigned", "TmpReg", "=", "is64Bit", "?", "PPC", "::", "X0", ":", "PPC", "::", "R0", ";", "unsigned", "ADDIInstr", "=", "is64Bit", "?", "PPC", "::", "ADDI8", ":", "PPC", "::", "ADDI", ";", "unsigned", "ADDInstr", "=", "is64Bit", "?", "PPC", "::", "ADD8", ":", "PPC", "::", "ADD4", ";", "unsigned", "LISInstr", "=", "is64Bit", "?", "PPC", "::", "LIS8", ":", "PPC", "::", "LIS", ";", "unsigned", "ORIInstr", "=", "is64Bit", "?", "PPC", "::", "ORI8", ":", "PPC", "::", "ORI", ";", "MachineInstr", "*", "MI", "=", "I", ";", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "isInt", "<", "<NUM_LIT>", ">", "(", "CalleeAmt", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "TII", ".", "get", "(", "ADDIInstr", ")", ",", "StackReg", ")", ".", "addReg", "(", "StackReg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "CalleeAmt", ")", ";", "}", "else", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "I", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "LISInstr", ")", ",", "TmpReg", ")", ".", "addImm", "(", "CalleeAmt", ">>", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ORIInstr", ")", ",", "TmpReg", ")", ".", "addReg", "(", "TmpReg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "CalleeAmt", "&", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ADDInstr", ")", ",", "StackReg", ")", ".", "addReg", "(", "StackReg", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "TmpReg", ")", ";", "}", "}", "}", "MBB", ".", "erase", "(", "I" ]

[ "vis", "=", "DECL_VISIBILITY", "(", "fn", ")", ";" ]

[ "bool", "ret", ";", "if", "(", "!", "TARGET_FDPIC", ")", "return", "true", ";", "if", "(", "!", "SYMBOL_REF_LOCAL_P", "(", "fnx", ")", ")", "return", "false", ";", "fn", "=", "SYMBOL_REF_DECL", "(", "fnx", ")", ";", "if", "(", "!", "fn", ")", "return", "false", ";" ]

[ "<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", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=" ]

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

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

[ "indirect_thunk_prefix_nt", ";" ]

[ "enum", "indirect_thunk_prefix", "need_prefix", ";", "if", "(", "ix86_bnd_prefixed_insn_p", "(", "insn", ")", ")", "need_prefix", "=", "indirect_thunk_prefix_bnd", ";", "else", "if", "(", "(", "cfun", "->", "machine", "->", "indirect_branch_type", "==", "indirect_branch_thunk_extern", ")", "&&", "ix86_notrack_prefixed_insn_p", "(", "insn", ")", ")", "{", "need_prefix", "=" ]

[ "static", "void", "msp430_print_operand_addr", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "PLUS", ":", "msp430_print_operand_raw", "(", "file", ",", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", ";", "gcc_assert", "(", "REG_P", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "(%s)", "<STR_LIT>", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", "]", ")", ";", "return", ";", "case", "REG", ":", "fprintf", "(", "file", ",", "<STR_LIT>", "@", "<STR_LIT>", ")", ";", "break", ";", "case", "CONST", ":", "case", "CONST_INT", ":", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "fprintf", "(", "file", ",", "<STR_LIT>", "&", "<STR_LIT>", ")", ";", "break", ";", "default", ":", "break", ";", "}", "msp430_print_operand_raw", "(", "file", ",", "addr", ")", ";", "}" ]

[ "Output", "to", "stdio", "stream", "FILE", "the", "assembler", "syntax", "for", "an", "instruction", "operand", "that", "is", "a", "memory", "reference", "whose", "address", "is", "ADDR", "." ]

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

[ "JVMLoadStoreEliminationOpt", "(", ")", ":", "MachineFunctionPass", "(", "ID", ")", "{", "initializeJVMLoadStoreEliminationOptPass", "(", "*", "PassRegistry", "::" ]

[ "<FIXS>", "Sched", "[", "Sched", "]", ">", ",", "VEX", ",", "VVVV", ",", "VEX_L", ";", "<FIXE>" ]

[ "<STR_LIT>", ")", ",", "[", "(", "set", "VR256", ":", "$", "dst", ",", "(", "OpVT", "(", "X86VPermv", "VR256", ":", "$", "src1", ",", "VR256", ":", "$", "src2", ")", ")", ")", "]", ">", ",", "<BUGS>", "Sched", "[", "Sched", "]", ">", ",", "VEX_4V", ",", "VEX_L", ";", "<BUGE>", "def", "Yrm", ":", "AVX28I", "opc", ",", "MRMSrcMem", ",", "(", "outs", "VR256", ":", "$", "dst", ")", ",", "(", "ins", "VR256", ":", "$", "src1", ",", "memOp", ":", "$", "src2", ")", ",", "!", "strconcat", "(", "OpcodeStr", "," ]

[ "<FIXS>", "return", "DW_CC_GNU_renesas_sh", ";", "<FIXE>" ]

[ "sh_dwarf_calling_convention", "(", "tree", "func", ")", "{", "if", "(", "sh_attr_renesas_p", "(", "func", ")", ")", "<BUGS>", "return", "DW_CC_renesas_sh", ";", "<BUGE>", "return", "DW_CC_normal", ";", "}" ]

[ "<FIXS>", "return", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "INT_11_BITS", "(", "op", ")", ")", ";", "}", "intuint32_operand", "(", "op", ",", "mode", ")", "rtx", "op", ";", "enum", "machine_mode", "mode", ";", "{", "#", "if", "HOST_BITS_PER_WIDE_INT", ">", "<NUM_LIT>", "return", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "(", "INTVAL", "(", "op", ")", ">=", "<NUM_LIT>", "&&", "INTVAL", "(", "op", ")", "<NUM_LIT>", "L", ")", ")", ";", "#", "elsereturn", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "||", "(", "GET_CODE", "(", "op", ")", "==", "CONST_DOUBLE", "&&", "CONST_DOUBLE_HIGH", "(", "op", ")", "==", "<NUM_LIT>", ")", ")", ";", "#", "endif", "<FIXE>" ]

[ "return", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "INT_U5_BITS", "(", "op", ")", ")", ";", "}", "intint11_operand", "(", "op", ",", "mode", ")", "rtx", "op", ";", "enum", "machine_mode", "mode", ";", "{", "<BUGS>", "return", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "INT_11_BITS", "(", "op", ")", ")", ";", "<BUGE>", "}", "int" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m128", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_maskz_fmadd_round_ss", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m128", "_", "_", "W", ",", "_", "_", "m128", "_", "_", "A", ",", "_", "_", "m128", "_", "_", "B", ",", "const", "int", "_", "_", "R", ")", "{", "return", "(", "_", "_", "m128", ")", "_", "_", "builtin_ia32_vfmaddss3_maskz", "(", "(", "_", "_", "v4sf", ")", "_", "_", "W", ",", "(", "_", "_", "v4sf", ")", "_", "_", "A", ",", "(", "_", "_", "v4sf", ")", "_", "_", "B", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ",", "_", "_", "R", ")", ";" ]

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

[ "DenseMap", "<", "const", "AllocaInst", "*", ",", "int", ">", "::", "iterator", "SI", "=", "FuncInfo", ".", "StaticAllocaMap", ".", "find", "(", "AI", ")", ";", "if", "(", "SI", "!=", "FuncInfo", ".", "StaticAllocaMap", ".", "end", "(", ")", ")", "{", "unsigned", "Opc", "=", "isThumb2", "?", "ARM", "::", "t2ADDri", ":", "ARM", "::", "ADDri", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TLI", ".", "getRegClassFor", "(", "VT", ")", ";", "unsigned", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "ResultReg", "=", "constrainOperandRegClass", "(", "TII", ".", "get", "(", "Opc", ")", ",", "ResultReg" ]

[ "UNSPECV_HTM_TTEST" ]

[ "[", "UNSPECV_HTM_TABORT", "UNSPECV_HTM_TABORTXC", "UNSPECV_HTM_TABORTXCI", "UNSPECV_HTM_TBEGIN", "UNSPECV_HTM_TCHECK", "UNSPECV_HTM_TEND", "UNSPECV_HTM_TRECHKPT", "UNSPECV_HTM_TRECLAIM", "UNSPECV_HTM_TSR" ]

[ "}" ]

[ "return", "CurDAG", "-", ">", "getTargetConstant", "(", "enc", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i32", ")", ";", "}", "]", ">", ">", "{", "let", "ParserMatchClass", "=", "SIMDImmType10Operand", ";", "let", "PrintMethod", "=", "<STR_LIT>", ";" ]

[ "void", "ARMCodeEmitter", "::", "emitInstruction", "(", "const", "MachineInstr", "&", "MI", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "<STR_LIT>", "JIT: ", "<STR_LIT>", "<<", "(", "void", "*", ")", "MCE", ".", "getCurrentPCValue", "(", ")", "<<", "<STR_LIT>", ":\\t", "<STR_LIT>", "<<", "MI", ")", ";", "MCE", ".", "processDebugLoc", "(", "MI", ".", "getDebugLoc", "(", ")", ",", "true", ")", ";", "++", "NumEmitted", ";", "switch", "(", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "default", ":", "{", "llvm_unreachable", "(", "<STR_LIT>", "Unhandled instruction encoding format!", "<STR_LIT>", ")", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "LEApcrelJT", ")", "{", "emitLEApcrelJTInstruction", "(", "MI", ")", ";", "break", ";", "}", "llvm_unreachable", "(", "<STR_LIT>", "Unhandled instruction encoding!", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "emitPseudoInstruction", "(", "MI", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "emitDataProcessingInstruction", "(", "MI", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "emitLoadStoreInstruction", "(", "MI", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "emitMiscLoadStoreInstruction", "(", "MI", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "emitLoadStoreMultipleInstruction", "(", "MI", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "emitMulFrmInstruction", "(", "MI", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "emitExtendInstruction", "(", "MI", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "emitMiscArithInstruction", "(", "MI", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "emitSaturateInstruction", "(", "MI", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "emitBranchInstruction", "(", "MI", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "emitMiscBranchInstruction", "(", "MI", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "emitVFPArithInstruction", "(", "MI", ")", ";", "break", ";", "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>", ":", "emitVFPConversionInstruction", "(", "MI", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "emitVFPLoadStoreInstruction", "(", "MI", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "emitVFPLoadStoreMultipleInstruction", "(", "MI", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "emitNEONLaneInstruction", "(", "MI", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "emitNEONDupInstruction", "(", "MI", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "emitNEON1RegModImmInstruction", "(", "MI", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "emitNEON2RegInstruction", "(", "MI", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "emitNEON3RegInstruction", "(", "MI", ")", ";", "break", ";", "}", "MCE", ".", "processDebugLoc", "(", "MI", ".", "getDebugLoc", "(", ")", ",", "false", ")", ";", "}" ]

[ "Targets", "should", "implement", "this", "to", "emit", "instructions", "." ]

[ "if", "(", "!", "match", "(", "FalseV", ",", "m_Xor", "(", "m_Specific", "(", "TrueV", ")", ",", "m_Value", "(", "Q", ")", ")", ")", "&&", "!", "match", "(", "FalseV", ",", "m_Xor", "(", "m_Value", "(", "Q", ")", ",", "m_Specific", "(", "TrueV", ")", ")", ")", ")", "return", "false", ";" ]

[ "if", "(", "P", "!=", "CmpInst", "::", "ICMP_EQ", "&&", "P", "!=", "CmpInst", "::", "ICMP_NE", ")", "return", "false", ";", "TrueIfZero", "=", "(", "P", "==", "CmpInst", "::", "ICMP_NE", ")", ";", "}", "else", "return", "false", ";", "Value", "*", "X", "=", "nullptr", ";", "if", "(", "!", "match", "(", "C", ",", "m_And", "(", "m_Value", "(", "X", ")", ",", "m_One", "(", ")", ")", ")", "&&", "!", "match", "(", "C", ",", "m_And", "(", "m_One", "(", ")", ",", "m_Value", "(", "X", ")", ")", ")", ")", "return", "false", ";", "Value", "*", "R", "=", "nullptr", ",", "*", "Q", "=", "nullptr", ";", "if", "(", "TrueIfZero", ")", "{", "if", "(", "!", "match", "(", "TrueV", ",", "m_LShr", "(", "m_Value", "(", "R", ")", ",", "m_One", "(", ")", ")", ")", ")", "return", "false", ";" ]

[ ";" ]

[ "if", "(", "exact_real_inverse", "(", "DFmode", ",", "&", "r0", ")", "&&", "!", "REAL_VALUE_NEGATIVE", "(", "r0", ")", ")", "{", "if", "(", "exact_real_truncate", "(", "DFmode", ",", "&", "r0", ")", ")", "{", "HOST_WIDE_INT", "value", "=", "real_to_integer", "(", "&", "r0", ")", ";", "value", "=", "value", "&", "<NUM_LIT>", ";", "if", "(", "(", "value", "!=", "<NUM_LIT>", ")", "&&", "(", "(", "value", "&", "(", "value", "-", "<NUM_LIT>", ")", ")", "==", "<NUM_LIT>", ")", ")", "return", "int_log2", "(", "value", ")", ";", "}", "}", "return", "<NUM_LIT>" ]

[ "Ops", "[", "<NUM_LIT>", "]", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SUB", ",", "DL", ",", "VT", ",", "Ops", "[", "<NUM_LIT>", "]", ",", "NegSum", ")", ";" ]

[ "else", "{", "SDValue", "C63", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i64", ")", ";", "SDValue", "LL", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "RL", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "LH", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRA", ",", "DL", ",", "VT", ",", "LL", ",", "C63", ")", ";", "SDValue", "RH", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRA", ",", "DL", ",", "VT", ",", "RL", ",", "C63", ")", ";", "lowerGR128Binary", "(", "DAG", ",", "DL", ",", "VT", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "LL", ",", "RL", ",", "Ops", "[", "<NUM_LIT>", "]", ",", "Ops", "[", "<NUM_LIT>", "]", ")", ";", "SDValue", "NegLLTimesRH", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "VT", ",", "LL", ",", "RH", ")", ";", "SDValue", "NegLHTimesRL", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "VT", ",", "LH", ",", "RL", ")", ";", "SDValue", "NegSum", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "VT", ",", "NegLLTimesRH", ",", "NegLHTimesRL", ")", ";" ]

[ "output_asm_insn", "(", "s", ",", "operands", ")", ";" ]

[ "s", "=", "division", ";", "if", "(", "loongarch_check_zero_div_p", "(", ")", ")", "{" ]

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

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

[ "}" ]

[ "extern", "_", "_", "inline", "void", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_mask_i32scatter_epi64", "(", "void", "*", "_", "_", "addr", ",", "_", "_", "mmask8", "_", "_", "mask", ",", "_", "_", "m128i", "_", "_", "index", ",", "_", "_", "m128i", "_", "_", "v1", ",", "const", "int", "_", "_", "scale", ")", "{", "_", "_", "builtin_ia32_scattersiv2di", "(", "_", "_", "addr", ",", "_", "_", "mask", ",", "(", "_", "_", "v4si", ")", "_", "_", "index", ",", "(", "_", "_", "v2di", ")", "_", "_", "v1", ",", "_", "_", "scale", ")", ";" ]

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

[ "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "const", "ARMSubtarget", "*", "STI", "=", "&", "Fn", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "!", "STI", "->", "isCortexA9", "(", ")", ")", "return", "false", ";", "isLikeA9", "=", "STI", "->", "isLikeA9", "(", ")", "||", "STI", "->", "isSwift", "(", ")", ";", "isSwift", "=", "STI", "->" ]

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

[ "}", "}", "else", "{", "for", "(", "SDValue", "V", ":", "Values", ")", "Words", ".", "push_back", "(", "DAG", ".", "getBitcast", "(", "MVT", "::", "i32", ",", "V", ")", ")", ";", "}", "auto", "isSplat", "=", "[", "]", "(", "ArrayRef", "<", "SDValue", ">", "Values", ",", "SDValue", "&", "SplatV", ")", "{", "unsigned", "NumValues", "=", "Values", ".", "size", "(", ")", ";", "assert", "(", "NumValues", ">", "<NUM_LIT>", ")", ";", "bool", "IsUndef", "=", "true", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumValues", ";", "++", "i", ")", "{", "if", "(", "Values", "[", "i", "]", ".", "isUndef", "(", ")", ")", "continue", ";", "IsUndef", "=", "false", ";", "if", "(", "!", "SplatV", ".", "getNode", "(", ")", ")", "SplatV", "=", "Values", "[", "i", "]", ";", "else", "if", "(", "SplatV", "!=", "Values", "[", "i", "]", ")", "return", "false", ";", "}", "if", "(", "IsUndef", ")", "SplatV", "=", "Values", "[", "<NUM_LIT>", "]", ";", "return", "true", ";", "}", ";", "unsigned", "NumWords", "=", "Words", ".", "size", "(", ")", ";", "SDValue", "SplatV", ";", "bool", "IsSplat", "=", "isSplat", "(", "Words", ",", "SplatV", ")", ";", "if", "(", "IsSplat", "&&", "isUndef", "(", "SplatV", ")", ")", "return", "DAG", ".", "getUNDEF", "(", "VecTy", ")", ";", "if", "(", "IsSplat", ")", "{", "assert", "(", "SplatV", ".", "getNode", "(", ")", ")", ";", "if", "(", "isNullConstant", "(", "SplatV", ")", ")", "return", "getZero", "(", "dl", ",", "VecTy", ",", "DAG", ")", ";", "MVT", "WordTy", "=", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i32", ",", "HwLen", "/", "<NUM_LIT>", ")", ";", "SDValue", "S", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SPLAT_VECTOR", ",", "dl", ",", "WordTy", ",", "SplatV", ")", ";", "return", "DAG", ".", "getBitcast", "(", "VecTy", ",", "S", ")", ";", "}", "SmallVector", "<", "ConstantInt", "*", ",", "<NUM_LIT>", ">", "Consts", "(", "VecLen", ")", ";", "bool", "AllConst", "=", "getBuildVectorConstInts", "(", "Values", ",", "VecTy", ",", "DAG", ",", "Consts", ")", ";", "if", "(", "AllConst", ")", "{", "ArrayRef", "<", "Constant", "*", ">", "Tmp", "(", "(", "Constant", "*", "*", ")", "Consts", ".", "begin", "(", ")", ",", "(", "Constant", "*", "*", ")", "Consts", ".", "end", "(", ")", ")", ";", "Constant", "*", "CV", "=", "ConstantVector", "::", "get", "(", "Tmp", ")", ";", "Align", "Alignment", "(", "HwLen", ")", ";", "SDValue", "CP", "=", "LowerConstantPool", "(", "DAG", ".", "getConstantPool", "(", "CV", ",", "VecTy", ",", "Alignment", ")", ",", "DAG", ")", ";", "return", "DAG", ".", "getLoad", "(", "VecTy", ",", "dl", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "CP", ",", "MachinePointerInfo", "::", "getConstantPool", "(", "MF", ")", ",", "Alignment", ")", ";", "}", "auto", "IsBuildFromExtracts", "=", "[", "this", ",", "&", "Values", "]", "(", "SDValue", "&", "SrcVec", ",", "SmallVectorImpl", "<", "int", ">", "&", "SrcIdx", ")", "{", "SDValue", "Vec", ";", "for", "(", "SDValue", "V", ":", "Values", ")", "{", "if", "(", "isUndef", "(", "V", ")", ")", "{", "SrcIdx", ".", "push_back", "(", "-", "<NUM_LIT>", ")", ";", "continue", ";", "}", "if", "(", "V", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "EXTRACT_VECTOR_ELT", ")", "return", "false", ";", "SDValue", "T", "=", "V", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Vec", ".", "getNode", "(", ")", "!=", "nullptr", "&&", "T", ".", "getNode", "(", ")", "!=", "Vec", ".", "getNode", "(", ")", ")", "return", "false", ";", "Vec", "=", "T", ";", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "V", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "C", "==", "nullptr", ")", "return", "false", ";", "int", "I", "=", "C", "->", "getSExtValue", "(", ")", ";", "assert", "(", "I", ">=", "<NUM_LIT>", "&&", "<STR_LIT>", "Negative element index", "<STR_LIT>", ")", ";", "SrcIdx", ".", "push_back", "(", "I", ")", ";", "}", "SrcVec", "=", "Vec", ";", "return", "true", ";", "}", ";", "SmallVector", "<", "int", "," ]

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

[ "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";" ]

[ ",", "_", "_", "b", ")", ";" ]

[ "return", "_", "_", "builtin_aarch64_srshr_ndi", "(", "_", "_", "a" ]

[ "let", "Pattern", "=", "pattern", ";" ]

[ "class", "SpuInst_UnarySw", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "RegisterClass", "Rdst", ",", "RegisterClass", "Rsrc", ",", "string", "asmstr", ",", "list", "<", "dag", ">", "pattern", "=", "[", "]", ">", ":", "ScalarInstBase", "<", "opc", ",", "asmstr", ">", "{", "let", "OutOperandList", "=", "(", "outs", "Rdst", ":", "$", "dest", ")", ";", "let", "InOperandList", "=", "(", "ins", "Rsrc", ":", "$", "op", ",", "DataType", ":", "$", "optype", ",", "SwitchSet", ":", "$", "sw", ",", "Rdst", ":", "$", "income", ",", "SPred", ":", "$", "pred", ")", ";" ]

[ "}" ]

[ "def", "F2_conv_sf2d_chop", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_3a867367", ",", "TypeS_2op", ">", ",", "Enc_3a3d62", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isFP", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "USR", "]", ";" ]

[ "}" ]

[ "bool", "PPCSubtarget", "::", "isPPC64", "(", ")", "const", "{", "return", "TM", ".", "isPPC64", "(", ")", ";" ]

[ ";" ]

[ "int", "offset", "=", "<NUM_LIT>", ";", "for", "(", "int", "i", "=", "std", "::", "size", "(", "ArgRegs", ")", "-", "<NUM_LIT>", ";", "i", ">=", "(", "int", ")", "FirstVAReg", ";", "--", "i", ")", "{", "int", "FI", "=", "MFI", ".", "CreateFixedObject", "(", "<NUM_LIT>", ",", "offset", ",", "true", ")", ";", "if", "(", "i", "==", "(", "int", ")", "FirstVAReg", ")", "{", "XFI", "->", "setVarArgsFrameIndex", "(", "FI", ")", ";", "}", "offset", "-=", "StackSlotSize", ";", "SDValue", "FIN", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "MVT", "::", "i32", ")", ";", "Register", "VReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "RegInfo", ".", "addLiveIn", "(", "ArgRegs", "[", "i", "]", ",", "VReg", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VReg", ",", "MVT", "::", "i32", ")", ";", "CFRegNode", ".", "push_back", "(", "Val", ".", "getValue", "(", "Val", "->", "getNumValues", "(", ")", "-", "<NUM_LIT>", ")", ")", ";", "SDValue", "Store", "=", "DAG", ".", "getStore", "(", "Val", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "dl", ",", "Val", ",", "FIN", ",", "MachinePointerInfo", "(", ")", ")", ";", "MemOps", ".", "push_back", "(", "Store", ")", ";", "}", "}", "else", "{", "XFI", "->", "setVarArgsFrameIndex", "(", "MFI", ".", "CreateFixedObject", "(", "<NUM_LIT>", ",", "LRSaveSize", "+", "CCInfo", ".", "getStackSize", "(", ")", ",", "true", ")", ")", ";", "}", "}", "if", "(", "!", "CFRegNode", ".", "empty", "(", ")", ")", "Chain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "dl", ",", "MVT", "::", "Other", ",", "CFRegNode", ")", ";", "for", "(", "const", "ArgDataPair", "&", "ArgDI", ":", "ArgData", ")", "{", "if", "(", "ArgDI", ".", "Flags", ".", "isByVal", "(", ")", "&&", "ArgDI", ".", "Flags", ".", "getByValSize", "(", ")", ")", "{", "unsigned", "Size", "=", "ArgDI", ".", "Flags", ".", "getByValSize", "(", ")", ";", "Align", "Alignment", "=", "std", "::", "max", "(", "Align", "(", "StackSlotSize", ")", ",", "ArgDI", ".", "Flags", ".", "getNonZeroByValAlign", "(", ")", ")", ";", "int", "FI", "=", "MFI", ".", "CreateStackObject", "(", "Size", ",", "Alignment", ",", "false", ")", ";", "SDValue", "FIN", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "MVT", "::", "i32", ")", ";", "InVals", ".", "push_back", "(", "FIN", ")", ";", "MemOps", ".", "push_back", "(", "DAG", ".", "getMemcpy", "(", "Chain", ",", "dl", ",", "FIN", ",", "ArgDI", ".", "SDV", ",", "DAG", ".", "getConstant", "(", "Size", ",", "dl", ",", "MVT", "::", "i32", ")", ",", "Alignment", ",", "false", ",", "false", ",", "false", ",", "MachinePointerInfo", "(", ")", ",", "MachinePointerInfo", "(", ")", ")", ")", ";", "}", "else", "{", "InVals", ".", "push_back", "(", "ArgDI", ".", "SDV", ")", ";", "}", "}", "if", "(", "!", "MemOps", ".", "empty", "(", ")", ")", "{", "MemOps", ".", "push_back", "(", "Chain", ")", ";", "Chain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "dl", ",", "MVT", "::", "Other", ",", "MemOps", ")", ";", "}", "return", "Chain" ]

[ "<FIXS>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "<FIXE>", "<FIXS>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "<FIXE>" ]

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

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

[ "(", "define_mode_iterator", "EXTSI", "[", "(", "DI" ]

[ "<FIXS>", "ParseSubtargetFeatures", "(", "CPUString", ",", "CPUString", ",", "FS", ")", ";", "<FIXE>" ]

[ "UseBSBScheduling", "=", "hasV60Ops", "(", ")", "&&", "EnableBSBSched", ";", "<BUGS>", "ParseSubtargetFeatures", "(", "CPUString", ",", "FS", ")", ";", "<BUGE>", "if", "(", "OverrideLongCalls", ".", "getPosition", "(", ")", ")", "UseLongCalls", "=", "OverrideLongCalls", ";" ]

[ "<STR_LIT>", "inconsistent dead flag", "<STR_LIT>", ")", ";" ]

[ "bool", "definesCPSR", "=", "false", ";", "bool", "deadCPSR", "=", "false", ";", "for", "(", "unsigned", "i", "=", "MCID", "->", "getNumOperands", "(", ")", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isDef", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "ARM", "::", "CPSR", ")", "{", "definesCPSR", "=", "true", ";", "if", "(", "MO", ".", "isDead", "(", ")", ")", "deadCPSR", "=", "true", ";", "MI", "->", "RemoveOperand", "(", "i", ")", ";", "break", ";", "}", "}", "if", "(", "!", "definesCPSR", ")", "{", "assert", "(", "!", "NewOpc", "&&", "<STR_LIT>", "Optional cc_out operand required", "<STR_LIT>", ")", ";", "return", ";", "}", "assert", "(", "deadCPSR", "==", "!", "Node", "->", "hasAnyUseOfValue", "(", "<NUM_LIT>", ")", "&&" ]

[ "<FIXS>", "fprintf", "(", "file", ",", "<STR_LIT>", "\\tadd\\t%s, %d, %s\\n", "<STR_LIT>", ",", "sp_str", ",", "(", "int", ")", "size", ",", "sp_str", ")", ";", "<FIXE>" ]

[ "fprintf", "(", "file", ",", "<STR_LIT>", "\\tadd\\t%s, %s, %s\\n", "<STR_LIT>", ",", "sp_str", ",", "t1_str", ",", "sp_str", ")", ";", "else", "if", "(", "size", ">", "<NUM_LIT>", ")", "<BUGS>", "fprintf", "(", "file", ",", "<STR_LIT>", "\\tadd\\t%s, %d, %s\\n", "<STR_LIT>", ",", "sp_str", ",", "size", ",", "sp_str", ")", ";", "<BUGE>", "elsefprintf", "(", "file", ",", "<STR_LIT>", "\\tnop\\n", "<STR_LIT>", ")", ";" ]

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

[ "def", "L2_ploadrbf_io", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pt4", ",", "IntRegs", ":", "$", "Rs32", ",", "u32_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_5ef37dc4", ",", "TypeV2LDST", ">", ",", "Enc_a21d47", ",", "AddrModeRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

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

[ "def", "fpimm16XForm", ":", "SDNodeXForm", "<", "fpimm", ",", "[", "{", "APFloat", "InVal", "=", "N", "-", ">", "getValueAPF", "(", ")", ";", "uint32_t", "enc", "=", "AArch64_AM", ":", ":", "getFP16Imm", "(", "InVal", ")", ";", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "enc", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i32", ")", ";", "}", "]", ">", ";", "def", "fpimm32XForm", ":", "SDNodeXForm", "<", "fpimm", ",", "[", "{", "APFloat", "InVal", "=", "N", "-", ">", "getValueAPF", "(", ")", ";", "uint32_t", "enc", "=", "AArch64_AM", ":", ":", "getFP32Imm", "(", "InVal", ")", ";", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "enc", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i32", ")", ";" ]

[ "Ops", ".", "push_back", "(", "SDValue", "(", "VStA", ",", "<NUM_LIT>", ")", ")", ";" ]

[ "case", "MVT", "::", "v8f16", ":", "case", "MVT", "::", "v8i16", ":", "OpcodeIndex", "=", "<NUM_LIT>", ";", "break", ";", "case", "MVT", "::", "v4f32", ":", "case", "MVT", "::", "v4i32", ":", "OpcodeIndex", "=", "<NUM_LIT>", ";", "break", ";", "case", "MVT", "::", "v2f64", ":", "case", "MVT", "::", "v2i64", ":", "OpcodeIndex", "=", "<NUM_LIT>", ";", "break", ";", "}", "std", "::", "vector", "<", "EVT", ">", "ResTys", ";", "if", "(", "isUpdating", ")", "ResTys", ".", "push_back", "(", "MVT", "::", "i32", ")", ";", "ResTys", ".", "push_back", "(", "MVT", "::", "Other", ")", ";", "SDValue", "Pred", "=", "getAL", "(", "CurDAG", ",", "dl", ")", ";", "SDValue", "Reg0", "=", "CurDAG", "->", "getRegister", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Ops", ";", "if", "(", "is64BitVector", "||", "NumVecs", "<=", "<NUM_LIT>", ")", "{", "SDValue", "SrcReg", ";", "if", "(", "NumVecs", "==", "<NUM_LIT>", ")", "{", "SrcReg", "=", "N", "->", "getOperand", "(", "Vec0Idx", ")", ";", "}", "else", "if", "(", "is64BitVector", ")", "{", "SDValue", "V0", "=", "N", "->", "getOperand", "(", "Vec0Idx", "+", "<NUM_LIT>", ")", ";", "SDValue", "V1", "=", "N", "->", "getOperand", "(", "Vec0Idx", "+", "<NUM_LIT>", ")", ";", "if", "(", "NumVecs", "==", "<NUM_LIT>", ")", "SrcReg", "=", "SDValue", "(", "createDRegPairNode", "(", "MVT", "::", "v2i64", ",", "V0", ",", "V1", ")", ",", "<NUM_LIT>", ")", ";", "else", "{", "SDValue", "V2", "=", "N", "->", "getOperand", "(", "Vec0Idx", "+", "<NUM_LIT>", ")", ";", "SDValue", "V3", "=", "(", "NumVecs", "==", "<NUM_LIT>", ")", "?", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "TargetOpcode", "::", "IMPLICIT_DEF", ",", "dl", ",", "VT", ")", ",", "<NUM_LIT>", ")", ":", "N", "->", "getOperand", "(", "Vec0Idx", "+", "<NUM_LIT>", ")", ";", "SrcReg", "=", "SDValue", "(", "createQuadDRegsNode", "(", "MVT", "::", "v4i64", ",", "V0", ",", "V1", ",", "V2", ",", "V3", ")", ",", "<NUM_LIT>", ")", ";", "}", "}", "else", "{", "SDValue", "Q0", "=", "N", "->", "getOperand", "(", "Vec0Idx", ")", ";", "SDValue", "Q1", "=", "N", "->", "getOperand", "(", "Vec0Idx", "+", "<NUM_LIT>", ")", ";", "SrcReg", "=", "SDValue", "(", "createQRegPairNode", "(", "MVT", "::", "v4i64", ",", "Q0", ",", "Q1", ")", ",", "<NUM_LIT>", ")", ";", "}", "unsigned", "Opc", "=", "(", "is64BitVector", "?", "DOpcodes", "[", "OpcodeIndex", "]", ":", "QOpcodes0", "[", "OpcodeIndex", "]", ")", ";", "Ops", ".", "push_back", "(", "MemAddr", ")", ";", "Ops", ".", "push_back", "(", "Align", ")", ";", "if", "(", "isUpdating", ")", "{", "SDValue", "Inc", "=", "N", "->", "getOperand", "(", "AddrOpIdx", "+", "<NUM_LIT>", ")", ";", "bool", "IsImmUpdate", "=", "isPerfectIncrement", "(", "Inc", ",", "VT", ",", "NumVecs", ")", ";", "if", "(", "!", "IsImmUpdate", ")", "{", "if", "(", "isVSTfixed", "(", "Opc", ")", ")", "Opc", "=", "getVLDSTRegisterUpdateOpcode", "(", "Opc", ")", ";", "Ops", ".", "push_back", "(", "Inc", ")", ";", "}", "else", "if", "(", "!", "isVSTfixed", "(", "Opc", ")", ")", "Ops", ".", "push_back", "(", "Reg0", ")", ";", "}", "Ops", ".", "push_back", "(", "SrcReg", ")", ";", "Ops", ".", "push_back", "(", "Pred", ")", ";", "Ops", ".", "push_back", "(", "Reg0", ")", ";", "Ops", ".", "push_back", "(", "Chain", ")", ";", "SDNode", "*", "VSt", "=", "CurDAG", "->", "getMachineNode", "(", "Opc", ",", "dl", ",", "ResTys", ",", "Ops", ")", ";", "cast", "<", "MachineSDNode", ">", "(", "VSt", ")", "->", "setMemRefs", "(", "MemOp", ",", "MemOp", "+", "<NUM_LIT>", ")", ";", "ReplaceNode", "(", "N", ",", "VSt", ")", ";", "return", ";", "}", "SDValue", "V0", "=", "N", "->", "getOperand", "(", "Vec0Idx", "+", "<NUM_LIT>", ")", ";", "SDValue", "V1", "=", "N", "->", "getOperand", "(", "Vec0Idx", "+", "<NUM_LIT>", ")", ";", "SDValue", "V2", "=", "N", "->", "getOperand", "(", "Vec0Idx", "+", "<NUM_LIT>", ")", ";", "SDValue", "V3", "=", "(", "NumVecs", "==", "<NUM_LIT>", ")", "?", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "TargetOpcode", "::", "IMPLICIT_DEF", ",", "dl", ",", "VT", ")", ",", "<NUM_LIT>", ")", ":", "N", "->", "getOperand", "(", "Vec0Idx", "+", "<NUM_LIT>", ")", ";", "SDValue", "RegSeq", "=", "SDValue", "(", "createQuadQRegsNode", "(", "MVT", "::", "v8i64", ",", "V0", ",", "V1", ",", "V2", ",", "V3", ")", ",", "<NUM_LIT>", ")", ";", "const", "SDValue", "OpsA", "[", "]", "=", "{", "MemAddr", ",", "Align", ",", "Reg0", ",", "RegSeq", ",", "Pred", ",", "Reg0", ",", "Chain", "}", ";", "SDNode", "*", "VStA", "=", "CurDAG", "->", "getMachineNode", "(", "QOpcodes0", "[", "OpcodeIndex", "]", ",", "dl", ",", "MemAddr", ".", "getValueType", "(", ")", ",", "MVT", "::", "Other", ",", "OpsA", ")", ";", "cast", "<", "MachineSDNode", ">", "(", "VStA", ")", "->", "setMemRefs", "(", "MemOp", ",", "MemOp", "+", "<NUM_LIT>", ")", ";", "Chain", "=", "SDValue", "(", "VStA", ",", "<NUM_LIT>", ")", ";" ]

[ "<STR_LIT>" ]

[ "(", "zero_extend", ":", "DI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "II", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Rs32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rs32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Rx32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rx32", "{", "<NUM_LIT>", "-" ]

[ "void", "X86FrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "Terminator", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "Terminator", ";", "DebugLoc", "DL", ";", "if", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "const", "bool", "Is64BitILP32", "=", "STI", ".", "isTarget64BitILP32", "(", ")", ";", "unsigned", "FramePtr", "=", "TRI", "->", "getFrameRegister", "(", "MF", ")", ";", "unsigned", "MachineFramePtr", "=", "Is64BitILP32", "?", "getX86SubSuperRegister", "(", "FramePtr", ",", "<NUM_LIT>", ")", ":", "FramePtr", ";", "bool", "IsWin64Prologue", "=", "MF", ".", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", "->", "usesWindowsCFI", "(", ")", ";", "bool", "NeedsWin64CFI", "=", "IsWin64Prologue", "&&", "MF", ".", "getFunction", "(", ")", ".", "needsUnwindTableEntry", "(", ")", ";", "bool", "IsFunclet", "=", "MBBI", "==", "MBB", ".", "end", "(", ")", "?", "false", ":", "isFuncletReturnInstr", "(", "*", "MBBI", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "uint64_t", "MaxAlign", "=", "calculateMaxStackAlign", "(", "MF", ")", ";", "unsigned", "CSSize", "=", "X86FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "bool", "HasFP", "=", "hasFP", "(", "MF", ")", ";", "uint64_t", "NumBytes", "=", "<NUM_LIT>", ";", "bool", "NeedsDwarfCFI", "=", "(", "!", "MF", ".", "getTarget", "(", ")", ".", "getTargetTriple", "(", ")", ".", "isOSDarwin", "(", ")", "&&", "!", "MF", ".", "getTarget", "(", ")", ".", "getTargetTriple", "(", ")", ".", "isOSWindows", "(", ")", ")", "&&", "(", "MF", ".", "getMMI", "(", ")", ".", "hasDebugInfo", "(", ")", "||", "MF", ".", "getFunction", "(", ")", ".", "needsUnwindTableEntry", "(", ")", ")", ";", "if", "(", "IsFunclet", ")", "{", "assert", "(", "HasFP", "&&", "<STR_LIT>", "EH funclets without FP not yet implemented", "<STR_LIT>", ")", ";", "NumBytes", "=", "getWinEHFuncletFrameSize", "(", "MF", ")", ";", "int", "Ignore", ";", "if", "(", "IsWin64Prologue", ")", "NumBytes", "+=", "X86FI", "->", "getCalleeSavedXMMFrameInfo", "(", "Ignore", ")", ";", "}", "else", "if", "(", "HasFP", ")", "{", "uint64_t", "FrameSize", "=", "StackSize", "-", "SlotSize", ";", "NumBytes", "=", "FrameSize", "-", "CSSize", ";", "if", "(", "TRI", "->", "needsStackRealignment", "(", "MF", ")", "&&", "!", "IsWin64Prologue", ")", "NumBytes", "=", "alignTo", "(", "FrameSize", ",", "MaxAlign", ")", ";", "}", "else", "{", "NumBytes", "=", "StackSize", "-", "CSSize", ";", "}", "uint64_t", "SEHStackAllocAmt", "=", "NumBytes", ";", "if", "(", "HasFP", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Is64Bit", "?", "X86", "::", "POP64r", ":", "X86", "::", "POP32r", ")", ",", "MachineFramePtr", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "if", "(", "NeedsDwarfCFI", ")", "{", "unsigned", "DwarfStackPtr", "=", "TRI", "->", "getDwarfRegNum", "(", "Is64Bit", "?", "X86", "::", "RSP", ":", "X86", "::", "ESP", ",", "true", ")", ";", "BuildCFI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "MCCFIInstruction", "::", "createDefCfa", "(", "nullptr", ",", "DwarfStackPtr", ",", "-", "SlotSize", ")", ")", ";", "--", "MBBI", ";", "}", "}", "MachineBasicBlock", "::", "iterator", "FirstCSPop", "=", "MBBI", ";", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "PI", "=", "std", "::", "prev", "(", "MBBI", ")", ";", "unsigned", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "!=", "X86", "::", "DBG_VALUE", "&&", "!", "PI", "->", "isTerminator", "(", ")", ")", "{", "if", "(", "(", "Opc", "!=", "X86", "::", "POP32r", "||", "!", "PI", "->", "getFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ")", "&&", "(", "Opc", "!=", "X86", "::", "POP64r", "||", "!", "PI", "->", "getFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ")", ")", "break", ";", "FirstCSPop", "=", "PI", ";", "}", "--", "MBBI", ";", "}", "MBBI", "=", "FirstCSPop", ";", "if", "(", "IsFunclet", "&&", "Terminator", "->", "getOpcode", "(", ")", "==", "X86", "::", "CATCHRET", ")", "emitCatchRetReturnValue", "(", "MBB", ",", "FirstCSPop", ",", "&", "*", "Terminator", ")", ";", "if", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "NumBytes", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "NumBytes", "+=", "mergeSPUpdates", "(", "MBB", ",", "MBBI", ",", "true", ")", ";", "if", "(", "(", "TRI", "->", "needsStackRealignment", "(", "MF", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "&&", "!", "IsFunclet", ")", "{", "if", "(", "TRI", "->", "needsStackRealignment", "(", "MF", ")", ")", "MBBI", "=", "FirstCSPop", ";", "unsigned", "SEHFrameOffset", "=", "calculateSetFPREG", "(", "SEHStackAllocAmt", ")", ";", "uint64_t", "LEAAmount", "=", "IsWin64Prologue", "?", "SEHStackAllocAmt", "-", "SEHFrameOffset", ":", "-", "CSSize", ";", "if", "(", "LEAAmount", "!=", "<NUM_LIT>", ")", "{", "unsigned", "Opc", "=", "getLEArOpcode", "(", "Uses64BitFramePtr", ")", ";", "addRegOffset", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ",", "FramePtr", ",", "false", ",", "LEAAmount", ")", ";", "--", "MBBI", ";", "}", "else", "{", "unsigned", "Opc", "=", "(", "Uses64BitFramePtr", "?", "X86", "::", "MOV64rr", ":", "X86", "::", "MOV32rr", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ".", "addReg", "(", "FramePtr", ")", ";", "--", "MBBI", ";", "}", "}", "else", "if", "(", "NumBytes", ")", "{", "emitSPUpdate", "(", "MBB", ",", "MBBI", ",", "DL", ",", "NumBytes", ",", "true", ")", ";", "if", "(", "!", "hasFP", "(", "MF", ")", "&&", "NeedsDwarfCFI", ")", "{", "BuildCFI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "MCCFIInstruction", "::", "createDefCfaOffset", "(", "nullptr", ",", "-", "CSSize", "-", "SlotSize", ")", ")", ";", "}", "--", "MBBI", ";", "}", "if", "(", "NeedsWin64CFI", "&&", "MF", ".", "hasWinCFI", "(", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "SEH_Epilogue", ")", ")", ";", "if", "(", "!", "hasFP", "(", "MF", ")", "&&", "NeedsDwarfCFI", ")", "{", "MBBI", "=", "FirstCSPop", ";", "int64_t", "Offset", "=", "-", "CSSize", "-", "SlotSize", ";", "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "PI", "=", "MBBI", ";", "unsigned", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "++", "MBBI", ";", "if", "(", "Opc", "==", "X86", "::", "POP32r", "||", "Opc", "==", "X86", "::", "POP64r", ")", "{", "Offset", "+=", "SlotSize", ";", "BuildCFI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "MCCFIInstruction", "::", "createDefCfaOffset", "(", "nullptr", ",", "Offset", ")", ")", ";", "}", "}", "}", "if", "(", "Terminator", "==", "MBB", ".", "end", "(", ")", "||", "!", "isTailCallOpcode", "(", "Terminator", "->", "getOpcode", "(", ")", ")", ")", "{", "int", "Offset", "=", "-", "<NUM_LIT>", "*", "X86FI", "->", "getTCReturnAddrDelta", "(", ")", ";", "assert", "(", "Offset", ">=", "<NUM_LIT>", "&&", "<STR_LIT>", "TCDelta should never be positive", "<STR_LIT>", ")", ";", "if", "(", "Offset", ")", "{", "Offset", "+=", "mergeSPUpdates", "(", "MBB", ",", "Terminator", ",", "true", ")", ";", "emitSPUpdate", "(", "MBB", ",", "Terminator", ",", "DL", ",", "Offset", ",", "true", ")", ";", "}", "}", "}" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

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

[ "bits", "<", "<NUM_LIT>", ">", "Rt", ";", "bits", "<", "<NUM_LIT>", ">", "label", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

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

[ "for", "(", "auto", "&", "Init", ":", "Inits", ")", "{", "auto", "&", "Defs", "=", "Init", ".", "second", ";", "for", "(", "auto", "I1", "=", "Defs", ".", "begin", "(", ")", ",", "E", "=", "Defs", ".", "end", "(", ")", ";", "I1", "!=", "E", ";", ")", "{", "MachineInstr", "*", "MI1", "=", "*", "I1", ";", "for", "(", "auto", "I2", "=", "std", "::", "next", "(", "I1", ")", ";", "I2", "!=", "E", ";", ")", "{", "MachineInstr", "*", "MI2", "=", "*", "I2", ";", "auto", "intereferes", "=", "[", "&", "]", "(", "MachineBasicBlock", "::", "iterator", "From", ",", "MachineBasicBlock", "::", "iterator", "To", ")", "->", "bool", "{", "assert", "(", "MDT", ".", "dominates", "(", "&", "*", "To", ",", "&", "*", "From", ")", ")", ";", "auto", "interferes", "=", "[", "&", "MDT", ",", "From", ",", "To", "]", "(", "MachineInstr", "*", "&", "Clobber", ")", "->", "bool", "{", "const", "MachineBasicBlock", "*", "MBBFrom", "=", "From", "->", "getParent", "(", ")", ";", "const", "MachineBasicBlock", "*", "MBBTo", "=", "To", "->", "getParent", "(", ")", ";", "bool", "MayClobberFrom", "=", "isReachable", "(", "Clobber", ",", "&", "*", "From", ",", "MBBTo", ",", "MDT", ")", ";", "bool", "MayClobberTo", "=", "isReachable", "(", "Clobber", ",", "&", "*", "To", ",", "MBBTo", ",", "MDT", ")", ";", "if", "(", "!", "MayClobberFrom", "&&", "!", "MayClobberTo", ")", "return", "false", ";", "if", "(", "(", "MayClobberFrom", "&&", "!", "MayClobberTo", ")", "||", "(", "!", "MayClobberFrom", "&&", "MayClobberTo", ")", ")", "return", "true", ";", "return", "!", "(", "(", "MBBFrom", "==", "MBBTo", "&&", "MDT", ".", "dominates", "(", "Clobber", ",", "&", "*", "From", ")", "&&", "MDT", ".", "dominates", "(", "Clobber", ",", "&", "*", "To", ")", ")", "||", "MDT", ".", "properlyDominates", "(", "Clobber", "->", "getParent", "(", ")", ",", "MBBTo", ")", ")", ";", "}", ";", "return", "(", "llvm", "::", "any_of", "(", "Clobbers", ",", "interferes", ")", ")", "||", "(", "llvm", "::", "any_of", "(", "Inits", ",", "[", "&", "]", "(", "InitListMap", "::", "value_type", "&", "C", ")", "{", "return", "C", ".", "first", "!=", "Init", ".", "first", "&&", "llvm", "::", "any_of", "(", "C", ".", "second", ",", "interferes", ")", ";", "}", ")", ")", ";", "}", ";", "if", "(", "MDT", ".", "dominates", "(", "MI1", ",", "MI2", ")", ")", "{", "if", "(", "!", "intereferes", "(", "MI2", ",", "MI1", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Erasing from ", "<STR_LIT>", "<<", "printMBBReference", "(", "*", "MI2", "->", "getParent", "(", ")", ")", "<<", "<STR_LIT>", "<STR_LIT>", "<<", "*", "MI2", ")", ";", "MI2", "->", "eraseFromParent", "(", ")", ";", "Defs", ".", "erase", "(", "I2", "++", ")", ";", "Changed", "=", "true", ";", "continue", ";", "}", "}", "else", "if", "(", "MDT", ".", "dominates", "(", "MI2", ",", "MI1", ")", ")", "{", "if", "(", "!", "intereferes", "(", "MI1", ",", "MI2", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Erasing from ", "<STR_LIT>", "<<", "printMBBReference", "(", "*", "MI1", "->", "getParent", "(", ")", ")", "<<", "<STR_LIT>" ]

[ "false", ";" ]

[ "if", "(", "optimizeBitExtract", "(", "inst", ")", ")", "{", "return", "false", ";", "}", "if", "(", "optimizeBitInsert", "(", "inst", ")", ")", "{", "return", "false", ";", "}", "if", "(", "correctMisalignedMemOp", "(", "inst", ")", ")", "{", "return", "false", ";", "}", "return" ]

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

[ "if", "(", "auto", "*", "ArrTy", "=", "dyn_cast", "<", "ArrayType", ">", "(", "GV", "->", "getValueType", "(", ")", ")", ")", "RangeSize", "=", "ArrTy", "->" ]

[ "<FIXS>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<FIXE>" ]

[ "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGS>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGE>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";" ]

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

[ "def", "F2_conv_sf2d", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_3a867367", ",", "TypeS_2op", ">", ",", "Enc_3a3d62", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>" ]

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

[ "class", "CEQI_D_DESC", ":", "MSA_I5_DESC_BASE", "<", "<STR_LIT>", ",", "vseteq_v2i64", ",", "vsplati64_simm5" ]

[ "}" ]

[ "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP0_TTMP1", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP2_TTMP3", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP4_TTMP5", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP6_TTMP7", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP8_TTMP9", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP10_TTMP11", ")", ";", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "unsigned", "MaxNumSGPRs", "=", "ST", ".", "getMaxNumSGPRs", "(", "MF", ")", ";", "unsigned", "TotalNumSGPRs", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxNumSGPRs", ";", "i", "<", "TotalNumSGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "unsigned", "MaxNumVGPRs", "=", "ST", ".", "getMaxNumVGPRs", "(", "MF", ")", ";", "unsigned", "TotalNumVGPRs", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxNumVGPRs", ";", "i", "<", "TotalNumVGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";" ]

[ ";" ]

[ "def", "L2_loadalignh_pbr", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Ryy32", ",", "IntRegs", ":", "$", "Rx32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Ryy32in", ",", "IntRegs", ":", "$", "Rx32in", ",", "ModRegs", ":", "$", "Mu2", ")", ",", "<STR_LIT>", ",", "tc_3c76b0ff", ",", "TypeLD", ">", ",", "Enc_1f5d8f", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "PostInc" ]

[ "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "-", "<NUM_LIT>", ")", ")", ")", "]" ]

[ "(", "const_int", "-", "<NUM_LIT>", ")", ")", "(", "const_int", "<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", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "Absolute", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "isExtended", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "DecoderNamespace", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable" ]

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

[ "def", "A2_tfrtnew", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_05c070ec", ",", "TypeALU32_2op", ">", ",", "PredNewRel", ",", "ImmRegRel", "{", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isPseudo", "=", "<NUM_LIT>", ";" ]

[ "(", "TargetReg", ")", ".", "addReg", "(", "ZERO", ")", ";" ]

[ "unsigned", "ADDU", "=", "ABI", ".", "GetPtrAdduOp", "(", ")", ";", "unsigned", "SP", "=", "Subtarget", ".", "isGP64bit", "(", ")", "?", "Mips", "::", "SP_64", ":", "Mips", "::", "SP", ";", "unsigned", "RA", "=", "Subtarget", ".", "isGP64bit", "(", ")", "?", "Mips", "::", "RA_64", ":", "Mips", "::", "RA", ";", "unsigned", "T9", "=", "Subtarget", ".", "isGP64bit", "(", ")", "?", "Mips", "::", "T9_64", ":", "Mips", "::", "T9", ";", "unsigned", "ZERO", "=", "Subtarget", ".", "isGP64bit", "(", ")", "?", "Mips", "::", "ZERO_64", ":", "Mips", "::", "ZERO", ";", "Register", "OffsetReg", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "Register", "TargetReg", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "const", "TargetMachine", "&", "TM", "=", "MBB", ".", "getParent", "(", ")", "->", "getTarget", "(", ")", ";", "if", "(", "TM", ".", "isPositionIndependent", "(", ")", ")", "BuildMI", "(", "MBB", ",", "I", ",", "I", "->", "getDebugLoc", "(", ")", ",", "get", "(", "ADDU", ")", ",", "T9", ")", ".", "addReg", "(", "TargetReg", ")", ".", "addReg", "(", "ZERO", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "I", "->", "getDebugLoc", "(", ")", ",", "get", "(", "ADDU", ")", ",", "RA", ")", ".", "addReg" ]

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

[ "(", "define_code_iterator", "any_scc", "[", "ltu", "lt", "]", ")", "(", "define_code_attr", "scc_str", "[", "(", "ltu", "<STR_LIT>", ")", "(" ]