Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "AU", ".", "addRequired", "<", "MachineLoopInfo", ">", "(", ")", ";" ]

[ "AU", ".", "addRequired", "<", "MachineFunctionAnalysis", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachinePostDominatorTree", ">", "(", ")", ";" ]

[ "{" ]

[ "[", "(", "set", "(", "match_operand", ":", "VHSDF", "<NUM_LIT>", "<STR_LIT>", ")", "(", "sqrt", ":", "VHSDF", "(", "match_operand", ":", "VHSDF", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>" ]

[ "assert", "(", "I", ".", "Br", "->", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", "==", "<NUM_LIT>", ")", ";" ]

[ "}", "else", "BuildMI", "(", "*", "BalTgtMBB", ",", "Pos", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "ADDiu", ")", ",", "Mips", "::", "SP", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BalTgtMBB", "->", "rbegin", "(", ")", "->", "bundleWithPred", "(", ")", ";", "}", "else", "{", "Pos", "=", "LongBrMBB", "->", "begin", "(", ")", ";", "BuildMI", "(", "*", "LongBrMBB", ",", "Pos", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "DADDiu", ")", ",", "Mips", "::", "SP_64", ")", ".", "addReg", "(", "Mips", "::", "SP_64", ")", ".", "addImm", "(", "-", "<NUM_LIT>", ")", ";", "BuildMI", "(", "*", "LongBrMBB", ",", "Pos", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "SD", ")", ")", ".", "addReg", "(", "Mips", "::", "RA_64", ")", ".", "addReg", "(", "Mips", "::", "SP_64", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "*", "LongBrMBB", ",", "Pos", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "LONG_BRANCH_DADDiu", ")", ",", "Mips", "::", "AT_64", ")", ".", "addReg", "(", "Mips", "::", "ZERO_64", ")", ".", "addMBB", "(", "TgtMBB", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addMBB", "(", "BalTgtMBB", ")", ";", "BuildMI", "(", "*", "LongBrMBB", ",", "Pos", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "DSLL", ")", ",", "Mips", "::", "AT_64", ")", ".", "addReg", "(", "Mips", "::", "AT_64", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "MIBundleBuilder", "(", "*", "LongBrMBB", ",", "Pos", ")", ".", "append", "(", "BuildMI", "(", "*", "MF", ",", "DL", ",", "TII", "->", "get", "(", "BalOp", ")", ")", ".", "addMBB", "(", "BalTgtMBB", ")", ")", ".", "append", "(", "BuildMI", "(", "*", "MF", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "LONG_BRANCH_DADDiu", ")", ",", "Mips", "::", "AT_64", ")", ".", "addReg", "(", "Mips", "::", "AT_64", ")", ".", "addMBB", "(", "TgtMBB", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addMBB", "(", "BalTgtMBB", ")", ")", ";", "Pos", "=", "BalTgtMBB", "->", "begin", "(", ")", ";", "BuildMI", "(", "*", "BalTgtMBB", ",", "Pos", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "DADDu", ")", ",", "Mips", "::", "AT_64", ")", ".", "addReg", "(", "Mips", "::", "RA_64", ")", ".", "addReg", "(", "Mips", "::", "AT_64", ")", ";", "BuildMI", "(", "*", "BalTgtMBB", ",", "Pos", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "LD", ")", ",", "Mips", "::", "RA_64", ")", ".", "addReg", "(", "Mips", "::", "SP_64", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "if", "(", "Subtarget", ".", "hasMips64r6", "(", ")", "&&", "!", "Subtarget", ".", "useIndirectJumpsHazard", "(", ")", ")", "BuildMI", "(", "*", "BalTgtMBB", ",", "Pos", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "JALR64", ")", ")", ".", "addReg", "(", "Mips", "::", "ZERO_64", ")", ".", "addReg", "(", "Mips", "::", "AT_64", ")", ";", "else", "{", "unsigned", "JROp", "=", "Subtarget", ".", "useIndirectJumpsHazard", "(", ")", "?", "(", "Subtarget", ".", "hasMips32r6", "(", ")", "?", "Mips", "::", "JR_HB64_R6", ":", "Mips", "::", "JR_HB64", ")", ":", "Mips", "::", "JR64", ";", "BuildMI", "(", "*", "BalTgtMBB", ",", "Pos", ",", "DL", ",", "TII", "->", "get", "(", "JROp", ")", ")", ".", "addReg", "(", "Mips", "::", "AT_64", ")", ";", "}", "BuildMI", "(", "*", "BalTgtMBB", ",", "Pos", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "DADDiu", ")", ",", "Mips", "::", "SP_64", ")", ".", "addReg", "(", "Mips", "::", "SP_64", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BalTgtMBB", "->", "rbegin", "(", ")", "->", "bundleWithPred", "(", ")", ";", "}", "assert", "(", "LongBrMBB", "->", "size", "(", ")", "+", "BalTgtMBB", "->", "size", "(", ")", "==", "LongBranchSeqSize", ")", ";", "}", "else", "{", "Pos", "=", "LongBrMBB", "->", "begin", "(", ")", ";", "LongBrMBB", "->", "addSuccessor", "(", "TgtMBB", ")", ";", "MIBundleBuilder", "(", "*", "LongBrMBB", ",", "Pos", ")", ".", "append", "(", "BuildMI", "(", "*", "MF", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "J", ")", ")", ".", "addMBB", "(", "TgtMBB", ")", ")", ".", "append", "(", "BuildMI", "(", "*", "MF", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "NOP", ")", ")", ")", ";", "assert", "(", "LongBrMBB", "->", "size", "(", ")", "==", "LongBranchSeqSize", ")", ";", "}", "if", "(", "I", ".", "Br", "->", "isUnconditionalBranch", "(", ")", ")", "{" ]

[ "{" ]

[ "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_operand", ":", "HF", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "]", "VCVT_SI_US_N", ")", "]", "<STR_LIT>" ]

[ "void", "MipsMCCodeEmitter", "::", "emitInstruction", "(", "uint64_t", "Val", ",", "unsigned", "Size", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "OS", ")", "const", "{", "if", "(", "IsLittleEndian", "&&", "Size", "==", "<NUM_LIT>", "&&", "isMicroMips", "(", "STI", ")", ")", "{", "emitInstruction", "(", "Val", ">>", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "STI", ",", "OS", ")", ";", "emitInstruction", "(", "Val", ",", "<NUM_LIT>", ",", "STI", ",", "OS", ")", ";", "}", "else", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "Size", ";", "++", "i", ")", "{", "unsigned", "Shift", "=", "IsLittleEndian", "?", "i", "*", "<NUM_LIT>", ":", "(", "Size", "-", "<NUM_LIT>", "-", "i", ")", "*", "<NUM_LIT>", ";", "EmitByte", "(", "(", "Val", ">>", "Shift", ")", "&", "<NUM_LIT>", ",", "OS", ")", ";", "}", "}", "}" ]

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

[ "}" ]

[ "field", "bits", "<", "<NUM_LIT>", ">", "SoftFail", "=", "<NUM_LIT>", ";", "let", "Size", "=", "<NUM_LIT>", ";", "dag", "OutOperandList", "=", "outs", ";", "dag", "InOperandList", "=", "ins", ";", "let", "Pattern", "=", "pattern", ";", "let", "Itinerary", "=", "itin", ";", "Format", "Form", "=", "form", ";", "field", "bits", "<", "<NUM_LIT>", ">", "ImmOpNo", "=", "<NUM_LIT>", ";", "field", "bits", "<", "<NUM_LIT>", ">", "ImmShift", "=", "<NUM_LIT>", ";", "bit", "ImmSigned", "=", "<NUM_LIT>", ";", "bit", "mayStall", "=", "<NUM_LIT>", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "mayStall", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "ImmSigned", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "ImmShift", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "ImmOpNo", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Form", ".", "Value", ";", "let", "DecoderNamespace", "=", "<STR_LIT>", ";" ]

[ "__xl_logf_finite", "<STR_LIT>", ",", "Op", ",", "DAG", ")", ";" ]

[ "return", "lowerLibCallBase", "(", "<STR_LIT>", "__xl_log", "<STR_LIT>", ",", "<STR_LIT>", "__xl_logf", "<STR_LIT>", ",", "<STR_LIT>", "__xl_log_finite", "<STR_LIT>", ",", "<STR_LIT>" ]

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

[ "[", "(", "set", "(", "strict_low_part", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "xor", ":", "HI", "(", "match_dup", "<NUM_LIT>", ")" ]

[ "<FIXS>", "void", "EmitFetchClause", "(", "MachineBasicBlock", "::", "iterator", "InsertPos", ",", "const", "DebugLoc", "&", "DL", ",", "ClauseFile", "&", "Clause", ",", "unsigned", "&", "CfCount", ")", "{", "<FIXE>", "<FIXS>", "BuildMI", "(", "BB", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "FETCH_CLAUSE", ")", ")", ".", "addImm", "(", "CfCount", ")", ";", "<FIXE>", "<FIXS>", "void", "EmitALUClause", "(", "MachineBasicBlock", "::", "iterator", "InsertPos", ",", "const", "DebugLoc", "&", "DL", ",", "ClauseFile", "&", "Clause", ",", "unsigned", "&", "CfCount", ")", "{", "<FIXE>", "<FIXS>", "BuildMI", "(", "BB", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "ALU_CLAUSE", ")", ")", ".", "addImm", "(", "CfCount", ")", ";", "<FIXE>" ]

[ "return", "ClauseFile", "(", "&", "ClauseHead", ",", "std", "::", "move", "(", "ClauseContent", ")", ")", ";", "}", "<BUGS>", "voidEmitFetchClause", "(", "MachineBasicBlock", "::", "iterator", "InsertPos", ",", "ClauseFile", "&", "Clause", ",", "unsigned", "&", "CfCount", ")", "{", "<BUGE>", "CounterPropagateAddr", "(", "*", "Clause", ".", "first", ",", "CfCount", ")", ";", "MachineBasicBlock", "*", "BB", "=", "Clause", ".", "first", "->", "getParent", "(", ")", ";", "<BUGS>", "BuildMI", "(", "BB", ",", "InsertPos", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "FETCH_CLAUSE", ")", ")", ".", "addImm", "(", "CfCount", ")", ";", "<BUGE>", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "Clause", ".", "second", ".", "size", "(", ")", ";", "i", "e", ";", "++", "i", ")", "{", "BB", "->", "splice", "(", "InsertPos", ",", "BB", ",", "Clause", ".", "second", "[", "i", "]", ")", ";", "}", "CfCount", "+=", "<NUM_LIT>", "*", "Clause", ".", "second", ".", "size", "(", ")", ";", "}", "<BUGS>", "voidEmitALUClause", "(", "MachineBasicBlock", "::", "iterator", "InsertPos", ",", "ClauseFile", "&", "Clause", ",", "unsigned", "&", "CfCount", ")", "{", "<BUGE>", "Clause", ".", "first", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setImm", "(", "<NUM_LIT>", ")", ";", "CounterPropagateAddr", "(", "*", "Clause", ".", "first", ",", "CfCount", ")", ";", "MachineBasicBlock", "*", "BB", "=", "Clause", ".", "first", "->", "getParent", "(", ")", ";", "<BUGS>", "BuildMI", "(", "BB", ",", "InsertPos", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "ALU_CLAUSE", ")", ")", ".", "addImm", "(", "CfCount", ")", ";", "<BUGE>", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "Clause", ".", "second", ".", "size", "(", ")", ";", "i", "e", ";", "++", "i", ")", "{", "BB", "->", "splice", "(", "InsertPos", ",", "BB", ",", "Clause", ".", "second", "[", "i", "]", ")", ";", "}" ]

[ "<NUM_LIT>", ";" ]

[ "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=" ]

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

[ "switch", "(", "DR", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "isUInt", "<", "<NUM_LIT>", ">", "(", "Val", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "isInt", "<", "<NUM_LIT>", ">", "(", "Val", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "isInt", "<", "<NUM_LIT>", ">", "(", "Val", ")", "&&", "isInt", "<", "<NUM_LIT>", ">", "(", "Val" ]

[ "}" ]

[ "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "AdrpOperand", ";" ]

[ ")", ";" ]

[ "SDValue", "VETargetLowering", "::", "legalizeInternalLoadStoreOp", "(", "SDValue", "Op", ",", "VECustomDAG", "&", "CDAG", ")", "const", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "::legalizeInternalLoadStoreOp\\n", "<STR_LIT>", ";", ")", ";", "MVT", "DataVT", "=", "getIdiomaticVectorType", "(", "Op", ".", "getNode", "(", ")", ")", "->", "getSimpleVT", "(", ")", ";", "if", "(", "isPackedVectorType", "(", "DataVT", ")", ")", "return", "splitPackedLoadStore", "(", "Op", ",", "CDAG", ")", ";", "return", "legalizePackedAVL", "(", "Op", ",", "CDAG" ]

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

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

[ ")", "{" ]

[ "}", "else", "{", "sparc_leaf_function_p", "=", "crtl", "->", "uses_only_leaf_regs", "=", "<NUM_LIT>", ";", "int_arg_first", "=", "SPARC_OUTGOING_INT_ARG_FIRST", ";", "}", "if", "(", "TARGET_ARCH64", "&&", "aggregate_value_p", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "function", ")", ")", ",", "function", ")", ")", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "int_arg_first", "+", "<NUM_LIT>", ")", ";", "else", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "int_arg_first", ")", ";", "if", "(", "delta", ")", "{", "rtx", "delta_rtx", "=", "GEN_INT", "(", "delta", ")", ";", "if", "(", "!", "SPARC_SIMM13_P", "(", "delta", ")", ")", "{", "rtx", "scratch", "=", "gen_rtx_REG", "(", "Pmode", ",", "<NUM_LIT>", ")", ";", "emit_move_insn", "(", "scratch", ",", "delta_rtx", ")", ";", "delta_rtx", "=", "scratch", ";", "}", "emit_insn", "(", "gen_add2_insn", "(", "this_rtx", ",", "delta_rtx", ")", ")", ";", "}", "if", "(", "vcall_offset", ")", "{", "rtx", "vcall_offset_rtx", "=", "GEN_INT", "(", "vcall_offset", ")", ";", "rtx", "scratch", "=", "gen_rtx_REG", "(", "Pmode", ",", "<NUM_LIT>", ")", ";", "gcc_assert", "(", "vcall_offset", "<", "<NUM_LIT>", ")", ";", "emit_move_insn", "(", "scratch", ",", "gen_rtx_MEM", "(", "Pmode", ",", "this_rtx", ")", ")", ";", "if", "(", "SPARC_SIMM13_P", "(", "vcall_offset", ")", ")", ";", "else", "if", "(", "!", "fixed_regs", "[", "<NUM_LIT>", "]", "&&", "vcall_offset", "<", "-", "<NUM_LIT>", ")", "{", "rtx", "scratch2", "=", "gen_rtx_REG", "(", "Pmode", ",", "<NUM_LIT>", ")", ";", "emit_move_insn", "(", "scratch2", ",", "vcall_offset_rtx", ")", ";", "vcall_offset_rtx", "=", "scratch2", ";", "}", "else", "{", "rtx", "increment", "=", "GEN_INT", "(", "-", "<NUM_LIT>", ")", ";", "while", "(", "!", "SPARC_SIMM13_P", "(", "vcall_offset", ")", ")", "{", "emit_insn", "(", "gen_add2_insn", "(", "scratch", ",", "increment", ")", ")", ";", "vcall_offset", "+=", "<NUM_LIT>", ";", "}", "vcall_offset_rtx", "=", "GEN_INT", "(", "vcall_offset", ")", ";", "}", "emit_move_insn", "(", "scratch", ",", "gen_rtx_MEM", "(", "Pmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "scratch", ",", "vcall_offset_rtx", ")", ")", ")", ";", "emit_insn", "(", "gen_add2_insn", "(", "this_rtx", ",", "scratch", ")", ")", ";", "}", "if", "(", "!", "TREE_USED", "(", "function", ")", ")", "{", "assemble_external", "(", "function", ")", ";", "TREE_USED", "(", "function", ")", "=", "<NUM_LIT>", ";", "}", "funexp", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "<NUM_LIT>", ")", ";", "if", "(", "flag_delayed_branch", ")", "{", "funexp", "=", "gen_rtx_MEM", "(", "FUNCTION_MODE", ",", "funexp", ")", ";", "insn", "=", "emit_call_insn", "(", "gen_sibcall", "(", "funexp", ")", ")", ";", "SIBLING_CALL_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "}", "else", "{", "rtx", "spill_reg", ",", "seq", ",", "scratch", "=", "gen_rtx_REG", "(", "Pmode", ",", "<NUM_LIT>", ")", ";", "if", "(", "flag_pic", ")", "{", "spill_reg", "=", "gen_rtx_REG", "(", "word_mode", ",", "<NUM_LIT>", ")", ";", "start_sequence", "(", ")", ";", "load_got_register", "(", ")", ";", "if", "(", "!", "TARGET_VXWORKS_RTP", ")", "pic_offset_table_rtx", "=", "got_register_rtx", ";", "scratch", "=", "sparc_legitimize_pic_address", "(", "funexp", ",", "scratch", ")", ";", "seq", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "emit_and_preserve", "(", "seq", ",", "spill_reg", ",", "pic_offset_table_rtx", ")", ";", "}", "else", "if", "(", "TARGET_ARCH32", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "scratch", ",", "gen_rtx_HIGH", "(", "SImode", ",", "funexp", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "scratch", ",", "gen_rtx_LO_SUM", "(", "SImode", ",", "scratch", ",", "funexp", ")", ")", ")", ";", "}", "else", "{", "switch", "(", "sparc_code_model" ]

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

[ "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isMoveImm", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "abs", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

[ "<FIXS>", "<STR_LIT>", "mt_function_arg_advance: words = %2d, mode = %4s, named = %d, size = %3d\\n", "<STR_LIT>", ",", "<FIXE>" ]

[ "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "<BUGS>", "<STR_LIT>", "ms1_function_arg_advance: words = %2d, mode = %4s, named = %d, size = %3d\\n", "<STR_LIT>", ",", "<BUGE>", "*", "cum", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "named", ",", "(", "*", "cum", ")", "*", "UNITS_PER_WORD", ")", ";", "}" ]

[ "<FIXS>", "if", "(", "Subtarget", "->", "TargetType", "==", "X86Subtarget", "::", "isDarwin", "&&", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC", ")", "<FIXE>" ]

[ "if", "(", "!", "isMemOp", ")", "O", "<<", "'", "$", "'", ";", "O", "<<", "PrivateGlobalPrefix", "<<", "<STR_LIT>", "CPI", "<STR_LIT>", "<<", "getFunctionNumber", "(", ")", "<<", "<STR_LIT>", "_", "<STR_LIT>", "<<", "MO", ".", "getConstantPoolIndex", "(", ")", ";", "<BUGS>", "if", "(", "forDarwin", "&&", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC", ")", "<BUGE>", "O", "<<", "<STR_LIT>", "-\\\"L", "<STR_LIT>", "<<", "getFunctionNumber", "(", ")", "<<", "<STR_LIT>", "$pb\\\"", "<STR_LIT>", ";", "int", "Offset", "=", "MO", ".", "getOffset", "(", ")", ";", "if", "(", "Offset", ">", "<NUM_LIT>", ")" ]

[ "Register", "XCoreRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "XCoreFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "}" ]

[ "Debug", "information", "queries", "." ]

[ "MachineOperand", "&", "HiOperand", "=", "IsI1Loreg", "?", "I2", "->", "getOperand", "(", "<NUM_LIT>", ")", ":" ]

[ "if", "(", "(", "MachineInstr", "*", ")", "MI", "==", "I2", ")", "++", "MI", ";", "unsigned", "I1DestReg", "=", "I1", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "I2DestReg", "=", "I2", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "bool", "IsI1Loreg", "=", "(", "I2DestReg", "-", "I1DestReg", ")", "==", "<NUM_LIT>", ";", "unsigned", "LoRegDef", "=", "IsI1Loreg", "?", "I1DestReg", ":", "I2DestReg", ";", "unsigned", "DoubleRegDest", "=", "TRI", "->", "getMatchingSuperReg", "(", "LoRegDef", ",", "Hexagon", "::", "subreg_loreg", ",", "&", "Hexagon", "::", "DoubleRegsRegClass", ")", ";", "assert", "(", "DoubleRegDest", "!=", "<NUM_LIT>", "&&", "<STR_LIT>", "Expect a valid register", "<STR_LIT>", ")", ";", "MachineOperand", "&", "LoOperand", "=", "IsI1Loreg", "?", "I1", "->", "getOperand", "(", "<NUM_LIT>", ")", ":", "I2", "->", "getOperand", "(", "<NUM_LIT>", ")", ";" ]

[ "<STR_LIT>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "pc", ")", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]" ]

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

[ "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "reg", "CC_REGNUM", ")" ]

[ "let", "isBranch", "=", "<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", "=", "<NUM_LIT>", ";" ]

[ ";" ]

[ "bool", "hasFlatLgkmVMemCountInOrder", "(", ")", "const", "{", "return", "getGeneration", "(", ")", ">", "GFX9" ]

[ "=", "itin", ";" ]

[ "list", "<", "dag", ">", "Pattern", "=", "[", "(", "set", "ROWD", ":", "$", "wd", ",", "(", "OpNode", "ROWS", ":", "$", "ws", ",", "Imm", ":", "$", "m", ")", ")", "]", ";", "InstrItinClass", "Itinerary" ]

[ "(", "match_dup", "<NUM_LIT>", ")", ")", ")" ]

[ "(", "define_insn_and_split", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "CC", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "compare", ":", "CC", "(", "and", ":", "GPR", "(", "match_operand", ":", "GPR", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "GPR", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_operand", ":", "GPR", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", ":", "GPR", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "clobber", "(", "match_scratch", ":", "CC", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "and", ":", "GPR", "(", "match_dup", "<NUM_LIT>", ")" ]

[ "bool", "AMDGPUAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "SetupMachineFunction", "(", "MF", ")", ";", "OutStreamer", ".", "emitRawComment", "(", "Twine", "(", "'", "@", "'", ")", "+", "MF", ".", "getName", "(", ")", "+", "Twine", "(", "'", ":", "'", ")", ")", ";", "MCContext", "&", "Context", "=", "getObjFileLowering", "(", ")", ".", "getContext", "(", ")", ";", "const", "MCSectionELF", "*", "ConfigSection", "=", "Context", ".", "getELFSection", "(", "<STR_LIT>", ".AMDGPU.config", "<STR_LIT>", ",", "ELF", "::", "SHT_PROGBITS", ",", "<NUM_LIT>", ",", "SectionKind", "::", "getReadOnly", "(", ")", ")", ";", "OutStreamer", ".", "SwitchSection", "(", "ConfigSection", ")", ";", "const", "AMDGPUSubtarget", "&", "STM", "=", "TM", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "SIProgramInfo", "KernelInfo", ";", "if", "(", "STM", ".", "getGeneration", "(", ")", ">", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "{", "getSIProgramInfo", "(", "KernelInfo", ",", "MF", ")", ";", "EmitProgramInfoSI", "(", "MF", ",", "KernelInfo", ")", ";", "}", "else", "{", "EmitProgramInfoR600", "(", "MF", ")", ";", "}", "DisasmLines", ".", "clear", "(", ")", ";", "HexLines", ".", "clear", "(", ")", ";", "DisasmLineMaxLen", "=", "<NUM_LIT>", ";", "OutStreamer", ".", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getTextSection", "(", ")", ")", ";", "EmitFunctionBody", "(", ")", ";", "if", "(", "isVerbose", "(", ")", ")", "{", "const", "MCSectionELF", "*", "CommentSection", "=", "Context", ".", "getELFSection", "(", "<STR_LIT>", ".AMDGPU.csdata", "<STR_LIT>", ",", "ELF", "::", "SHT_PROGBITS", ",", "<NUM_LIT>", ",", "SectionKind", "::", "getReadOnly", "(", ")", ")", ";", "OutStreamer", ".", "SwitchSection", "(", "CommentSection", ")", ";", "if", "(", "STM", ".", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", "{", "OutStreamer", ".", "emitRawComment", "(", "<STR_LIT>", " Kernel info:", "<STR_LIT>", ",", "false", ")", ";", "OutStreamer", ".", "emitRawComment", "(", "<STR_LIT>", " codeLenInByte = ", "<STR_LIT>", "+", "Twine", "(", "KernelInfo", ".", "CodeLen", ")", ",", "false", ")", ";", "OutStreamer", ".", "emitRawComment", "(", "<STR_LIT>", " NumSgprs: ", "<STR_LIT>", "+", "Twine", "(", "KernelInfo", ".", "NumSGPR", ")", ",", "false", ")", ";", "OutStreamer", ".", "emitRawComment", "(", "<STR_LIT>", " NumVgprs: ", "<STR_LIT>", "+", "Twine", "(", "KernelInfo", ".", "NumVGPR", ")", ",", "false", ")", ";", "OutStreamer", ".", "emitRawComment", "(", "<STR_LIT>", " FloatMode: ", "<STR_LIT>", "+", "Twine", "(", "KernelInfo", ".", "FloatMode", ")", ",", "false", ")", ";", "OutStreamer", ".", "emitRawComment", "(", "<STR_LIT>", " IeeeMode: ", "<STR_LIT>", "+", "Twine", "(", "KernelInfo", ".", "IEEEMode", ")", ",", "false", ")", ";", "}", "else", "{", "R600MachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "R600MachineFunctionInfo", ">", "(", ")", ";", "OutStreamer", ".", "emitRawComment", "(", "Twine", "(", "<STR_LIT>", "SQ_PGM_RESOURCES:STACK_SIZE = ", "<STR_LIT>", "+", "Twine", "(", "MFI", "->", "StackSize", ")", ")", ")", ";", "}", "}", "if", "(", "STM", ".", "dumpCode", "(", ")", ")", "{", "MF", ".", "dump", "(", ")", ";", "if", "(", "DisasmEnabled", ")", "{", "OutStreamer", ".", "SwitchSection", "(", "Context", ".", "getELFSection", "(", "<STR_LIT>", ".AMDGPU.disasm", "<STR_LIT>", ",", "ELF", "::", "SHT_NOTE", ",", "<NUM_LIT>", ",", "SectionKind", "::", "getReadOnly", "(", ")", ")", ")", ";", "for", "(", "size_t", "i", "=", "<NUM_LIT>", ";", "i", "<", "DisasmLines", ".", "size", "(", ")", ";", "++", "i", ")", "{", "std", "::", "string", "Comment", "(", "DisasmLineMaxLen", "-", "DisasmLines", "[", "i", "]", ".", "size", "(", ")", ",", "'", "'", ")", ";", "Comment", "+=", "<STR_LIT>", " ; ", "<STR_LIT>", "+", "HexLines", "[", "i", "]", "+", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "OutStreamer", ".", "EmitBytes", "(", "StringRef", "(", "DisasmLines", "[", "i", "]", ")", ")", ";", "OutStreamer", ".", "EmitBytes", "(", "StringRef", "(", "Comment", ")", ")", ";", "}", "}", "}", "return", "false", ";", "}" ]

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

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

[ "O", "<<", "<STR_LIT>", "\\tmr ", "<STR_LIT>", ";", "printOperand", "(", "MI", ",", "<NUM_LIT>", ",", "O", ")", ";", "O", "<<", "<STR_LIT>", ", ", "<STR_LIT>", ";", "printOperand", "(", "MI", ",", "<NUM_LIT>", ",", "O", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "O", ".", "str", "(", ")", ")", ";", "return", ";", "}", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "PPC", "::", "RLDICR", ")", "{", "unsigned", "char", "SH", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "unsigned", "char", "ME", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "if", "(", "<NUM_LIT>", "-", "SH", "==", "ME", ")", "{", "O", "<<", "<STR_LIT>", "\\tsldi ", "<STR_LIT>", ";", "printOperand", "(", "MI", ",", "<NUM_LIT>", ",", "O", ")", ";", "O", "<<", "<STR_LIT>", ", ", "<STR_LIT>", ";", "printOperand", "(", "MI", ",", "<NUM_LIT>", ",", "O", ")", ";", "O", "<<", "<STR_LIT>", ", ", "<STR_LIT>", "<<", "(", "unsigned", "int", ")", "SH", ";", "OutStreamer", ".", "EmitRawText", "(", "O", ".", "str", "(", ")", ")", ";", "return", ";", "}", "}", "printInstruction", "(", "MI", ",", "O", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "O", "." ]

[ "return", "MadeChange", ";" ]

[ "if", "(", "Buckets", ".", "empty", "(", ")", ")", "return", "MadeChange", ";", "SmallSet", "<", "BasicBlock", "*", ",", "<NUM_LIT>", ">", "BBChanged", ";", "for", "(", "auto", "&", "Bucket", ":", "Buckets", ")", "{", "if", "(", "prepareBasesForCommoningChains", "(", "Bucket", ")", ")", "MadeChange", "|=", "rewriteLoadStoresForCommoningChains", "(", "L", ",", "Bucket", ",", "BBChanged", ")", ";", "}", "if", "(", "MadeChange", ")", "for", "(", "auto", "*", "BB", ":", "BBChanged", ")", "DeleteDeadPHIs", "(", "BB", ")", ";" ]

[ "let", "Constraints", "=", "<STR_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "opc", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "imm4", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "pattern", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rdn", ";", "let", "AsmString", "=", "!", "if", "(", "!", "eq", "(", "opc", "{", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ",", "!", "strconcat", "(", "asm", ",", "<STR_LIT>", ")", ",", "!", "strconcat", "(", "asm", ",", "<STR_LIT>", ")", ")", ";" ]

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

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

[ "for", "(", "unsigned", "im", "=", "(", "unsigned", ")", "ISD", "::", "PRE_INC", ";" ]

[ "for", "(", "auto", "VT", ":", "FloatTypes", ")", "{", "addRegisterClass", "(", "VT", ",", "&", "ARM", "::", "MQPRRegClass", ")", ";", "if", "(", "!", "HasMVEFP", ")", "setAllExpand", "(", "VT", ")", ";", "setOperationAction", "(", "ISD", "::", "VECTOR_SHUFFLE", ",", "VT", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "INSERT_VECTOR_ELT", ",", "VT", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "INSERT_VECTOR_ELT", ",", "VT", ".", "getVectorElementType", "(", ")", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "VT", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "BUILD_VECTOR", ",", "VT", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "BUILD_VECTOR", ",", "VT", ".", "getVectorElementType", "(", ")", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "VT", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SETCC", ",", "VT", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "MLOAD", ",", "VT", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "MSTORE", ",", "VT", ",", "Legal", ")", ";", "for", "(", "unsigned", "im", "=", "(", "unsigned", ")", "ISD", "::", "PRE_INC", ";", "im", "!=", "(", "unsigned", ")", "ISD", "::", "LAST_INDEXED_MODE", ";", "++", "im", ")", "{", "setIndexedLoadAction", "(", "im", ",", "VT", ",", "Legal", ")", ";", "setIndexedStoreAction", "(", "im", ",", "VT", ",", "Legal", ")", ";", "}", "if", "(", "HasMVEFP", ")", "{", "setOperationAction", "(", "ISD", "::", "FMINNUM", ",", "VT", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "FMAXNUM", ",", "VT", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "FROUND", ",", "VT", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "FDIV", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FREM", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FSQRT", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FSIN", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FCOS", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FPOW", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FLOG", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FLOG2", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FLOG10", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FEXP", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FEXP2", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FNEARBYINT", ",", "VT", ",", "Expand", ")", ";", "}", "}", "const", "MVT", "LongTypes", "[", "]", "=", "{", "MVT", "::", "v2i64", ",", "MVT", "::", "v2f64", "}", ";", "for", "(", "auto", "VT", ":", "LongTypes", ")", "{", "addRegisterClass", "(", "VT", ",", "&", "ARM", "::", "MQPRRegClass", ")", ";", "setAllExpand", "(", "VT", ")", ";", "setOperationAction", "(", "ISD", "::", "INSERT_VECTOR_ELT", ",", "VT", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "VT", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "BUILD_VECTOR", ",", "VT", ",", "Custom", ")", ";", "}", "setOperationAction", "(", "ISD", "::", "AND", ",", "MVT", "::", "v2i64", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "OR", ",", "MVT", "::", "v2i64", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "XOR", ",", "MVT", "::", "v2i64", ",", "Legal", ")", ";", "addAllExtLoads", "(", "MVT", "::", "v8i16", ",", "MVT", "::", "v8i8", ",", "Legal", ")", ";", "addAllExtLoads", "(", "MVT", "::", "v4i32", ",", "MVT", "::", "v4i16", ",", "Legal", ")", ";", "addAllExtLoads", "(", "MVT", "::", "v4i32", ",", "MVT", "::", "v4i8", ",", "Legal", ")", ";", "setTruncStoreAction", "(", "MVT", "::", "v4i32", ",", "MVT", "::", "v4i16", ",", "Legal", ")", ";", "setTruncStoreAction", "(", "MVT", "::", "v4i32", ",", "MVT", "::", "v4i8", ",", "Legal", ")", ";", "setTruncStoreAction", "(", "MVT", "::", "v8i16", ",", "MVT", "::", "v8i8", ",", "Legal", ")", ";" ]

[ "MI", "->", "eraseFromParent", "(", ")", ";" ]

[ "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "TEST8rr", ")", ")", ".", "addReg", "(", "CountReg", ")", ".", "addReg", "(", "CountReg", ")", ";", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "JE_1", ")", ")", ".", "addMBB", "(", "EndMBB", ")", ";", "MBB", "->", "addSuccessor", "(", "EndMBB", ")", ";", "}", "assert", "(", "(", "MI", "->", "getNumOperands", "(", ")", "<=", "<NUM_LIT>", "||", "!", "MI", "->", "getOperand", "(", "MI", "->", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "||", "MI", "->", "getOperand", "(", "MI", "->", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "X86", "::", "EFLAGS", ")", "&&", "<STR_LIT>", "Expected last argument to be EFLAGS", "<STR_LIT>", ")", ";", "unsigned", "MOVOpc", "=", "Subtarget", "->", "hasFp256", "(", ")", "?", "X86", "::", "VMOVAPSmr", ":", "X86", "::", "MOVAPSmr", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "int64_t", "Offset", "=", "(", "i", "-", "<NUM_LIT>", ")", "*", "<NUM_LIT>", "+", "VarArgsFPOffset", ";", "MachineMemOperand", "*", "MMO", "=", "F", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "F", ",", "RegSaveFrameIndex", ",", "Offset", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "BuildMI", "(", "XMMSaveMBB", ",", "DL", ",", "TII", "->", "get", "(", "MOVOpc", ")", ")", ".", "addFrameIndex", "(", "RegSaveFrameIndex", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "Offset", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "i", ")", ".", "getReg", "(", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}" ]

[ "let", "prefersSlot3", "=", "<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", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";" ]

[ "<STR_LIT>", ")" ]

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

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

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

[ "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

[ "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_psraqi128_mask", "(", "(", "_", "_", "v2di", ")", "_", "_", "A", ",", "_", "_", "imm", ",", "(", "_", "_", "v2di", ")", "_", "_", "W", ",", "(" ]

[ "DONE" ]

[ "(", "zero_extend", ":", "<", "DWI", ">", "(", "match_operand", ":", "DWIH", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "ashift", ":", "<", "DWI", ">", "(", "zero_extend", ":", "<", "DWI", ">", "(", "match_operand", ":", "DWIH", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "<", "DWI", ">", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "clobber", "(", "const_int", "<NUM_LIT>", ")", ")", "]", "{", "split_double_concat", "(", "<", "DWI", ">", "mode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")" ]

[ "void", "HexagonEarlyIfConversion", "::", "removeBlock", "(", "MachineBasicBlock", "*", "B", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Removing block ", "<STR_LIT>", "<<", "PrintMB", "(", "B", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "MachineDomTreeNode", "*", "N", "=", "MDT", "->", "getNode", "(", "B", ")", ";", "MachineDomTreeNode", "*", "IDN", "=", "N", "->", "getIDom", "(", ")", ";", "if", "(", "IDN", ")", "{", "MachineBasicBlock", "*", "IDB", "=", "IDN", "->", "getBlock", "(", ")", ";", "using", "GTN", "=", "GraphTraits", "<", "MachineDomTreeNode", "*", ">", ";", "using", "DTNodeVectType", "=", "SmallVector", "<", "MachineDomTreeNode", "*", ",", "<NUM_LIT>", ">", ";", "DTNodeVectType", "Cn", "(", "GTN", "::", "child_begin", "(", "N", ")", ",", "GTN", "::", "child_end", "(", "N", ")", ")", ";", "for", "(", "auto", "&", "I", ":", "Cn", ")", "{", "MachineBasicBlock", "*", "SB", "=", "I", "->", "getBlock", "(", ")", ";", "MDT", "->", "changeImmediateDominator", "(", "SB", ",", "IDB", ")", ";", "}", "}", "while", "(", "!", "B", "->", "succ_empty", "(", ")", ")", "B", "->", "removeSuccessor", "(", "B", "->", "succ_begin", "(", ")", ")", ";", "for", "(", "MachineBasicBlock", "*", "Pred", ":", "B", "->", "predecessors", "(", ")", ")", "Pred", "->", "removeSuccessor", "(", "B", ",", "true", ")", ";", "Deleted", ".", "insert", "(", "B", ")", ";", "MDT", "->", "eraseNode", "(", "B", ")", ";", "MFN", "->", "erase", "(", "B", "->", "getIterator", "(", ")", ")", ";", "}" ]

[ "This", "method", "completely", "removes", "BB", "from", "all", "data", "structures", ",", "including", "all", "of", "the", "Loop", "objects", "it", "is", "nested", "in", "and", "our", "mapping", "from", "MachineBasicBlocks", "to", "loops", "." ]

[ "<STR_LIT>", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V2DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unsigned_float", ":", "V2DF", "(", "vec_select", ":", "V2SI", "(", "match_operand", ":", "V4SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "SW_AUTO_INC", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "SW_FORCE_SIGN0", "=", "<NUM_LIT>", ";", "int", "RM_DEFAULT", "=", "<NUM_LIT>", ";", "int", "RM_G1_RHNE", "=", "<NUM_LIT>", ";", "int", "RM_G1_RD", "=", "<NUM_LIT>", ";", "int", "RM_G1_RU", "=", "<NUM_LIT>", ";", "int", "RM_G1_SR", "=", "<NUM_LIT>", ";", "int", "CVT_G1_RZ", "=", "<NUM_LIT>", ";", "int", "RM_RHNE", "=", "<NUM_LIT>", ";", "int", "RM_RZ", "=", "<NUM_LIT>", ";", "int", "RM_RU", "=", "<NUM_LIT>", ";", "int", "RM_RD", "=", "<NUM_LIT>", ";", "int", "RM_SR", "=", "<NUM_LIT>", ";" ]

[ "let", "EncoderMethod", "=", "<STR_LIT>", ";" ]

[ "def", "move_vec_shift", ":", "Operand", "<", "i32", ">", "{", "let", "PrintMethod", "=", "<STR_LIT>", ";" ]

[ "::", "ssub_0", ":", "ARM", "::", "ssub_1", ")", ";" ]

[ "if", "(", "MI", "->", "definesRegister", "(", "DReg", ",", "TRI", ")", "||", "MI", "->", "readsRegister", "(", "DReg", ",", "TRI", ")", ")", "{", "ImplicitSReg", "=", "<NUM_LIT>", ";", "return", "true", ";", "}", "ImplicitSReg", "=", "TRI", "->", "getSubReg", "(", "DReg", ",", "(", "Lane", "&", "<NUM_LIT>", ")", "?", "ARM" ]

[ "<FIXS>", "[", "(", "set", "(", "match_operand", ":", "V8HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "V8HI", "[", "(", "match_operand", ":", "V8HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<FIXE>" ]

[ "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_insn", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "match_operand", ":", "V8HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "V8HI", "[", "(", "match_operand", ":", "V8HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<BUGE>", "UNSPEC_PHMINPOSUW", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

[ ")" ]

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

[ "<FIXS>", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<FIXE>", "<FIXS>", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<FIXE>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mult", ":", "DI", "(", "sign_extend", ":", "DI", "<BUGS>", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<BUGE>", "(", "sign_extend", ":", "DI", "<BUGS>", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "]", "<NUM_LIT>", ")", ")", "]", "<FIXE>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "<BUGS>", "(", "unspec", ":", "SI", "[", "<BUGE>", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "]", "<NUM_LIT>", ")", ")", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "(", "_", "_", "v16hi", ")", "_", "mm256_undefined_si256", "(", ")", ",", "(", "_", "_", "mmask16", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_ia32_pmovsdw512_mask", "(", "(", "_", "_", "v16si", ")", "_", "_", "A", "," ]

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

[ "void", "adds4_0ImmOperands", "(", "MCInst", "&", "Inst", ",", "unsigned", "N", ")", "const", "{", "addSignedImmOperands", "(", "Inst" ]

[ "}" ]

[ "switch", "(", "ET", ")", "{", "default", ":", "assert", "(", "false", "&&", "<STR_LIT>", "unhandled extend type!", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "uxtb", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "uxth", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "uxtw", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "uxtx", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "sxtb", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "sxth", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "sxtw", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "sxtx", "<STR_LIT>", ";" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rd", ";" ]

[ "<FIXS>", "void", "PPCInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "Register", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ",", "Register", "VReg", ")", "const", "{", "<FIXE>" ]

[ "NewMIs", ".", "back", "(", ")", "->", "addMemOperand", "(", "MF", ",", "MMO", ")", ";", "}", "<BUGS>", "void", "PPCInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "Register", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "<BUGE>" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "zero_extend", ":", "SI", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", ")", "<BUGE>", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

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

[ "def", "W14", ":", "ARM64Reg", "<", "<NUM_LIT>", ",", "<STR_LIT>", ">", ",", "DwarfRegNum", "<" ]

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

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

[ "?", "CalleeSavedRegsIntr", ":", "CalleeSavedRegs", ")", ";" ]

[ "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", ")", ";", "else", "return", "(", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "MSP430_INTR" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_maskz_cvtepi32_epi16", "(", "_", "_", "mmask8", "_", "_", "M", ",", "_", "_", "m128i", "_", "_", "A", ")", "{", "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_pmovdw128_mask", "(", "(", "_", "_", "v4si", ")", "_", "_", "A", ",", "(", "_", "_", "v8hi", ")", "_", "mm_avx512_setzero_si128", "(", ")", ",", "_", "_", "M", ")", ";" ]

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

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

[ "Reg", "=", "UseMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";" ]

[ "if", "(", "Register", "::", "isPhysicalRegister", "(", "Reg", ")", "||", "!", "MRI", "->", "hasOneNonDBGUse", "(", "Reg", ")", ")", "return", "Reg", ";", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "MachineInstr", "*", "UseMI", "=", "&", "*", "MRI", "->", "use_instr_nodbg_begin", "(", "Reg", ")", ";", "if", "(", "UseMI", "->", "getParent", "(", ")", "!=", "MBB", ")", "return", "Reg", ";", "while", "(", "UseMI", "->", "isCopy", "(", ")", "||", "UseMI", "->", "isInsertSubreg", "(", ")", ")", "{" ]

[ "bool", "ARMConstantIslands", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "mf", ")", "{", "MF", "=", "&", "mf", ";", "MCP", "=", "mf", ".", "getConstantPool", "(", ")", ";", "BBUtils", "=", "std", "::", "unique_ptr", "<", "ARMBasicBlockUtils", ">", "(", "new", "ARMBasicBlockUtils", "(", "mf", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "***** ARMConstantIslands: ", "<STR_LIT>", "<<", "MCP", "->", "getConstants", "(", ")", ".", "size", "(", ")", "<<", "<STR_LIT>", " CP entries, aligned to ", "<STR_LIT>", "<<", "MCP", "->", "getConstantPoolAlignment", "(", ")", "<<", "<STR_LIT>", " bytes *****\\n", "<STR_LIT>", ")", ";", "STI", "=", "&", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "MF", "->", "getSubtarget", "(", ")", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "isPositionIndependentOrROPI", "=", "STI", "->", "getTargetLowering", "(", ")", "->", "isPositionIndependent", "(", ")", "||", "STI", "->", "isROPI", "(", ")", ";", "AFI", "=", "MF", "->", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "DT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "isThumb", "=", "AFI", "->", "isThumbFunction", "(", ")", ";", "isThumb1", "=", "AFI", "->", "isThumb1OnlyFunction", "(", ")", ";", "isThumb2", "=", "AFI", "->", "isThumb2Function", "(", ")", ";", "HasFarJump", "=", "false", ";", "bool", "GenerateTBB", "=", "isThumb2", "||", "(", "isThumb1", "&&", "SynthesizeThumb1TBB", ")", ";", "MF", "->", "RenumberBlocks", "(", ")", ";", "bool", "MadeChange", "=", "false", ";", "if", "(", "GenerateTBB", "&&", "AdjustJumpTableBlocks", ")", "{", "scanFunctionJumpTables", "(", ")", ";", "MadeChange", "|=", "reorderThumb2JumpTables", "(", ")", ";", "T2JumpTables", ".", "clear", "(", ")", ";", "MF", "->", "RenumberBlocks", "(", ")", ";", "}", "std", "::", "vector", "<", "MachineInstr", "*", ">", "CPEMIs", ";", "if", "(", "!", "MCP", "->", "isEmpty", "(", ")", ")", "doInitialConstPlacement", "(", "CPEMIs", ")", ";", "if", "(", "MF", "->", "getJumpTableInfo", "(", ")", ")", "doInitialJumpTablePlacement", "(", "CPEMIs", ")", ";", "AFI", "->", "initPICLabelUId", "(", "CPEMIs", ".", "size", "(", ")", ")", ";", "initializeFunctionInfo", "(", "CPEMIs", ")", ";", "CPEMIs", ".", "clear", "(", ")", ";", "LLVM_DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "if", "(", "!", "T2JumpTables", ".", "empty", "(", ")", ")", "MF", "->", "ensureAlignment", "(", "Align", "(", "<NUM_LIT>", ")", ")", ";", "MadeChange", "|=", "removeUnusedCPEntries", "(", ")", ";", "unsigned", "NoCPIters", "=", "<NUM_LIT>", ",", "NoBRIters", "=", "<NUM_LIT>", ";", "while", "(", "true", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Beginning CP iteration #", "<STR_LIT>", "<<", "NoCPIters", "<<", "'", "\\n", "'", ")", ";", "bool", "CPChange", "=", "false", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "CPUsers", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "CPChange", "|=", "handleConstantPoolUser", "(", "i", ",", "NoCPIters", ">=", "CPMaxIteration", "/", "<NUM_LIT>", ")", ";", "if", "(", "CPChange", "&&", "++", "NoCPIters", ">", "CPMaxIteration", ")", "report_fatal_error", "(", "<STR_LIT>", "Constant Island pass failed to converge!", "<STR_LIT>", ")", ";", "LLVM_DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "NewWaterList", ".", "clear", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Beginning BR iteration #", "<STR_LIT>", "<<", "NoBRIters", "<<", "'", "\\n", "'", ")", ";", "bool", "BRChange", "=", "false", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "ImmBranches", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "BRChange", "|=", "fixupImmediateBr", "(", "ImmBranches", "[", "i", "]", ")", ";", "if", "(", "BRChange", "&&", "++", "NoBRIters", ">", "<NUM_LIT>", ")", "report_fatal_error", "(", "<STR_LIT>", "Branch Fix Up pass failed to converge!", "<STR_LIT>", ")", ";", "LLVM_DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "if", "(", "!", "CPChange", "&&", "!", "BRChange", ")", "break", ";", "MadeChange", "=", "true", ";", "}", "if", "(", "isThumb2", "&&", "!", "STI", "->", "prefers32BitThumb", "(", ")", ")", "MadeChange", "|=", "optimizeThumb2Instructions", "(", ")", ";", "if", "(", "isThumb", "&&", "STI", "->", "hasV8MBaselineOps", "(", ")", ")", "MadeChange", "|=", "optimizeThumb2Branches", "(", ")", ";", "if", "(", "GenerateTBB", "&&", "!", "STI", "->", "genExecuteOnly", "(", ")", ")", "MadeChange", "|=", "optimizeThumb2JumpTables", "(", ")", ";", "verify", "(", ")", ";", "if", "(", "isThumb", "&&", "!", "HasFarJump", "&&", "AFI", "->", "isLRSpilledForFarJump", "(", ")", ")", "MadeChange", "|=", "undoLRSpillRestore", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "CPEntries", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "for", "(", "unsigned", "j", "=", "<NUM_LIT>", ",", "je", "=", "CPEntries", "[", "i", "]", ".", "size", "(", ")", ";", "j", "!=", "je", ";", "++", "j", ")", "{", "const", "CPEntry", "&", "CPE", "=", "CPEntries", "[", "i", "]", "[", "j", "]", ";", "if", "(", "CPE", ".", "CPEMI", "&&", "CPE", ".", "CPEMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isCPI", "(", ")", ")", "AFI", "->", "recordCPEClone", "(", "i", ",", "CPE", ".", "CPI", ")", ";", "}", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "'", "\\n", "'", ";", "dumpBBs", "(", ")", ")", ";", "BBUtils", "->", "clear", "(", ")", ";", "WaterList", ".", "clear", "(", ")", ";", "CPUsers", ".", "clear", "(", ")", ";", "CPEntries", ".", "clear", "(", ")", ";", "JumpTableEntryIndices", ".", "clear", "(", ")", ";", "JumpTableUserIndices", ".", "clear", "(", ")", ";", "ImmBranches", ".", "clear", "(", ")", ";", "PushPopMIs", ".", "clear", "(", ")", ";", "T2JumpTables", ".", "clear", "(", ")", ";", "return", "MadeChange", ";", "}" ]

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

[ "<STR_LIT>", ")" ]

[ "(", "and", "(", "match_code" ]

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

[ "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "(", "ior", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "(", "and", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")" ]

[ ";" ]

[ "Op", "->", "Mem", ".", "Base", "=", "Base", ";", "Op", "->", "Mem", ".", "Index", "=", "Index", ";", "Op", "->", "Mem", ".", "Disp", "=", "Disp" ]

[ "<NUM_LIT>", ";" ]

[ "let", "isPredicateLate", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "LC0", ",", "P3", ",", "SA0", ",", "USR", "]", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=" ]

[ "VAddr", ",", "Offset", ",", "SLC", ")", ";" ]

[ "return", "SelectFlatOffset", "<", "true", ">", "(", "N", ",", "Addr", "," ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SFDF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "neg", ":", "SFDF", "(", "fma", ":", "SFDF", "(", "match_operand", ":", "SFDF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SFDF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SFDF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "minus", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "else", "return", "(", "<NUM_LIT>", ")", ";" ]

[ "_", "_", "c", "=", "(", "_", "_", "vector", "unsigned", "short", ")", "vec_splats", "(", "(", "unsigned", "short", ")", "_", "_", "count", ")", ";", "_", "_", "r", "=", "vec_sra", "(", "_", "_", "r", ",", "(", "_", "_", "vector", "unsigned", "short", ")", "_", "_", "c", ")", ";", "return", "(", "_", "_", "m64", ")", "(", "(", "_", "_", "vector", "long", "long", ")", "_", "_", "r", ")", "[", "<NUM_LIT>", "]", ";", "}" ]

[ "Has3r1E3r2", "=", "false", ";" ]

[ "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "<STR_LIT>", "generic", "<STR_LIT>", ";", "if", "(", "TuneCPUName", ".", "empty", "(", ")", ")", "TuneCPUName", "=", "CPUName", ";", "HasE1", "=", "false", ";", "HasE2", "=", "false", ";", "Has2E3", "=", "false", ";", "HasMP", "=", "false", ";", "Has3E3r1", "=", "false", ";" ]

[ ":", "$", "ws", ",", "Imm", ":", "$", "m", ")", ")", "]", ";" ]

[ "class", "MSA_BIT_D_DESC_BASE", "<", "string", "instr_asm", ",", "SDPatternOperator", "OpNode", ",", "ComplexPattern", "Imm", ",", "RegisterOperand", "ROWD", ",", "RegisterOperand", "ROWS", "=", "ROWD", ",", "InstrItinClass", "itin", "=", "NoItinerary", ">", "{", "dag", "OutOperandList", "=", "(", "outs", "ROWD", ":", "$", "wd", ")", ";", "dag", "InOperandList", "=", "(", "ins", "ROWS", ":", "$", "ws", ",", "vsplat_uimm6", ":", "$", "m", ")", ";", "string", "AsmString", "=", "!", "strconcat", "(", "instr_asm", ",", "<STR_LIT>", ")", ";", "list", "<", "dag", ">", "Pattern", "=", "[", "(", "set", "ROWD", ":", "$", "wd", ",", "(", "OpNode", "ROWS" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "Ii", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Ii", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Pv4", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Pv4", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Vd32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Vd32", "{", "<NUM_LIT>" ]

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

[ "def", "A2_svadduhs", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "IntRegs", ":", "$", "Rt32", ")", ",", "<STR_LIT>", ",", "tc_61830035", ",", "TypeALU32_3op", ">", ",", "Enc_5ab2be", "{", "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", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "prefersSlot3", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "USR_OVF", "]", ";", "let", "InputType", "=", "<STR_LIT>", ";" ]

[ "<FIXS>", "put_condition_code", "(", "enum", "rtx_code", "code", ",", "machine_mode", "mode", ",", "bool", "reverse", ",", "<FIXE>" ]

[ "}", "static", "void", "<BUGS>", "put_condition_code", "(", "enum", "rtx_code", "code", ",", "enum", "machine_mode", "mode", ",", "bool", "reverse", ",", "<BUGE>", "bool", "fp", ",", "FILE", "*", "file", ")", "{", "const", "char", "*", "suffix", ";" ]

[ "bool", "ARMAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "unsigned", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "MatchResult", ";", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "if", "(", "validateInstruction", "(", "Inst", ",", "Operands", ")", ")", "{", "forwardITPosition", "(", ")", ";", "return", "true", ";", "}", "{", "bool", "wasInITBlock", "=", "inITBlock", "(", ")", ";", "while", "(", "processInstruction", "(", "Inst", ",", "Operands", ")", ")", ";", "if", "(", "wasInITBlock", "&&", "hasV8Ops", "(", ")", "&&", "isThumb", "(", ")", "&&", "!", "isV8EligibleForIT", "(", "&", "Inst", ")", ")", "{", "Warning", "(", "IDLoc", ",", "<STR_LIT>", "deprecated instruction in IT block", "<STR_LIT>", ")", ";", "}", "}", "forwardITPosition", "(", ")", ";", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "ARM", "::", "ITasm", ")", "return", "false", ";", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "{", "assert", "(", "ErrorInfo", "&&", "<STR_LIT>", "Unknown missing feature!", "<STR_LIT>", ")", ";", "std", "::", "string", "Msg", "=", "<STR_LIT>", "instruction requires:", "<STR_LIT>", ";", "unsigned", "Mask", "=", "<NUM_LIT>", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "(", "sizeof", "(", "ErrorInfo", ")", "*", "<NUM_LIT>", "-", "<NUM_LIT>", ")", ";", "++", "i", ")", "{", "if", "(", "ErrorInfo", "&", "Mask", ")", "{", "Msg", "+=", "<STR_LIT>", "<STR_LIT>", ";", "Msg", "+=", "getSubtargetFeatureName", "(", "ErrorInfo", "&", "Mask", ")", ";", "}", "Mask", "<<=", "<NUM_LIT>", ";", "}", "return", "Error", "(", "IDLoc", ",", "Msg", ")", ";", "}", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "<NUM_LIT>", "U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "too few operands for instruction", "<STR_LIT>", ")", ";", "ErrorLoc", "=", "(", "(", "ARMOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "<STR_LIT>", "invalid operand for instruction", "<STR_LIT>", ")", ";", "}", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "invalid instruction", "<STR_LIT>", ",", "(", "(", "ARMOperand", "*", ")", "Operands", "[", "<NUM_LIT>", "]", ")", "->", "getLocRange", "(", ")", ")", ";", "case", "Match_RequiresNotITBlock", ":", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "flag setting instruction only valid outside IT block", "<STR_LIT>", ")", ";", "case", "Match_RequiresITBlock", ":", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "instruction only valid inside IT block", "<STR_LIT>", ")", ";", "case", "Match_RequiresV6", ":", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "instruction variant requires ARMv6 or later", "<STR_LIT>", ")", ";", "case", "Match_RequiresThumb2", ":", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "instruction variant requires Thumb2", "<STR_LIT>", ")", ";", "case", "Match_ImmRange0_15", ":", "{", "SMLoc", "ErrorLoc", "=", "(", "(", "ARMOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "return", "Error", "(", "ErrorLoc", ",", "<STR_LIT>", "immediate operand must be in the range [0,15]", "<STR_LIT>", ")", ";", "}", "case", "Match_ImmRange0_239", ":", "{", "SMLoc", "ErrorLoc", "=", "(", "(", "ARMOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "return", "Error", "(", "ErrorLoc", ",", "<STR_LIT>", "immediate operand must be in the range [0,239]", "<STR_LIT>", ")", ";", "}", "}", "llvm_unreachable", "(", "<STR_LIT>", "Implement any new match types added!", "<STR_LIT>", ")", ";", "}" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

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

[ "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]

[ "<STR_LIT>" ]

[ "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "not", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]" ]

[ "bool", "contains", "(", "int32_t", "V", ")", "const", "{", "return", "Min", "<=", "V", "&&", "V", "<=", "Max", "&&", "(", "V", "%", "Align", ")", "==", "<NUM_LIT>", ";", "}" ]

[ "contains", "-", "Returns", "true", "if", "this", "trace", "contains", "the", "given", "basic", "block", "." ]

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

[ "static", "void", "ensurePromotedGV", "(", "Function", "&", "F", ",", "Constant", "&", "C", ",", "AArch64PromoteConstant", "::", "PromotedConstant", "&", "PC", ")", "{", "assert", "(", "PC", ".", "ShouldConvert", "&&", "<STR_LIT>", "Expected that we should convert this to a global", "<STR_LIT>", ")", ";", "if", "(", "PC", ".", "GV", ")", "return", ";", "PC", ".", "GV", "=", "new", "GlobalVariable", "(", "*", "F", ".", "getParent", "(", ")", ",", "C", ".", "getType", "(", ")", ",", "true", ",", "GlobalValue", "::", "InternalLinkage", ",", "nullptr", ",", "<STR_LIT>", "_PromotedConst", "<STR_LIT>", ",", "nullptr", ",", "GlobalVariable", "::", "NotThreadLocal", ")", ";", "PC", ".", "GV", "->", "setInitializer", "(", "&", "C", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Global replacement: " ]

[ "EVT", "N00VT", "=", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ";" ]

[ "static", "SDValue", "combineExtSetcc", "(", "SDNode", "*", "N", ",", "SelectionDAG", "&", "DAG", ",", "const", "X86Subtarget", "&", "Subtarget", ")", "{", "SDValue", "N0", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "SDLoc", "dl", "(", "N", ")", ";", "if", "(", "!", "Subtarget", ".", "hasAVX512", "(", ")", "||", "!", "VT", ".", "isVector", "(", ")", "||", "N0", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "SETCC", ")", "return", "SDValue", "(", ")", ";", "EVT", "SVT", "=", "VT", ".", "getVectorElementType", "(", ")", ";", "if", "(", "SVT", "!=", "MVT", "::", "i8", "&&", "SVT", "!=", "MVT", "::", "i16", "&&", "SVT", "!=", "MVT", "::", "i32", "&&", "SVT", "!=", "MVT", "::", "i64", "&&", "SVT", "!=", "MVT", "::", "f32", "&&", "SVT", "!=", "MVT", "::", "f64", ")", "return", "SDValue", "(", ")", ";", "unsigned", "Size", "=", "VT", ".", "getSizeInBits", "(", ")", ";", "if", "(", "Size", ">", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "ISD", "::", "CondCode", "CC", "=", "cast", "<", "CondCodeSDNode", ">", "(", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "get", "(", ")", ";", "if", "(", "ISD", "::", "isUnsignedIntSetCC", "(", "CC", ")", ")", "return", "SDValue", "(", ")", ";" ]

[ "<STR_LIT>", ")" ]

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

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

[ "}", "Insn", ".", "operands", "=", "x86OperandSets", "[", "Insn", ".", "spec", "->", "operands", "]", ";", "Insn", ".", "length", "=", "Insn", ".", "readerCursor", "-", "Insn", ".", "startLocation", ";", "Size", "=", "Insn", ".", "length", ";", "if", "(", "Size", ">", "<NUM_LIT>", ")", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Instruction exceeds 15-byte limit", "<STR_LIT>", ")", ";", "bool", "Ret", "=", "translateInstruction", "(", "Instr", ",", "Insn", ",", "this", ")", ";", "if", "(", "!", "Ret", ")", "{", "unsigned", "Flags", "=", "X86", "::", "IP_NO_PREFIX", ";", "if", "(", "Insn", ".", "hasAdSize", ")", "Flags", "|=", "X86", "::", "IP_HAS_AD_SIZE", ";", "if", "(", "!", "Insn", ".", "mandatoryPrefix", ")", "{", "if", "(", "Insn", ".", "hasOpSize", ")", "Flags", "|=", "X86", "::", "IP_HAS_OP_SIZE", ";", "if", "(", "Insn", ".", "repeatPrefix", "==", "<NUM_LIT>", ")", "Flags", "|=", "X86", "::", "IP_HAS_REPEAT_NE", ";", "else", "if", "(", "Insn", ".", "repeatPrefix", "==", "<NUM_LIT>", "&&", "Insn", ".", "opcode", "!=", "<NUM_LIT>", ")", "Flags", "|=", "X86", "::", "IP_HAS_REPEAT", ";", "if", "(", "Insn", ".", "hasLockPrefix", ")", "Flags", "|=", "X86", "::", "IP_HAS_LOCK", ";", "}", "Instr", ".", "setFlags" ]

[ "<FIXS>", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<FIXE>", "<FIXS>", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<NUM_LIT>", ")", ")", ")", "<FIXE>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "ior", ":", "DI", "(", "ashift", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")", "<BUGS>", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "<BUGE>", "(", "subreg", ":", "DI", "(", "lshiftrt", ":", "TI", "(", "zero_extend", ":", "TI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<BUGS>", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "<NUM_LIT>", ")", ")", ")", "<BUGE>", "(", "clobber", "(", "reg", ":", "CC", "FLAGS_REG", ")", ")", "]", "<STR_LIT>" ]

[ "}" ]

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

[ "}" ]

[ "alignment", "=", "type", "?", "TYPE_ALIGN", "(", "type", ")", ":", "GET_MODE_ALIGNMENT", "(", "mode", ")", ";", "if", "(", "alignment", "<", "PARM_BOUNDARY", ")", "alignment", "=", "PARM_BOUNDARY", ";", "if", "(", "alignment", ">", "STACK_BOUNDARY", ")", "alignment", "=", "STACK_BOUNDARY", ";", "return", "alignment", ";" ]

[ "(", "<NUM_LIT>", "-", "Imm", ")", ")", ";" ]

[ "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm" ]

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

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

[ ")", "]" ]

[ "(", "sign_extend", ":", "DI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "R_FLAGS", ")", ")", "]", ")", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "ashiftrt", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "R_FLAGS", ")", ")", "]" ]

[ "}" ]

[ "num", "+=", "(", "length", "+", "nelt", "-", "<NUM_LIT>", ")", "/", "nelt", ";", "if", "(", "!", "unaligned_p", "&&", "(", "length", "&", "<NUM_LIT>", ")", "!=", "<NUM_LIT>", ")", "num", "++", ";", "if", "(", "!", "unaligned_p", "&&", "mode", "==", "V16QImode", ")", "num", "--", ";", "return", "(", "num", "<=", "arm_block_set_max_insns", "(", ")", ")", ";" ]

[ "if", "(", "HexagonMCInstrInfo", "::", "getDesc", "(", "MCII", ",", "ID", ")", ".", "isBranch", "(", ")", ")", "Summary", ".", "branchInsts", ".", "push_back", "(", "ISJ", ")", ";" ]

[ "if", "(", "HexagonMCInstrInfo", "::", "IsABranchingInst", "(", "MCII", ",", "STI", ",", "*", "ISJ", "->", "ID", ")", ")", "Summary", ".", "branchInsts", ".", "push_back", "(", "ISJ", ")", ";", "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>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "++", "Summary", ".", "NonZCVIloads", ";", "LLVM_FALLTHROUGH", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "++", "Summary", ".", "AllCVIloads", ";", "LLVM_FALLTHROUGH", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "++", "Summary", ".", "loads", ";", "++", "Summary", ".", "memory", ";", "if", "(", "ISJ", "->", "Core", ".", "getUnits", "(", ")", "==", "slotSingleLoad", "||", "HexagonMCInstrInfo", "::", "getType", "(", "MCII", ",", "ID", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "++", "Summary", ".", "load0", ";", "if", "(", "HexagonMCInstrInfo", "::", "getDesc", "(", "MCII", ",", "ID", ")", ".", "isReturn", "(", ")", ")", "Summary", ".", "branchInsts", ".", "push_back", "(", "ISJ", ")", ";", "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>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "++", "Summary", ".", "CVIstores", ";", "LLVM_FALLTHROUGH", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "++", "Summary", ".", "stores", ";", "++", "Summary", ".", "memory", ";", "if", "(", "ISJ", "->", "Core", ".", "getUnits", "(", ")", "==", "slotSingleStore", "||", "HexagonMCInstrInfo", "::", "getType", "(", "MCII", ",", "ID", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "++", "Summary", ".", "store0", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "++", "Summary", ".", "loads", ";", "++", "Summary", ".", "stores", ";", "++", "Summary", ".", "store1", ";", "++", "Summary", ".", "memops", ";", "++", "Summary", ".", "memory", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "++", "Summary", ".", "memory", ";", "Summary", ".", "branchInsts", ".", "push_back", "(", "ISJ", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "if", "(", "HexagonMCInstrInfo", "::", "getDesc", "(", "MCII", ",", "ID", ")", ".", "mayLoad", "(", ")", ")", "{", "++", "Summary", ".", "loads", ";", "++", "Summary", ".", "memory", ";", "if", "(", "ISJ", "->", "Core", ".", "getUnits", "(", ")", "==", "slotSingleLoad", "||", "HexagonMCInstrInfo", "::", "getType", "(", "MCII", ",", "ID", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "++", "Summary", ".", "load0", ";", "}", "else", "{", "assert", "(", "HexagonMCInstrInfo", "::", "getDesc", "(", "MCII", ",", "ID", ")", ".", "mayStore", "(", ")", ")", ";", "++", "Summary", ".", "memory", ";", "++", "Summary", ".", "stores", ";", "}", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":" ]

[ ")", ";" ]

[ "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R13", ")", ";", "}", "if", "(", "Subtarget", ".", "isAIXABI", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R2", ")", ";", "if", "(", "TM", ".", "isPPC64", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R13", ")", ";", "if", "(", "TFI", "->", "needsFP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R31", ")", ";", "bool", "IsPositionIndependent", "=", "TM", ".", "isPositionIndependent", "(", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "{", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", "&&", "!", "TM", ".", "isPPC64", "(", ")", "&&", "IsPositionIndependent", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R29", ")", ";", "else", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R30", ")", ";", "}", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", "&&", "!", "TM", ".", "isPPC64", "(", ")", "&&", "IsPositionIndependent", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R30", ")", ";", "if", "(", "!", "Subtarget", ".", "hasAltivec", "(", ")", ")", "for", "(", "TargetRegisterClass", "::", "iterator", "I", "=", "PPC", "::", "VRRCRegClass", ".", "begin", "(", ")", ",", "IE", "=", "PPC", "::", "VRRCRegClass", ".", "end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "markSuperRegs", "(", "Reserved", ",", "*", "I", ")", ";", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")" ]

[ "use", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "mask", ")", ";" ]

[ "if", "(", "use_sse", ")", "mask", "=", "ix86_build_signbit_mask", "(", "vmode", ",", "vector_mode", ",", "code", "==", "ABS", ")", ";", "else", "mask", "=", "NULL_RTX", ";", "dst", "=", "operands", "[", "<NUM_LIT>", "]", ";", "src", "=", "operands", "[", "<NUM_LIT>", "]", ";", "set", "=", "gen_rtx_fmt_e", "(", "code", ",", "mode", ",", "src", ")", ";", "set", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "dst", ",", "set", ")", ";", "if", "(", "mask", ")", "{", "rtx", "use", ",", "clob", ";", "rtvec", "par", ";" ]

[ "static", "void", "mips_for_each_saved_acc", "(", "HOST_WIDE_INT", "sp_offset", ",", "mips_save_restore_fn", "fn", ")", "{", "HOST_WIDE_INT", "offset", ";", "int", "regno", ";", "offset", "=", "cfun", "->", "machine", "->", "frame", ".", "acc_sp_offset", "-", "sp_offset", ";", "if", "(", "BITSET_P", "(", "cfun", "->", "machine", "->", "frame", ".", "acc_mask", ",", "<NUM_LIT>", ")", ")", "{", "mips_save_restore_reg", "(", "word_mode", ",", "LO_REGNUM", ",", "offset", ",", "fn", ")", ";", "offset", "-=", "UNITS_PER_WORD", ";", "mips_save_restore_reg", "(", "word_mode", ",", "HI_REGNUM", ",", "offset", ",", "fn", ")", ";", "offset", "-=", "UNITS_PER_WORD", ";", "}", "for", "(", "regno", "=", "DSP_ACC_REG_FIRST", ";", "regno", "<=", "DSP_ACC_REG_LAST", ";", "regno", "++", ")", "if", "(", "BITSET_P", "(", "cfun", "->", "machine", "->", "frame", ".", "acc_mask", ",", "(", "(", "regno", "-", "DSP_ACC_REG_FIRST", ")", "/", "<NUM_LIT>", ")", "+", "<NUM_LIT>", ")", ")", "{", "mips_save_restore_reg", "(", "word_mode", ",", "regno", ",", "offset", ",", "fn", ")", ";", "offset", "-=", "UNITS_PER_WORD", ";", "}", "}" ]

[ "Call", "FN", "for", "each", "accumlator", "that", "is", "saved", "by", "the", "current", "function", ".", "SP_OFFSET", "is", "the", "offset", "of", "the", "current", "stack", "pointer", "from", "the", "start", "of", "the", "frame", "." ]

[ ")", "]" ]

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

[ "if", "(", "!", "CE", ")", "{" ]

[ "}", "StringRef", "ShiftName", "=", "Tok", ".", "getString", "(", ")", ";", "bool", "isASR", ";", "if", "(", "ShiftName", "==", "<STR_LIT>", "lsl", "<STR_LIT>", "||", "ShiftName", "==", "<STR_LIT>", "LSL", "<STR_LIT>", ")", "isASR", "=", "false", ";", "else", "if", "(", "ShiftName", "==", "<STR_LIT>", "asr", "<STR_LIT>", "||", "ShiftName", "==", "<STR_LIT>", "ASR", "<STR_LIT>", ")", "isASR", "=", "true", ";", "else", "{", "Error", "(", "S", ",", "<STR_LIT>", "shift operator 'asr' or 'lsl' expected", "<STR_LIT>", ")", ";", "return", "MatchOperand_ParseFail", ";", "}", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "isNot", "(", "AsmToken", "::", "Hash", ")", "&&", "Parser", ".", "getTok", "(", ")", ".", "isNot", "(", "AsmToken", "::", "Dollar", ")", ")", "{", "Error", "(", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ",", "<STR_LIT>", "'#' expected", "<STR_LIT>", ")", ";", "return", "MatchOperand_ParseFail", ";", "}", "Parser", ".", "Lex", "(", ")", ";", "SMLoc", "ExLoc", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "const", "MCExpr", "*", "ShiftAmount", ";", "SMLoc", "EndLoc", ";", "if", "(", "getParser", "(", ")", ".", "ParseExpression", "(", "ShiftAmount", ",", "EndLoc", ")", ")", "{", "Error", "(", "ExLoc", ",", "<STR_LIT>", "malformed shift expression", "<STR_LIT>", ")", ";", "return", "MatchOperand_ParseFail", ";", "}", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "ShiftAmount", ")", ";" ]

[ ";" ]

[ "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>" ]

[ "}" ]

[ "static", "_", "_", "inline", "void", "_", "_", "attribute__", "(", "(", "_", "_", "always_inline__", ")", ")", "_", "mm_store_ps1", "(", "float", "*", "_", "_", "P", ",", "_", "_", "m128", "_", "_", "A", ")", "{", "_", "mm_store1_ps", "(", "_", "_", "P", ",", "_", "_", "A", ")", ";" ]

[ "<FIXS>", "if", "(", "!", "trySkipToken", "(", "AsmToken", "::", "Comma", ")", ")", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "if", "(", "!", "trySkipToken", "(", "AsmToken", "::", "Comma", ")", ")", "<FIXE>", "<FIXS>", "if", "(", "!", "parseString", "(", "VendorName", ",", "<STR_LIT>", "invalid vendor name", "<STR_LIT>", ")", ")", "return", "true", ";", "<FIXE>", "<FIXS>", "if", "(", "!", "trySkipToken", "(", "AsmToken", "::", "Comma", ")", ")", "<FIXE>", "<FIXS>", "if", "(", "!", "parseString", "(", "ArchName", ",", "<STR_LIT>", "invalid arch name", "<STR_LIT>", ")", ")", "return", "true", ";", "<FIXE>" ]

[ "if", "(", "ParseDirectiveMajorMinor", "(", "Major", ",", "Minor", ")", ")", "return", "true", ";", "<BUGS>", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "Comma", ")", ")", "<BUGE>", "return", "TokError", "(", "<STR_LIT>", "stepping version number required, comma expected", "<STR_LIT>", ")", ";", "<BUGS>", "Lex", "(", ")", ";", "<BUGE>", "if", "(", "ParseAsAbsoluteExpression", "(", "Stepping", ")", ")", "return", "TokError", "(", "<STR_LIT>", "invalid stepping version", "<STR_LIT>", ")", ";", "<BUGS>", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "Comma", ")", ")", "<BUGE>", "return", "TokError", "(", "<STR_LIT>", "vendor name required, comma expected", "<STR_LIT>", ")", ";", "<BUGS>", "Lex", "(", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "String", ")", ")", "return", "TokError", "(", "<STR_LIT>", "invalid vendor name", "<STR_LIT>", ")", ";", "VendorName", "=", "getLexer", "(", ")", ".", "getTok", "(", ")", ".", "getStringContents", "(", ")", ";", "Lex", "(", ")", ";", "<BUGE>", "<BUGS>", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "Comma", ")", ")", "<BUGE>", "return", "TokError", "(", "<STR_LIT>", "arch name required, comma expected", "<STR_LIT>", ")", ";", "<BUGS>", "Lex", "(", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "String", ")", ")", "return", "TokError", "(", "<STR_LIT>", "invalid arch name", "<STR_LIT>", ")", ";", "ArchName", "=", "getLexer", "(", ")", ".", "getTok", "(", ")", ".", "getStringContents", "(", ")", ";", "Lex", "(", ")", ";", "<BUGE>", "getTargetStreamer", "(", ")", ".", "EmitDirectiveHSACodeObjectISA", "(", "Major", ",", "Minor", ",", "Stepping", ",", "VendorName", ",", "ArchName", ")", ";" ]

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

[ "(", "define_code_attr", "su_optab", "[", "(", "fix", "<STR_LIT>" ]

[ "static", "void", "s390_chunkify_cancel", "(", "struct", "constant_pool", "*", "pool_list", ")", "{", "struct", "constant_pool", "*", "curr_pool", "=", "NULL", ";", "rtx", "insn", ";", "for", "(", "curr_pool", "=", "pool_list", ";", "curr_pool", ";", "curr_pool", "=", "curr_pool", "->", "next", ")", "{", "rtx", "barrier", "=", "PREV_INSN", "(", "curr_pool", "->", "pool_insn", ")", ";", "rtx", "jump", "=", "barrier", "?", "PREV_INSN", "(", "barrier", ")", ":", "NULL_RTX", ";", "rtx", "label", "=", "NEXT_INSN", "(", "curr_pool", "->", "pool_insn", ")", ";", "if", "(", "jump", "&&", "GET_CODE", "(", "jump", ")", "==", "JUMP_INSN", "&&", "barrier", "&&", "GET_CODE", "(", "barrier", ")", "==", "BARRIER", "&&", "label", "&&", "GET_CODE", "(", "label", ")", "==", "CODE_LABEL", "&&", "GET_CODE", "(", "PATTERN", "(", "jump", ")", ")", "==", "SET", "&&", "SET_DEST", "(", "PATTERN", "(", "jump", ")", ")", "==", "pc_rtx", "&&", "GET_CODE", "(", "SET_SRC", "(", "PATTERN", "(", "jump", ")", ")", ")", "==", "LABEL_REF", "&&", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "jump", ")", ")", ",", "<NUM_LIT>", ")", "==", "label", ")", "{", "remove_insn", "(", "jump", ")", ";", "remove_insn", "(", "barrier", ")", ";", "remove_insn", "(", "label", ")", ";", "}", "remove_insn", "(", "curr_pool", "->", "pool_insn", ")", ";", "}", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", ")", "{", "rtx", "next_insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "insn", ")", "==", "INSN", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SET", "&&", "GET_CODE", "(", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ")", "==", "UNSPEC", "&&", "XINT", "(", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ",", "<NUM_LIT>", ")", "==", "UNSPEC_RELOAD_BASE", ")", "remove_insn", "(", "insn", ")", ";", "insn", "=", "next_insn", ";", "}", "while", "(", "pool_list", ")", "{", "struct", "constant_pool", "*", "next", "=", "pool_list", "->", "next", ";", "s390_free_pool", "(", "pool_list", ")", ";", "pool_list", "=", "next", ";", "}", "}" ]

[ "POOL_LIST", "is", "a", "chunk", "list", "as", "prepared", "by", "s390_chunkify_start", ".", "We", "have", "decided", "we", "can", "not", "use", "this", "list", ",", "so", "revert", "all", "changes", "to", "the", "current", "function", "that", "were", "done", "by", "s390_chunkify_start", "." ]