Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "case", "ISD", "::", "ADD", ":" ]

[ "case", "ISD", "::", "FSHR", ":", "return", "LowerFunnelShift", "(", "Op", ",", "Subtarget", ",", "DAG", ")", ";", "case", "ISD", "::", "STRICT_SINT_TO_FP", ":", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerSINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STRICT_UINT_TO_FP", ":", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "LowerUINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "TRUNCATE", ":", "return", "LowerTRUNCATE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "LowerZERO_EXTEND", "(", "Op", ",", "Subtarget", ",", "DAG", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "LowerSIGN_EXTEND", "(", "Op", ",", "Subtarget", ",", "DAG", ")", ";", "case", "ISD", "::", "ANY_EXTEND", ":", "return", "LowerANY_EXTEND", "(", "Op", ",", "Subtarget", ",", "DAG", ")", ";", "case", "ISD", "::", "ZERO_EXTEND_VECTOR_INREG", ":", "case", "ISD", "::", "SIGN_EXTEND_VECTOR_INREG", ":", "return", "LowerEXTEND_VECTOR_INREG", "(", "Op", ",", "Subtarget", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "case", "ISD", "::", "STRICT_FP_TO_SINT", ":", "case", "ISD", "::", "FP_TO_UINT", ":", "case", "ISD", "::", "STRICT_FP_TO_UINT", ":", "return", "LowerFP_TO_INT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_EXTEND", ":", "case", "ISD", "::", "STRICT_FP_EXTEND", ":", "return", "LowerFP_EXTEND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_ROUND", ":", "case", "ISD", "::", "STRICT_FP_ROUND", ":", "return", "LowerFP_ROUND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLoad", "(", "Op", ",", "Subtarget", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerStore", "(", "Op", ",", "Subtarget", ",", "DAG", ")", ";", "case", "ISD", "::", "FADD", ":", "case", "ISD", "::", "FSUB", ":", "return", "lowerFaddFsub", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FABS", ":", "case", "ISD", "::", "FNEG", ":", "return", "LowerFABSorFNEG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FCOPYSIGN", ":", "return", "LowerFCOPYSIGN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FGETSIGN", ":", "return", "LowerFGETSIGN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "case", "ISD", "::", "STRICT_FSETCC", ":", "case", "ISD", "::", "STRICT_FSETCCS", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCCCARRY", ":", "return", "LowerSETCCCARRY", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "LowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "LowerVAARG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VACOPY", ":", "return", "LowerVACOPY", "(", "Op", ",", "Subtarget", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "LowerINTRINSIC_W_CHAIN", "(", "Op", ",", "Subtarget", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADDROFRETURNADDR", ":", "return", "LowerADDROFRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAME_TO_ARGS_OFFSET", ":", "return", "LowerFRAME_TO_ARGS_OFFSET", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_RETURN", ":", "return", "LowerEH_RETURN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_SJLJ_SETJMP", ":", "return", "lowerEH_SJLJ_SETJMP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_SJLJ_LONGJMP", ":", "return", "lowerEH_SJLJ_LONGJMP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_SJLJ_SETUP_DISPATCH", ":", "return", "lowerEH_SJLJ_SETUP_DISPATCH", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INIT_TRAMPOLINE", ":", "return", "LowerINIT_TRAMPOLINE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADJUST_TRAMPOLINE", ":", "return", "LowerADJUST_TRAMPOLINE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FLT_ROUNDS_", ":", "return", "LowerFLT_ROUNDS_", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CTLZ", ":", "case", "ISD", "::", "CTLZ_ZERO_UNDEF", ":", "return", "LowerCTLZ", "(", "Op", ",", "Subtarget", ",", "DAG", ")", ";", "case", "ISD", "::", "CTTZ", ":", "case", "ISD", "::", "CTTZ_ZERO_UNDEF", ":", "return", "LowerCTTZ", "(", "Op", ",", "Subtarget", ",", "DAG", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "LowerMUL", "(", "Op", ",", "Subtarget", ",", "DAG", ")", ";", "case", "ISD", "::", "MULHS", ":", "case", "ISD", "::", "MULHU", ":", "return", "LowerMULH", "(", "Op", ",", "Subtarget", ",", "DAG", ")", ";", "case", "ISD", "::", "ROTL", ":", "case", "ISD", "::", "ROTR", ":", "return", "LowerRotate", "(", "Op", ",", "Subtarget", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SHL", ":", "return", "LowerShift", "(", "Op", ",", "Subtarget", ",", "DAG", ")", ";", "case", "ISD", "::", "SADDO", ":", "case", "ISD", "::", "UADDO", ":", "case", "ISD", "::", "SSUBO", ":", "case", "ISD", "::", "USUBO", ":", "case", "ISD", "::", "SMULO", ":", "case", "ISD", "::", "UMULO", ":", "return", "LowerXALUO", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "READCYCLECOUNTER", ":", "return", "LowerREADCYCLECOUNTER", "(", "Op", ",", "Subtarget", ",", "DAG", ")", ";", "case", "ISD", "::", "BITCAST", ":", "return", "LowerBITCAST", "(", "Op", ",", "Subtarget", ",", "DAG", ")", ";", "case", "ISD", "::", "ADDCARRY", ":", "case", "ISD", "::", "SUBCARRY", ":", "return", "LowerADDSUBCARRY", "(", "Op", ",", "DAG", ")", ";" ]

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

[ "(", "unspec", ":", "V8QI", "[", "(", "match_operand", ":", "OI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V8QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]" ]

[ ")" ]

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

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

[ "(", "neg", ":", "VF_SF_AVX512VL", "(", "match_operand", ":", "VF_SF_AVX512VL", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "}" ]

[ "MachineBasicBlock", "::", "iterator", "addToPacket", "(", "MachineInstr", "&", "MI", ")", "override", "{", "MachineBasicBlock", "::", "iterator", "FirstInBundle", "=", "CurrentPacketMIs", ".", "empty", "(", ")", "?", "&", "MI", ":", "CurrentPacketMIs", ".", "front", "(", ")", ";", "const", "DenseMap", "<", "unsigned", ",", "unsigned", ">", "&", "PV", "=", "getPreviousVector", "(", "FirstInBundle", ")", ";", "std", "::", "vector", "<", "R600InstrInfo", "::", "BankSwizzle", ">", "BS", ";", "bool", "isTransSlot", ";", "if", "(", "isBundlableWithCurrentPMI", "(", "MI", ",", "PV", ",", "BS", ",", "isTransSlot", ")", ")", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "CurrentPacketMIs", ".", "size", "(", ")", ";", "i", "<", "e", ";", "i", "++", ")", "{", "MachineInstr", "*", "MI", "=", "CurrentPacketMIs", "[", "i", "]", ";", "unsigned", "Op", "=", "TII", "->", "getOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", "::", "bank_swizzle", ")", ";", "MI", "->", "getOperand", "(", "Op", ")", ".", "setImm", "(", "BS", "[", "i", "]", ")", ";", "}", "unsigned", "Op", "=", "TII", "->", "getOperandIdx", "(", "MI", ".", "getOpcode", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", "::", "bank_swizzle", ")", ";", "MI", ".", "getOperand", "(", "Op", ")", ".", "setImm", "(", "BS", ".", "back", "(", ")", ")", ";", "if", "(", "!", "CurrentPacketMIs", ".", "empty", "(", ")", ")", "setIsLastBit", "(", "CurrentPacketMIs", ".", "back", "(", ")", ",", "<NUM_LIT>", ")", ";", "substitutePV", "(", "MI", ",", "PV", ")", ";", "MachineBasicBlock", "::", "iterator", "It", "=", "VLIWPacketizerList", "::", "addToPacket", "(", "MI", ")", ";", "if", "(", "isTransSlot", ")", "{", "endPacket", "(", "std", "::", "next", "(", "It", ")", "->", "getParent", "(", ")", ",", "std", "::", "next", "(", "It", ")", ")", ";", "}", "return", "It", ";", "}", "endPacket", "(", "MI", ".", "getParent", "(", ")", ",", "MI", ")", ";", "if", "(", "TII", "->", "isTransOnly", "(", "MI", ")", ")", "return", "MI", ";", "return", "VLIWPacketizerList", "::", "addToPacket", "(", "MI", ")", ";" ]

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

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

[ "<STR_LIT>" ]

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

[ "CmpXChg", ":", "AtomicExpansionKind", "::", "None", ";" ]

[ "return", "needsCmpXchgNb", "(", "PTy", "->", "getElementType", "(", ")", ")", "?", "AtomicExpansionKind", "::" ]

[ "}" ]

[ "auto", "SMBB", "=", "MI", ".", "getParent", "(", ")", ";", "auto", "EMBB", "=", "U", "->", "getParent", "(", ")", ";", "DenseSet", "<", "const", "MachineBasicBlock", "*", ">", "Visited", ";", "SmallVector", "<", "MachineBasicBlock", "*", ",", "<NUM_LIT>", ">", "Worklist", "(", "SMBB", "->", "succ_begin", "(", ")", ",", "SMBB", "->", "succ_end", "(", ")", ")", ";", "while", "(", "!", "Worklist", ".", "empty", "(", ")", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "Worklist", ".", "pop_back_val", "(", ")", ";", "if", "(", "MBB", "==", "EMBB", "||", "!", "Visited", ".", "insert", "(", "MBB", ")", ".", "second", ")", "continue", ";", "for", "(", "auto", "&", "Term", ":", "MBB", "->", "terminators", "(", ")", ")", "if", "(", "TII", "->", "isKillTerminator", "(", "Term", ".", "getOpcode", "(", ")", ")", ")", "return", "false", ";", "Worklist", ".", "append", "(", "MBB", "->", "succ_begin", "(", ")", ",", "MBB", "->", "succ_end", "(", ")", ")", ";" ]

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

[ "_", "_", "uqasx", "(", "uint16x2_t", "_", "_", "a", ",", "uint16x2_t", "_", "_", "b", ")", "{", "return", "_", "_", "builtin_arm_uqasx", "(", "_", "_", "a", ",", "_" ]

[ "<FIXS>", "pcrel", "=", "insn", ".", "startLocation", "+", "insn", ".", "immediateOffset", "+", "insn", ".", "immediateSize", ";", "<FIXE>" ]

[ "uint64_t", "pcrel", "=", "<NUM_LIT>", ";", "if", "(", "type", "==", "TYPE_REL", ")", "{", "isBranch", "=", "true", ";", "<BUGS>", "pcrel", "=", "insn", ".", "startLocation", "+", "insn", ".", "length", ";", "<BUGE>", "switch", "(", "operand", ".", "encoding", ")", "{", "default", ":", "break", ";" ]

[ ")", ")" ]

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

[ "<STR_LIT>" ]

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

[ "static", "void", "adjust_vperm", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "set", "=", "PATTERN", "(", "insn", ")", ";", "rtx", "mask_reg", "=", "XVECEXP", "(", "SET_SRC", "(", "set", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "struct", "df_insn_info", "*", "insn_info", "=", "DF_INSN_INFO_GET", "(", "insn", ")", ";", "df_ref", "use", ";", "rtx_insn", "*", "swap_insn", "=", "<NUM_LIT>", ";", "FOR_EACH_INSN_INFO_USE", "(", "use", ",", "insn_info", ")", "if", "(", "rtx_equal_p", "(", "DF_REF_REG", "(", "use", ")", ",", "mask_reg", ")", ")", "{", "struct", "df_link", "*", "def_link", "=", "DF_REF_CHAIN", "(", "use", ")", ";", "gcc_assert", "(", "def_link", "&&", "!", "def_link", "->", "next", ")", ";", "swap_insn", "=", "DF_REF_INSN", "(", "def_link", "->", "ref", ")", ";", "break", ";", "}", "gcc_assert", "(", "swap_insn", ")", ";", "insn_info", "=", "DF_INSN_INFO_GET", "(", "swap_insn", ")", ";", "rtx_insn", "*", "load_insn", "=", "<NUM_LIT>", ";", "FOR_EACH_INSN_INFO_USE", "(", "use", ",", "insn_info", ")", "{", "struct", "df_link", "*", "def_link", "=", "DF_REF_CHAIN", "(", "use", ")", ";", "gcc_assert", "(", "def_link", "&&", "!", "def_link", "->", "next", ")", ";", "load_insn", "=", "DF_REF_INSN", "(", "def_link", "->", "ref", ")", ";", "break", ";", "}", "gcc_assert", "(", "load_insn", ")", ";", "insn_info", "=", "DF_INSN_INFO_GET", "(", "load_insn", ")", ";", "rtx_insn", "*", "tocrel_insn", "=", "<NUM_LIT>", ";", "FOR_EACH_INSN_INFO_USE", "(", "use", ",", "insn_info", ")", "{", "struct", "df_link", "*", "def_link", "=", "DF_REF_CHAIN", "(", "use", ")", ";", "gcc_assert", "(", "def_link", "&&", "!", "def_link", "->", "next", ")", ";", "tocrel_insn", "=", "DF_REF_INSN", "(", "def_link", "->", "ref", ")", ";", "break", ";", "}", "gcc_assert", "(", "tocrel_insn", ")", ";", "rtx", "base", ",", "offset", ";", "const_rtx", "tocrel_base", ";", "rtx", "tocrel_expr", "=", "SET_SRC", "(", "PATTERN", "(", "tocrel_insn", ")", ")", ";", "if", "(", "MEM_P", "(", "tocrel_expr", ")", ")", "tocrel_expr", "=", "XEXP", "(", "tocrel_expr", ",", "<NUM_LIT>", ")", ";", "if", "(", "!", "toc_relative_expr_p", "(", "tocrel_expr", ",", "false", ",", "&", "tocrel_base", ",", "NULL", ")", ")", "gcc_unreachable", "(", ")", ";", "split_const", "(", "XVECEXP", "(", "tocrel_base", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ",", "&", "base", ",", "&", "offset", ")", ";", "rtx", "const_vector", "=", "get_pool_constant", "(", "base", ")", ";", "if", "(", "SYMBOL_REF_P", "(", "const_vector", ")", ")", "const_vector", "=", "get_pool_constant", "(", "const_vector", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "const_vector", ")", "==", "CONST_VECTOR", ")", ";", "unsigned", "int", "new", "_", "mask", "[", "<NUM_LIT>", "]", ",", "i", ",", "val", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "++", "i", ")", "{", "val", "=", "INTVAL", "(", "XVECEXP", "(", "const_vector", ",", "<NUM_LIT>", ",", "i", ")", ")", ";", "if", "(", "val", "<", "<NUM_LIT>", ")", "new", "_", "mask", "[", "i", "]", "=", "(", "val", "+", "<NUM_LIT>", ")", "%", "<NUM_LIT>", ";", "else", "new", "_", "mask", "[", "i", "]", "=", "(", "(", "val", "+", "<NUM_LIT>", ")", "%", "<NUM_LIT>", ")", "+", "<NUM_LIT>", ";", "}", "rtx", "vals", "=", "gen_rtx_PARALLEL", "(", "V16QImode", ",", "rtvec_alloc", "(", "<NUM_LIT>", ")", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "++", "i", ")", "XVECEXP", "(", "vals", ",", "<NUM_LIT>", ",", "i", ")", "=", "GEN_INT", "(", "new", "_", "mask", "[", "i", "]", ")", ";", "rtx", "new", "_", "const_vector", "=", "gen_rtx_CONST_VECTOR", "(", "V16QImode", ",", "XVEC", "(", "vals", ",", "<NUM_LIT>", ")", ")", ";", "rtx", "new", "_", "mem", "=", "force_const_mem", "(", "V16QImode", ",", "new", "_", "const_vector", ")", ";", "if", "(", "!", "REG_P", "(", "XEXP", "(", "new", "_", "mem", ",", "<NUM_LIT>", ")", ")", ")", "{", "rtx", "base_reg", "=", "force_reg", "(", "Pmode", ",", "XEXP", "(", "new", "_", "mem", ",", "<NUM_LIT>", ")", ")", ";", "XEXP", "(", "new", "_", "mem", ",", "<NUM_LIT>", ")", "=", "base_reg", ";", "rtx_insn", "*", "force_insn", "=", "get_last_insn", "(", ")", ";", "remove_insn", "(", "force_insn", ")", ";", "rtx_insn", "*", "before_load_insn", "=", "PREV_INSN", "(", "load_insn", ")", ";", "add_insn_after", "(", "force_insn", ",", "before_load_insn", ",", "BLOCK_FOR_INSN", "(", "load_insn", ")", ")", ";", "df_insn_rescan", "(", "before_load_insn", ")", ";", "df_insn_rescan", "(", "force_insn", ")", ";", "}", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "load_insn", ")", ")", ",", "<NUM_LIT>", ")", "=", "new", "_", "mem", ";", "INSN_CODE", "(", "load_insn", ")", "=", "-", "<NUM_LIT>", ";", "df_insn_rescan", "(", "load_insn", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "<STR_LIT>", "Adjusting mask for vperm %d\\n", "<STR_LIT>", ",", "INSN_UID", "(", "insn", ")", ")", ";", "}" ]

[ "Given", "an", "UNSPEC_VPERM", "insn", ",", "modify", "the", "mask", "loaded", "from", "the", "constant", "pool", "to", "reflect", "swapped", "doublewords", "." ]

[ "}" ]

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

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

[ "def", "L2_loadrh_pci", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ",", "IntRegs", ":", "$", "Rx32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rx32in", ",", "s4_1Imm", ":", "$", "Ii", ",", "ModRegs", ":", "$", "Mu2", ")", ",", "<STR_LIT>", ",", "tc_e93a3d71", ",", "TypeLD", ">", ",", "Enc_e83554", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";" ]

[ "Created", "->", "push_back", "(", "Cmp", ".", "getNode", "(", ")", ")", ";" ]

[ "EVT", "VT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "if", "(", "(", "VT", "!=", "MVT", "::", "i32", "&&", "VT", "!=", "MVT", "::", "i64", ")", "||", "!", "(", "Divisor", ".", "isPowerOf2", "(", ")", "||", "(", "-", "Divisor", ")", ".", "isPowerOf2", "(", ")", ")", ")", "return", "SDValue", "(", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "SDValue", "N0", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "unsigned", "Lg2", "=", "Divisor", ".", "countTrailingZeros", "(", ")", ";", "SDValue", "Zero", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "VT", ")", ";", "SDValue", "Pow2MinusOne", "=", "DAG", ".", "getConstant", "(", "(", "<NUM_LIT>", "ULL", "<<", "Lg2", ")", "-", "<NUM_LIT>", ",", "DL", ",", "VT", ")", ";", "SDValue", "CCVal", ";", "SDValue", "Cmp", "=", "getAArch64Cmp", "(", "N0", ",", "Zero", ",", "ISD", "::", "SETLT", ",", "CCVal", ",", "DAG", ",", "DL", ")", ";", "SDValue", "Add", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "VT", ",", "N0", ",", "Pow2MinusOne", ")", ";", "SDValue", "CSel", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "Add", ",", "N0", ",", "CCVal", ",", "Cmp", ")", ";", "if", "(", "Created", ")", "{" ]

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

[ "if", "(", "ExpandMLx", "&&", "OptLevel", "!=", "CodeGenOpt", "::", "None", "&&", "Subtarget", ".", "hasVFP2", "(", ")", ")", "PM", ".", "add", "(" ]

[ ";" ]

[ "MCAsmInfo", "*", "MAI", "=", "new", "HexagonMCAsmInfo", "(", "TT", ")", ";", "MCCFIInstruction", "Inst", "=", "MCCFIInstruction", "::", "createDefCfa", "(", "nullptr", ",", "Hexagon", "::", "R30", ",", "<NUM_LIT>", ")", ";", "MAI", "->", "addInitialFrameState", "(", "Inst", ")" ]

[ "unsigned", "HexagonInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "Hexagon", "::", "LDriw", ":", "case", "Hexagon", "::", "LDrid", ":", "case", "Hexagon", "::", "LDrih", ":", "case", "Hexagon", "::", "LDrib", ":", "case", "Hexagon", "::", "LDriub", ":", "if", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "&&", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", ")", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "default", ":", "break", ";", "}", "return", "<NUM_LIT>", ";", "}" ]

[ "isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "}" ]

[ "bool", "CSKYFrameLowering", "::", "hasBP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "MFI", ".", "hasVarSizedObjects", "(", ")", ";" ]

[ "<FIXS>", "assert", "(", "MO", ".", "isImm", "(", ")", "&&", "<STR_LIT>", "Relocation required in an instruction that we cannot encode!", "<STR_LIT>", ")", ";", "return", "MO", ".", "getImm", "(", ")", ";", "<FIXE>" ]

[ "return", "PPCRegisterInfo", "::", "getRegisterNumbering", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "<BUGS>", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", "||", "MO", ".", "isSymbol", "(", ")", "||", "MO", ".", "isCPI", "(", ")", "||", "MO", ".", "isJTI", "(", ")", ")", "{", "unsigned", "Reloc", "=", "<NUM_LIT>", ";", "assert", "(", "(", "TM", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "PIC_", "||", "MovePCtoLROffset", ")", "&&", "<STR_LIT>", "MovePCtoLR not seen yet?", "<STR_LIT>", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "MI", ".", "dump", "(", ")", ";", "llvm_unreachable", "(", "<STR_LIT>", "Unknown instruction for relocation!", "<STR_LIT>", ")", ";", "case", "PPC", "::", "LBZ", ":", "case", "PPC", "::", "LBZ8", ":", "case", "PPC", "::", "LHA", ":", "case", "PPC", "::", "LHA8", ":", "case", "PPC", "::", "LHZ", ":", "case", "PPC", "::", "LHZ8", ":", "case", "PPC", "::", "LWZ", ":", "case", "PPC", "::", "LWZ8", ":", "case", "PPC", "::", "LFS", ":", "case", "PPC", "::", "LFD", ":", "case", "PPC", "::", "STB", ":", "case", "PPC", "::", "STB8", ":", "case", "PPC", "::", "STH", ":", "case", "PPC", "::", "STH8", ":", "case", "PPC", "::", "STW", ":", "case", "PPC", "::", "STW8", ":", "case", "PPC", "::", "STFS", ":", "case", "PPC", "::", "STFD", ":", "Reloc", "=", "PPC", "::", "reloc_absolute_low", ";", "break", ";", "}", "MCE", ".", "addRelocation", "(", "GetRelocation", "(", "MO", ",", "Reloc", ")", ")", ";", "}", "else", "{", "#", "ifndef", "NDEBUGerrs", "(", ")", "<<", "<STR_LIT>", "ERROR: Unknown type of MachineOperand: ", "<STR_LIT>", "<<", "MO", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "#", "endifllvm_unreachable", "(", "<NUM_LIT>", ")", ";", "}", "return", "<NUM_LIT>", ";", "<BUGE>", "}", "#", "include", "<STR_LIT>", "PPCGenCodeEmitter.inc", "<STR_LIT>" ]

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

[ "class", "ADRI", "<", "bit", "page", ",", "string", "asm", ",", "Operand", "adr", ",", "list", "<", "dag", ">", "pattern", ">", ":", "I", "<", "(", "outs", "GPR64", ":", "$", "Xd", ")", ",", "(", "ins", "adr", ":", "$", "label", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "pattern", ">", ",", "Sched", "<", "[", "WriteI", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Xd", ";" ]

[ "}" ]

[ "bool", "ARMInstructionSelector", "::", "insertComparison", "(", "CmpConstants", "Helper", ",", "InsertInfo", "I", ",", "unsigned", "ResReg", ",", "<STR_LIT>", "::", "<STR_LIT>", "Cond", ",", "unsigned", "LHSReg", ",", "unsigned", "RHSReg", ",", "unsigned", "PrevRes", ")", "const", "{", "auto", "CmpI", "=", "BuildMI", "(", "I", ".", "MBB", ",", "I", ".", "InsertBefore", ",", "I", ".", "DbgLoc", ",", "TII", ".", "get", "(", "Helper", ".", "ComparisonOpcode", ")", ")", ".", "addUse", "(", "LHSReg", ")", ".", "addUse", "(", "RHSReg", ")", ".", "add", "(", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "if", "(", "!", "constrainSelectedInstRegOperands", "(", "*", "CmpI", ",", "TII", ",", "TRI", ",", "RBI", ")", ")", "return", "false", ";", "if", "(", "Helper", ".", "ReadFlagsOpcode", "!=", "ARM", "::", "INSTRUCTION_LIST_END", ")", "{", "auto", "ReadI", "=", "BuildMI", "(", "I", ".", "MBB", ",", "I", ".", "InsertBefore", ",", "I", ".", "DbgLoc", ",", "TII", ".", "get", "(", "Helper", ".", "ReadFlagsOpcode", ")", ")", ".", "add", "(", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "if", "(", "!", "constrainSelectedInstRegOperands", "(", "*", "ReadI", ",", "TII", ",", "TRI", ",", "RBI", ")", ")", "return", "false", ";" ]

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

[ "}", "}", ")", "<BUGS>", "(", "define_insn", "<STR_LIT>", "<BUGE>", "[", "(", "set", "(", "reg", ":", "PSI", "<NUM_LIT>", ")", "(", "mult", ":", "PSI", "(", "sign_extend", ":", "PSI", "(", "reg", ":", "QI", "<NUM_LIT>", ")", ")", "(", "reg", ":", "PSI", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<BUGS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>", "<BUGS>", "(", "define_insn", "<STR_LIT>", "<BUGE>", "[", "(", "set", "(", "reg", ":", "PSI", "<NUM_LIT>", ")", "(", "mult", ":", "PSI", "(", "reg", ":", "PSI", "<NUM_LIT>", ")", "(", "reg", ":", "PSI", "<NUM_LIT>", ")", ")", ")" ]

[ "bool", "R600ClauseMergePass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TII", "=", "static_cast", "<", "const", "R600InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "MF", ".", "begin", "(", ")", ",", "BB_E", "=", "MF", ".", "end", "(", ")", ";", "BB", "!=", "BB_E", ";", "++", "BB", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BB", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "LatestCFAlu", "=", "E", ";", "while", "(", "I", "!=", "E", ")", "{", "MachineInstr", "*", "MI", "=", "I", "++", ";", "if", "(", "(", "!", "TII", "->", "canBeConsideredALU", "(", "MI", ")", "&&", "!", "isCFAlu", "(", "MI", ")", ")", "||", "TII", "->", "mustBeLastInClause", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "LatestCFAlu", "=", "E", ";", "if", "(", "!", "isCFAlu", "(", "MI", ")", ")", "continue", ";", "cleanPotentialDisabledCFAlu", "(", "MI", ")", ";", "if", "(", "LatestCFAlu", "!=", "E", "&&", "mergeIfPossible", "(", "LatestCFAlu", ",", "MI", ")", ")", "{", "MI", "->", "eraseFromParent", "(", ")", ";", "}", "else", "{", "assert", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "&&", "<STR_LIT>", "CF ALU instruction disabled", "<STR_LIT>", ")", ";", "LatestCFAlu", "=", "MI", ";", "}", "}", "}", "return", "false", ";", "}" ]

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

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

[ "(", "and", "(", "and", "(", "eq_attr" ]

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

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

[ "SDValue", "HexagonTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDValue", "Callee", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_Hexagon", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "SDValue", "RetVal", ";", "if", "(", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", "==", "MVT", "::", "i1", ")", "{", "auto", "&", "MRI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ";", "SDValue", "FR0", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "MVT", "::", "i32", ",", "InFlag", ")", ";", "unsigned", "PredR", "=", "MRI", ".", "createVirtualRegister", "(", "&", "Hexagon", "::", "PredRegsRegClass", ")", ";", "SDValue", "TPR", "=", "DAG", ".", "getCopyToReg", "(", "FR0", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "dl", ",", "PredR", ",", "FR0", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "FR0", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "RetVal", "=", "DAG", ".", "getCopyFromReg", "(", "TPR", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "dl", ",", "PredR", ",", "MVT", "::", "i1", ",", "TPR", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "}", "else", "{", "RetVal", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "InFlag", ")", ";", "}", "InVals", ".", "push_back", "(", "RetVal", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "Chain", "=", "RetVal", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "InFlag", "=", "RetVal", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "}", "return", "Chain", ";", "}" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "<FIXS>", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "HasV4TOps", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "HasV4TOps", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "HasV4TOps", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "HasV4TOps", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "HasV4TOps", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "HasV4TOps", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "HasV4TOps", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "HasV4TOps", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "HasV4TOps", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "HasV4TOps", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "HasV4TOps", "]", ">", ";", "<FIXE>", "<FIXS>", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "HasV5TOps", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "HasV5TOps", "]", ">", ";", "<FIXE>", "<FIXS>", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "HasV5TEOps", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "HasV5TEOps", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "HasV5TEOps", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "HasV5TEOps", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "HasV5TEOps", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "HasV5TEOps", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "HasV5TEOps", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "HasV5TEOps", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "HasV5TEOps", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "HasV5TEOps", "]", ">", ";", "<FIXE>", "<FIXS>", "def", ":", "Processor", "<STR_LIT>", ",", "ARMV6Itineraries", ",", "[", "HasV6Ops", "]", ">", ";", "def", ":", "Processor", "<STR_LIT>", ",", "ARMV6Itineraries", ",", "[", "HasV6Ops", ",", "FeatureVFP2", ",", "<FIXE>", "<FIXS>", "def", ":", "Processor", "<STR_LIT>", ",", "ARMV6Itineraries", ",", "[", "HasV6Ops", "]", ">", ";", "def", ":", "Processor", "<STR_LIT>", ",", "ARMV6Itineraries", ",", "[", "HasV6Ops", ",", "FeatureVFP2", ",", "<FIXE>", "<FIXS>", "def", ":", "Processor", "<STR_LIT>", ",", "ARMV6Itineraries", ",", "[", "HasV6Ops", "]", ">", ";", "def", ":", "Processor", "<STR_LIT>", ",", "ARMV6Itineraries", ",", "[", "HasV6Ops", ",", "FeatureVFP2", ",", "<FIXE>", "<FIXS>", "def", ":", "Processor", "<STR_LIT>", ",", "ARMV6Itineraries", ",", "[", "HasV6Ops", ",", "FeatureNoARM", ",", "FeatureDB", "]", ">", ";", "<FIXE>", "<FIXS>", "def", ":", "Processor", "<STR_LIT>", ",", "ARMV6Itineraries", ",", "[", "HasV6T2Ops", "]", ">", ";", "def", ":", "Processor", "<STR_LIT>", ",", "ARMV6Itineraries", ",", "[", "HasV6T2Ops", ",", "FeatureVFP2", ",", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "[", "ProcA8", ",", "HasV7Ops", ",", "FeatureNEON", ",", "FeatureDB", ",", "FeatureDSPThumb2", "]", ">", ";", "<FIXE>", "<FIXS>", "[", "ProcA9", ",", "HasV7Ops", ",", "FeatureNEON", ",", "FeatureDB", ",", "FeatureDSPThumb2", "]", ">", ";", "<FIXE>", "<FIXS>", "[", "ProcA9", ",", "HasV7Ops", ",", "FeatureNEON", ",", "FeatureDB", ",", "FeatureDSPThumb2", ",", "FeatureMP", "]", ">", ";", "<FIXE>", "<FIXS>", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "HasV7Ops", ",", "FeatureThumb2", ",", "FeatureNoARM", ",", "FeatureDB", ",", "FeatureHWDiv", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "HasV7Ops", ",", "FeatureThumb2", ",", "FeatureNoARM", ",", "FeatureDB", ",", "FeatureHWDiv", ",", "FeatureDSPThumb2", ",", "FeatureT2XtPk", ",", "FeatureVFP2", ",", "FeatureVFPOnlySP", "]", ">", ";", "<FIXE>" ]

[ "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "]", ">", ";", "<BUGS>", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "ArchV4T", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "ArchV4T", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "ArchV4T", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "ArchV4T", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "ArchV4T", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "ArchV4T", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "ArchV4T", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "ArchV4T", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "ArchV4T", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "ArchV4T", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "ArchV4T", "]", ">", ";", "<BUGE>", "<BUGS>", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "ArchV5T", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "ArchV5T", "]", ">", ";", "<BUGE>", "<BUGS>", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "ArchV5TE", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "ArchV5TE", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "ArchV5TE", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "ArchV5TE", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "ArchV5TE", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "ArchV5TE", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "ArchV5TE", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "ArchV5TE", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "ArchV5TE", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "ArchV5TE", "]", ">", ";", "<BUGE>", "<BUGS>", "def", ":", "Processor", "<STR_LIT>", ",", "ARMV6Itineraries", ",", "[", "ArchV6", "]", ">", ";", "def", ":", "Processor", "<STR_LIT>", ",", "ARMV6Itineraries", ",", "[", "ArchV6", ",", "FeatureVFP2", ",", "<BUGE>", "FeatureHasSlowFPVMLx", "]", ">", ";", "<BUGS>", "def", ":", "Processor", "<STR_LIT>", ",", "ARMV6Itineraries", ",", "[", "ArchV6", "]", ">", ";", "def", ":", "Processor", "<STR_LIT>", ",", "ARMV6Itineraries", ",", "[", "ArchV6", ",", "FeatureVFP2", ",", "<BUGE>", "FeatureHasSlowFPVMLx", "]", ">", ";", "<BUGS>", "def", ":", "Processor", "<STR_LIT>", ",", "ARMV6Itineraries", ",", "[", "ArchV6", "]", ">", ";", "def", ":", "Processor", "<STR_LIT>", ",", "ARMV6Itineraries", ",", "[", "ArchV6", ",", "FeatureVFP2", ",", "<BUGE>", "FeatureHasSlowFPVMLx", "]", ">", ";", "<BUGS>", "def", ":", "Processor", "<STR_LIT>", ",", "ARMV6Itineraries", ",", "[", "ArchV6M", "]", ">", ";", "<BUGE>", "<BUGS>", "def", ":", "Processor", "<STR_LIT>", ",", "ARMV6Itineraries", ",", "[", "ArchV6T2", "]", ">", ";", "def", ":", "Processor", "<STR_LIT>", ",", "ARMV6Itineraries", ",", "[", "ArchV6T2", ",", "FeatureVFP2", ",", "<BUGE>", "FeatureHasSlowFPVMLx", "]", ">", ";", "<BUGS>", "<BUGE>", "def", ":", "Processor", "<STR_LIT>", ",", "CortexA8Itineraries", ",", "<BUGS>", "[", "ArchV7A", ",", "ProcA8", "]", ">", ";", "<BUGE>", "def", ":", "Processor", "<STR_LIT>", ",", "CortexA9Itineraries", ",", "<BUGS>", "[", "ArchV7A", ",", "ProcA9", "]", ">", ";", "<BUGE>", "def", ":", "Processor", "<STR_LIT>", ",", "CortexA9Itineraries", ",", "<BUGS>", "[", "ArchV7A", ",", "ProcA9", ",", "FeatureMP", "]", ">", ";", "<BUGE>", "<BUGS>", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "ArchV7M", "]", ">", ";", "def", ":", "ProcNoItin", "<STR_LIT>", ",", "[", "ArchV7EM", ",", "FeatureVFP2", ",", "FeatureVFPOnlySP", "]", ">", ";", "<BUGE>" ]

[ "}" ]

[ "class", "MVE_VCMPqrs", "<", "string", "suffix", ",", "bits", "<", "<NUM_LIT>", ">", "size", ">", ":", "MVE_VCMPqr", "<", "suffix", ",", "<NUM_LIT>", ",", "size", ",", "pred_basic_s", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "MMOs", ".", "first", ")", "->", "getAlignment", "(", ")", ">=", "Alignment", ";" ]

[ "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "N", "->", "getNumValues", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "EVT", "VT", "=", "N", "->", "getValueType", "(", "i", ")", ";", "if", "(", "VT", "!=", "MVT", "::", "Other", "&&", "i", ">=", "(", "unsigned", ")", "MCID", ".", "getNumDefs", "(", ")", ")", "VTs", ".", "push_back", "(", "VT", ")", ";", "}", "if", "(", "Load", ")", "BeforeOps", ".", "push_back", "(", "SDValue", "(", "Load", ",", "<NUM_LIT>", ")", ")", ";", "std", "::", "copy", "(", "AfterOps", ".", "begin", "(", ")", ",", "AfterOps", ".", "end", "(", ")", ",", "std", "::", "back_inserter", "(", "BeforeOps", ")", ")", ";", "SDNode", "*", "NewNode", "=", "DAG", ".", "getMachineNode", "(", "Opc", ",", "dl", ",", "VTs", ",", "&", "BeforeOps", "[", "<NUM_LIT>", "]", ",", "BeforeOps", ".", "size", "(", ")", ")", ";", "NewNodes", ".", "push_back", "(", "NewNode", ")", ";", "if", "(", "FoldedStore", ")", "{", "AddrOps", ".", "pop_back", "(", ")", ";", "AddrOps", ".", "push_back", "(", "SDValue", "(", "NewNode", ",", "<NUM_LIT>", ")", ")", ";", "AddrOps", ".", "push_back", "(", "Chain", ")", ";", "std", "::", "pair", "<", "MachineInstr", "::", "mmo_iterator", ",", "MachineInstr", "::", "mmo_iterator", ">", "MMOs", "=", "MF", ".", "extractStoreMemRefs", "(", "cast", "<", "MachineSDNode", ">", "(", "N", ")", "->", "memoperands_begin", "(", ")", ",", "cast", "<", "MachineSDNode", ">", "(", "N", ")", "->", "memoperands_end", "(", ")", ")", ";", "if", "(", "!", "(", "*", "MMOs", ".", "first", ")", "&&", "RC", "==", "&", "X86", "::", "VR128RegClass", "&&", "!", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "isUnalignedMemAccessFast", "(", ")", ")", "return", "false", ";", "unsigned", "Alignment", "=", "RC", "->", "getSize", "(", ")", "==", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "bool", "isAligned", "=", "(", "*", "MMOs", ".", "first", ")", "&&", "(", "*" ]

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

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

[ "return", "P", ".", "first", "->", "second", ";" ]

[ "dbgs", "(", ")", "<<", "<STR_LIT>", "Allocating local ", "<STR_LIT>", "<<", "CurLocal", "<<", "<STR_LIT>", "for VReg ", "<STR_LIT>", "<<", "Register", "::", "virtReg2Index", "(", "Reg", ")", "<<", "'", "\\n", "'", ";", "}", ")", ";", "MFI", ".", "setFrameBaseLocal", "(", "CurLocal", ")", ";", "}", "++", "CurLocal", ";", "}" ]

[ ";" ]

[ "if", "(", "!", "Op", ")", "continue", ";", "MachineInstr", "*", "Def", "=", "Op", "->", "getParent", "(", ")", ";", "if", "(", "DeadInstr", ".", "find", "(", "Def", ")", "!=", "DeadInstr", ".", "end", "(", ")", ")", "continue", ";", "bool", "IsDead", "=", "true", ";", "for", "(", "MachineOperand", "&", "MODef", ":", "Def", "->", "operands", "(", ")", ")", "{", "if", "(", "(", "!", "MODef", ".", "isReg", "(", ")", ")", "||", "(", "!", "MODef", ".", "isDef", "(", ")", ")", ")", "continue", ";", "Register", "DefReg", "=", "MODef", ".", "getReg", "(", ")", ";", "if", "(", "!", "DefReg", ".", "isVirtual", "(", ")", ")", "{", "IsDead", "=", "false" ]

[ "<FIXS>", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "{", "if", "(", "Subtarget", "->", "isPICStyleStub", "(", ")", ")", "O", "<<", "<STR_LIT>", "-\\\"L", "<STR_LIT>", "<<", "getFunctionNumber", "(", ")", "<<", "<STR_LIT>", "$pb\\\"", "<STR_LIT>", ";", "if", "(", "Subtarget", "->", "isPICStyleGOT", "(", ")", ")", "O", "<<", "<STR_LIT>", "@GOTOFF", "<STR_LIT>", ";", "}", "<FIXE>" ]

[ "if", "(", "!", "isMemOp", ")", "O", "<<", "'", "$", "'", ";", "O", "<<", "TAI", "->", "getPrivateGlobalPrefix", "(", ")", "<<", "<STR_LIT>", "CPI", "<STR_LIT>", "<<", "getFunctionNumber", "(", ")", "<<", "<STR_LIT>", "_", "<STR_LIT>", "<<", "MO", ".", "getConstantPoolIndex", "(", ")", ";", "<BUGS>", "if", "(", "X86PICStyle", "==", "PICStyle", "::", "Stub", "&&", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "O", "<<", "<STR_LIT>", "-\\\"L", "<STR_LIT>", "<<", "getFunctionNumber", "(", ")", "<<", "<STR_LIT>", "$pb\\\"", "<STR_LIT>", ";", "<BUGE>", "int", "Offset", "=", "MO", ".", "getOffset", "(", ")", ";", "if", "(", "Offset", ">", "<NUM_LIT>", ")", "O", "<<", "<STR_LIT>", "+", "<STR_LIT>", "<<", "Offset", ";" ]

[ "<FIXS>", "static", "void", "arm_set_default_type_attributes", "PARAMS", "(", "(", "tree", ")", ")", ";", "<FIXE>", "<FIXS>", "static", "int", "count_insns_for_constant", "PARAMS", "(", "(", "Hint", ",", "int", ")", ")", ";", "<FIXE>", "<FIXS>", "static", "void", "arm_elf_asm_named_section", "PARAMS", "(", "(", "Ccstar", ",", "unsigned", "int", ")", ")", ";", "<FIXE>", "<FIXS>", "static", "void", "aof_globalize_label", "PARAMS", "(", "(", "FILE", "*", ",", "Ccstar", ")", ")", ";", "<FIXE>", "<FIXS>", "<FIXE>" ]

[ "static", "void", "arm_output_function_prologue", "PARAMS", "(", "(", "FILE", "*", ",", "Hint", ")", ")", ";", "static", "void", "thumb_output_function_prologue", "PARAMS", "(", "(", "FILE", "*", ",", "Hint", ")", ")", ";", "static", "int", "arm_comp_type_attributes", "PARAMS", "(", "(", "tree", ",", "tree", ")", ")", ";", "<BUGS>", "static", "void", "arm_set_default_type_attributes", "PARAMS", "(", "(", "tree", ")", ")", ";", "<BUGE>", "static", "int", "arm_adjust_cost", "PARAMS", "(", "(", "rtx", ",", "rtx", ",", "rtx", ",", "int", ")", ")", ";", "<BUGS>", "static", "int", "count_insns_for_constant", "PARAMS", "(", "(", "HOST_WIDE_INT", ",", "int", ")", ")", ";", "<BUGE>", "static", "int", "arm_get_strip_length", "PARAMS", "(", "(", "int", ")", ")", ";", "static", "bool", "arm_function_ok_for_sibcall", "PARAMS", "(", "(", "tree", ",", "tree", ")", ")", ";", "#", "ifdef", "OBJECT_FORMAT_ELF", "<BUGS>", "static", "void", "arm_elf_asm_named_section", "PARAMS", "(", "(", "const", "char", "*", ",", "unsigned", "int", ")", ")", ";", "<BUGE>", "#", "endif", "#", "ifndef", "ARM_PEstatic", "void", "arm_encode_section_info", "PARAMS", "(", "(", "tree", ",", "int", ")", ")", ";", "#", "endif", "#", "ifdef", "AOF_ASSEMBLER", "<BUGS>", "static", "void", "aof_globalize_label", "PARAMS", "(", "(", "FILE", "*", ",", "const", "char", "*", ")", ")", ";", "<BUGE>", "#", "endif", "<BUGS>", "static", "void", "arm_internal_label", "PARAMS", "(", "(", "FILE", "*", ",", "const", "char", "*", ",", "unsigned", "long", ")", ")", ";", "static", "void", "arm_output_mi_thunk", "PARAMS", "(", "(", "FILE", "*", ",", "tree", ",", "HOST_WIDE_INT", ",", "HOST_WIDE_INT", ",", "tree", ")", ")", ";", "static", "int", "arm_rtx_costs_1", "PARAMS", "(", "(", "rtx", ",", "enum", "rtx_code", ",", "enum", "rtx_code", ")", ")", ";", "static", "bool", "arm_rtx_costs", "PARAMS", "(", "(", "rtx", ",", "int", ",", "int", ",", "int", "*", ")", ")", ";", "static", "int", "arm_address_cost", "PARAMS", "(", "(", "rtx", ")", ")", ";", "static", "int", "is_load_address", "PARAMS", "(", "(", "rtx", ")", ")", ";", "static", "int", "is_cirrus_insn", "PARAMS", "(", "(", "rtx", ")", ")", ";", "static", "void", "cirrus_reorg", "PARAMS", "(", "(", "rtx", ")", ")", ";", "<BUGE>", "#", "undef", "Hint", "#", "undef", "Mmode" ]

[ "SrcReg", ",", "Subtarget", ")", ";" ]

[ "Opc", "=", "X86", "::", "VMOVAPSZrr", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "DestReg", "=", "TRI", "->", "getMatchingSuperReg", "(", "DestReg", ",", "X86", "::", "sub_xmm", ",", "&", "X86", "::", "VR512RegClass", ")", ";", "SrcReg", "=", "TRI", "->", "getMatchingSuperReg", "(", "SrcReg", ",", "X86", "::", "sub_xmm", ",", "&", "X86", "::", "VR512RegClass", ")", ";", "}", "}", "else", "if", "(", "X86", "::", "VR256XRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "if", "(", "HasVLX", ")", "Opc", "=", "X86", "::", "VMOVAPSZ256rr", ";", "else", "if", "(", "X86", "::", "VR256RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "X86", "::", "VMOVAPSYrr", ";", "else", "{", "Opc", "=", "X86", "::", "VMOVAPSZrr", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "DestReg", "=", "TRI", "->", "getMatchingSuperReg", "(", "DestReg", ",", "X86", "::", "sub_ymm", ",", "&", "X86", "::", "VR512RegClass", ")", ";", "SrcReg", "=", "TRI", "->", "getMatchingSuperReg", "(", "SrcReg", ",", "X86", "::", "sub_ymm", ",", "&", "X86", "::", "VR512RegClass", ")", ";", "}", "}", "else", "if", "(", "X86", "::", "VR512RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "X86", "::", "VMOVAPSZrr", ";", "else", "if", "(", "X86", "::", "VK16RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "Subtarget", ".", "hasBWI", "(", ")", "?", "X86", "::", "KMOVQkk", ":", "X86", "::", "KMOVWkk", ";", "if", "(", "!", "Opc", ")", "Opc", "=", "CopyToFromAsymmetricReg", "(", "DestReg", "," ]

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

[ "[", "(", "set", "(", "match_operand", ":", "V2DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "vec_select", ":", "V2DF", "(", "vec_concat", ":", "V4DF", "(", "match_operand", ":", "V2DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]" ]

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

[ "def", "V_FMA_F64", ":", "VOP3_64", "<", "<NUM_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "f64", ":", "$", "dst", ",", "(", "fma", "f64", ":", "$", "src0", ",", "f64", ":", "$", "src1", ",", "f64", ":", "$", "src2" ]

[ "<FIXS>", "return", "STI", ".", "getFeatureBits", "(", ")", "[", "ARM", "::", "ModeThumb", "]", ";", "<FIXE>", "<FIXS>", "return", "isThumb", "(", ")", "&&", "!", "STI", ".", "getFeatureBits", "(", ")", "[", "ARM", "::", "FeatureThumb2", "]", ";", "<FIXE>", "<FIXS>", "return", "isThumb", "(", ")", "&&", "STI", ".", "getFeatureBits", "(", ")", "[", "ARM", "::", "FeatureThumb2", "]", ";", "<FIXE>", "<FIXS>", "return", "STI", ".", "getFeatureBits", "(", ")", "[", "ARM", "::", "HasV4TOps", "]", ";", "<FIXE>", "<FIXS>", "return", "STI", ".", "getFeatureBits", "(", ")", "[", "ARM", "::", "HasV6Ops", "]", ";", "<FIXE>", "<FIXS>", "return", "STI", ".", "getFeatureBits", "(", ")", "[", "ARM", "::", "HasV6MOps", "]", ";", "<FIXE>", "<FIXS>", "return", "STI", ".", "getFeatureBits", "(", ")", "[", "ARM", "::", "HasV7Ops", "]", ";", "<FIXE>", "<FIXS>", "return", "STI", ".", "getFeatureBits", "(", ")", "[", "ARM", "::", "HasV8Ops", "]", ";", "<FIXE>", "<FIXS>", "return", "!", "STI", ".", "getFeatureBits", "(", ")", "[", "ARM", "::", "FeatureNoARM", "]", ";", "<FIXE>", "<FIXS>", "return", "STI", ".", "getFeatureBits", "(", ")", "[", "ARM", "::", "FeatureDSPThumb2", "]", ";", "<FIXE>", "<FIXS>", "return", "STI", ".", "getFeatureBits", "(", ")", "[", "ARM", "::", "FeatureD16", "]", ";", "<FIXE>" ]

[ "bool", "isThumb", "(", ")", "const", "{", "<BUGS>", "return", "(", "STI", ".", "getFeatureBits", "(", ")", "&", "ARM", "::", "ModeThumb", ")", "!=", "<NUM_LIT>", ";", "<BUGE>", "}", "bool", "isThumbOne", "(", ")", "const", "{", "<BUGS>", "return", "isThumb", "(", ")", "&&", "(", "STI", ".", "getFeatureBits", "(", ")", "&", "ARM", "::", "FeatureThumb2", ")", "==", "<NUM_LIT>", ";", "<BUGE>", "}", "bool", "isThumbTwo", "(", ")", "const", "{", "<BUGS>", "return", "isThumb", "(", ")", "&&", "(", "STI", ".", "getFeatureBits", "(", ")", "&", "ARM", "::", "FeatureThumb2", ")", ";", "<BUGE>", "}", "bool", "hasThumb", "(", ")", "const", "{", "<BUGS>", "return", "STI", ".", "getFeatureBits", "(", ")", "&", "ARM", "::", "HasV4TOps", ";", "<BUGE>", "}", "bool", "hasV6Ops", "(", ")", "const", "{", "<BUGS>", "return", "STI", ".", "getFeatureBits", "(", ")", "&", "ARM", "::", "HasV6Ops", ";", "<BUGE>", "}", "bool", "hasV6MOps", "(", ")", "const", "{", "<BUGS>", "return", "STI", ".", "getFeatureBits", "(", ")", "&", "ARM", "::", "HasV6MOps", ";", "<BUGE>", "}", "bool", "hasV7Ops", "(", ")", "const", "{", "<BUGS>", "return", "STI", ".", "getFeatureBits", "(", ")", "&", "ARM", "::", "HasV7Ops", ";", "<BUGE>", "}", "bool", "hasV8Ops", "(", ")", "const", "{", "<BUGS>", "return", "STI", ".", "getFeatureBits", "(", ")", "&", "ARM", "::", "HasV8Ops", ";", "<BUGE>", "}", "bool", "hasARM", "(", ")", "const", "{", "<BUGS>", "return", "!", "(", "STI", ".", "getFeatureBits", "(", ")", "&", "ARM", "::", "FeatureNoARM", ")", ";", "<BUGE>", "}", "bool", "hasThumb2DSP", "(", ")", "const", "{", "<BUGS>", "return", "STI", ".", "getFeatureBits", "(", ")", "&", "ARM", "::", "FeatureDSPThumb2", ";", "<BUGE>", "}", "bool", "hasD16", "(", ")", "const", "{", "<BUGS>", "return", "STI", ".", "getFeatureBits", "(", ")", "&", "ARM", "::", "FeatureD16", ";", "<BUGE>", "}", "void", "SwitchMode", "(", ")", "{" ]

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

[ "if", "(", "pool_size", ")", "{", "fprintf", "(", "asm_out_file", ",", "<STR_LIT>", "\\t.align 2\\n", "<STR_LIT>", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "pool_size", ";" ]

[ "return", "ResNode", ";" ]

[ "const", "SDValue", "Ops", "[", "]", "=", "{", "VSrc", ",", "Base", ",", "getI8Imm", "(", "Scale", "->", "getSExtValue", "(", ")", ",", "DL", ")", ",", "VIdx", ",", "Disp", ",", "Segment", ",", "VMask", ",", "Chain", "}", ";", "SDNode", "*", "ResNode", "=", "CurDAG", "->", "getMachineNode", "(", "Opc", ",", "DL", ",", "VTs", ",", "Ops", ")", ";", "ReplaceUses", "(", "SDValue", "(", "Node", ",", "<NUM_LIT>", ")", ",", "SDValue", "(", "ResNode", ",", "<NUM_LIT>", ")", ")", ";", "ReplaceUses", "(", "SDValue", "(", "Node", ",", "<NUM_LIT>", ")", ",", "SDValue", "(", "ResNode", ",", "<NUM_LIT>", ")", ")", ";" ]

[ "Error", "(", "Loc", ",", "<STR_LIT>", "invalid immediate: only 16-bit values are legal", "<STR_LIT>", ")", ";" ]

[ "using", "namespace", "llvm", "::", "AMDGPU", "::", "SendMsg", ";", "int64_t", "ImmVal", "=", "<NUM_LIT>", ";", "SMLoc", "Loc", "=", "getLoc", "(", ")", ";", "if", "(", "trySkipId", "(", "<STR_LIT>", "sendmsg", "<STR_LIT>", ",", "AsmToken", "::", "LParen", ")", ")", "{", "OperandInfoTy", "Msg", "(", "OPR_ID_UNKNOWN", ")", ";", "OperandInfoTy", "Op", "(", "OP_NONE_", ")", ";", "OperandInfoTy", "Stream", "(", "STREAM_ID_NONE_", ")", ";", "if", "(", "parseSendMsgBody", "(", "Msg", ",", "Op", ",", "Stream", ")", "&&", "validateSendMsg", "(", "Msg", ",", "Op", ",", "Stream", ")", ")", "{", "ImmVal", "=", "encodeMsg", "(", "Msg", ".", "Id", ",", "Op", ".", "Id", ",", "Stream", ".", "Id", ")", ";", "}", "else", "{", "return", "MatchOperand_ParseFail", ";", "}", "}", "else", "if", "(", "parseExpr", "(", "ImmVal", ",", "<STR_LIT>", "a sendmsg macro", "<STR_LIT>", ")", ")", "{", "if", "(", "ImmVal", "<", "<NUM_LIT>", "||", "!", "isUInt", "<", "<NUM_LIT>", ">", "(", "ImmVal", ")", ")", "{" ]

[ "}" ]

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

[ "}" ]

[ "bool", "doInitialization", "(", "Module", "&", "M", ")", "override", "{", "return", "mergeModuleStringPool", "(", "M", ")", ";" ]

[ "<FIXS>", "[", "(", "set", "VR128", ":", "$", "dst", ",", "(", "V4F32Int", "(", "memopv4f32", "addr", ":", "$", "src", ")", ")", ")", "]", ">", ";", "<FIXE>" ]

[ "def", "PSm_Int", ":", "PSI", "opc", ",", "MRMSrcMem", ",", "(", "outs", "VR128", ":", "$", "dst", ")", ",", "(", "ins", "f128mem", ":", "$", "src", ")", ",", "!", "strconcat", "(", "OpcodeStr", ",", "<STR_LIT>", ")", ",", "<BUGS>", "[", "(", "set", "VR128", ":", "$", "dst", ",", "(", "V4F32Int", "(", "load", "addr", ":", "$", "src", ")", ")", ")", "]", ">", ";", "<BUGE>", "}" ]

[ "}" ]

[ "void", "setVarArgsStackIndex", "(", "int", "Index", ")", "{", "VarArgsStackIndex", "=", "Index", ";" ]

[ "<STR_LIT>", ";" ]

[ "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "EncoderMethod", "=", "<STR_LIT>", "#", "shift", "#", "<STR_LIT>", ";", "let", "DecoderMethod", "=", "<STR_LIT>", "#", "shift", "#" ]

[ "]", ")" ]

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

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

[ "bool", "AMDGPUAsmParser", "::", "parseExpr", "(", "int64_t", "&", "Imm", ")", "{", "return", "!", "getParser", "(", ")", ".", "parseAbsoluteExpression", "(" ]

[ "itin", ";" ]

[ "dag", "InOperandList", "=", "(", "ins", "ROWS", ":", "$", "ws", ",", "vsplat_uimm6", ":", "$", "m", ")", ";", "string", "AsmString", "=", "!", "strconcat", "(", "instr_asm", ",", "<STR_LIT>", ")", ";", "list", "<", "dag", ">", "Pattern", "=", "[", "(", "set", "ROWD", ":", "$", "wd", ",", "(", "OpNode", "ROWS", ":", "$", "ws", ",", "Imm", ":", "$", "m", ")", ")", "]", ";", "InstrItinClass", "Itinerary", "=" ]

[ "bu", ".", "_", "_", "o", ")", ";" ]

[ "union", "{", "int64x1x3_t", "_", "_", "i", ";", "_", "_", "builtin_neon_ei", "_", "_", "o", ";", "}", "_", "_", "bu", "=", "{", "_", "_", "b", "}", ";", "_", "_", "builtin_neon_vst3di", "(", "(", "_", "_", "builtin_neon_di", "*", ")", "_", "_", "a", ",", "_", "_" ]

[ "let", "PredicateMethod", "=", "<STR_LIT>", "#", "Reg", "#", "<STR_LIT>", "#", "Width", "#", "<STR_LIT>", ";" ]

[ "class", "MemExtendOperand", "<", "string", "Reg", ",", "int", "Width", ">", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", "#", "Reg", "#", "<STR_LIT>", "#", "Width", ";" ]

[ "void", "WebAssemblyTargetWasmStreamer", "::", "emitLocal", "(", "ArrayRef", "<", "<STR_LIT>", "::", "<STR_LIT>", ">", "Types", ")", "{", "SmallVector", "<", "std", "::", "pair", "<", "<STR_LIT>", "::", "<STR_LIT>", ",", "uint32_t", ">", ",", "<NUM_LIT>", ">", "Grouped", ";", "for", "(", "auto", "Type", ":", "Types", ")", "{", "if", "(", "Grouped", ".", "empty", "(", ")", "||", "Grouped", ".", "back", "(", ")", ".", "first", "!=", "Type", ")", "Grouped", ".", "push_back", "(", "std", "::", "make_pair", "(", "Type", ",", "<NUM_LIT>", ")", ")", ";", "else", "++", "Grouped", ".", "back", "(", ")", ".", "second", ";", "}", "Streamer", ".", "emitULEB128IntValue", "(", "Grouped", ".", "size", "(", ")", ")", ";", "for", "(", "auto", "Pair", ":", "Grouped", ")", "{", "Streamer", ".", "emitULEB128IntValue", "(", "Pair", ".", "second", ")", ";", "emitValueType", "(", "Pair", ".", "first", ")", ";", "}", "}" ]

[ ".local" ]

[ ")", ")" ]

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

[ ";" ]

[ "bool", "ARMBlockPlacement", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "ARMSubtarget", "&", "ST", "=", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "if", "(", "!", "ST", ".", "hasLOB", "(", ")", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "DEBUG_PREFIX", "<<", "<STR_LIT>", "Running on ", "<STR_LIT>", "<<", "MF", ".", "getName", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "ST", ".", "getInstrInfo", "(", ")", ")", ";", "BBUtils", "=", "std", "::", "unique_ptr", "<", "ARMBasicBlockUtils", ">", "(", "new", "ARMBasicBlockUtils", "(", "MF", ")", ")", ";", "MF", ".", "RenumberBlocks", "(", ")", ";", "BBUtils", "->", "computeAllBlockSizes", "(", ")" ]

[ "]", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "reg", ":", "CC_NOOV", "CC_REGNUM", ")", "(", "compare", ":", "CC_NOOV", "(", "not", ":", "SI", "(", "match_operator", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Moved CPI#", "<STR_LIT>", "<<", "i", "<<", "<STR_LIT>", " to end of function, size = ", "<STR_LIT>", "<<", "Size", "<<", "<STR_LIT>", ", align = ", "<STR_LIT>", "<<", "Align", "<<", "'", "\\n", "'", ")", ";" ]

[ "BB", "->", "setAlignment", "(", "AlignConstantIslands", "?", "MaxAlign", ":", "<NUM_LIT>", ")", ";", "MF", "->", "ensureAlignment", "(", "BB", "->", "getAlignment", "(", ")", ")", ";", "SmallVector", "<", "MachineBasicBlock", "::", "iterator", ",", "<NUM_LIT>", ">", "InsPoint", "(", "MaxAlign", "+", "<NUM_LIT>", ",", "BB", "->", "end", "(", ")", ")", ";", "const", "std", "::", "vector", "<", "MachineConstantPoolEntry", ">", "&", "CPs", "=", "MCP", "->", "getConstants", "(", ")", ";", "const", "DataLayout", "&", "TD", "=", "*", "MF", "->", "getTarget", "(", ")", ".", "getDataLayout", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "CPs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Size", "=", "TD", ".", "getTypeAllocSize", "(", "CPs", "[", "i", "]", ".", "getType", "(", ")", ")", ";", "assert", "(", "Size", ">=", "<NUM_LIT>", "&&", "<STR_LIT>", "Too small constant pool entry", "<STR_LIT>", ")", ";", "unsigned", "Align", "=", "CPs", "[", "i", "]", ".", "getAlignment", "(", ")", ";", "assert", "(", "isPowerOf2_32", "(", "Align", ")", "&&", "<STR_LIT>", "Invalid alignment", "<STR_LIT>", ")", ";", "assert", "(", "(", "Size", "%", "Align", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "CP Entry not multiple of 4 bytes!", "<STR_LIT>", ")", ";", "unsigned", "LogAlign", "=", "Log2_32", "(", "Align", ")", ";", "MachineBasicBlock", "::", "iterator", "InsAt", "=", "InsPoint", "[", "LogAlign", "]", ";", "MachineInstr", "*", "CPEMI", "=", "BuildMI", "(", "*", "BB", ",", "InsAt", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "Mips", "::", "CONSTPOOL_ENTRY", ")", ")", ".", "addImm", "(", "i", ")", ".", "addConstantPoolIndex", "(", "i", ")", ".", "addImm", "(", "Size", ")", ";", "CPEMIs", ".", "push_back", "(", "CPEMI", ")", ";", "for", "(", "unsigned", "a", "=", "LogAlign", "+", "<NUM_LIT>", ";", "a", "<=", "MaxAlign", ";", "++", "a", ")", "if", "(", "InsPoint", "[", "a", "]", "==", "InsAt", ")", "InsPoint", "[", "a", "]", "=", "CPEMI", ";", "std", "::", "vector", "<", "CPEntry", ">", "CPEs", ";", "CPEs", ".", "push_back", "(", "CPEntry", "(", "CPEMI", ",", "i", ")", ")", ";", "CPEntries", ".", "push_back", "(", "CPEs", ")", ";", "++", "NumCPEs", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rx32", "{", "<NUM_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", ";" ]

[ "<STR_LIT>", ")" ]

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

[ "}" ]

[ "bool", "hasSDWAMac", "(", ")", "const", "{", "return", "HasSDWAMac", ";" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ "printU8ImmDecOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";" ]

[ "void", "AMDGPUInstPrinter", "::", "printOffset0", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNo", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "getImm", "(", ")", ")", "{", "O", "<<", "<STR_LIT>", " offset0:", "<STR_LIT>", ";" ]

[ "}" ]

[ "def", "ModImmNegAsmOperand", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", ";", "}", "def", "mod_imm_neg", ":", "Operand", "<", "i32", ">", ",", "PatLeaf", "<", "(", "imm", ")", ",", "[", "{", "unsigned", "Value", "=", "-", "(", "unsigned", ")", "N", "-", ">", "getZExtValue", "(", ")", ";", "return", "Value", "&", "&", "ARM_AM", ":", ":", "getSOImmVal", "(", "Value", ")", "!", "=", "-", "<NUM_LIT>", ";", "}", "]", ",", "imm_neg_XFORM", ">", "{", "let", "ParserMatchClass", "=", "ModImmNegAsmOperand", ";" ]

[ ")", ";" ]

[ "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", "(", ")", ";", "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", "(" ]

[ ";" ]

[ "return", "<STR_LIT>", "Z80old DAG->DAG Instruction Selection", "<STR_LIT>" ]

[ ";" ]

[ "static", "bool", "tryLess", "(", "int", "TryVal", ",", "int", "CandVal", ",", "SISchedulerCandidate", "&", "TryCand", ",", "SISchedulerCandidate", "&", "Cand", ",", "SIScheduleCandReason", "Reason", ")", "{", "if", "(", "TryVal", "<", "CandVal", ")", "{", "TryCand", ".", "Reason", "=", "Reason", ";", "return", "true", ";", "}", "if", "(", "TryVal", ">", "CandVal", ")", "{", "if", "(", "Cand", ".", "Reason", ">", "Reason", ")", "Cand", ".", "Reason", "=", "Reason", ";", "return", "true" ]

[ "<FIXS>", "static", "void", "c4x_asm_named_section", "PARAMS", "(", "(", "const", "char", "*", ",", "unsigned", "int", ")", ")", ";", "<FIXE>" ]

[ "static", "int", "c4x_label_ref_used_p", "PARAMS", "(", "(", "rtx", ",", "rtx", ")", ")", ";", "static", "int", "c4x_valid_type_attribute_p", "PARAMS", "(", "(", "tree", ",", "tree", ",", "tree", ",", "tree", ")", ")", ";", "static", "void", "c4x_insert_attributes", "PARAMS", "(", "(", "tree", ",", "tree", "*", ")", ")", ";", "<BUGS>", "static", "void", "c4x_asm_named_section", "PARAMS", "(", "(", "const", "char", "*", ",", "unsigned", "int", ",", "unsigned", "int", ")", ")", ";", "<BUGE>", "#", "undef", "TARGET_VALID_TYPE_ATTRIBUTE" ]

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

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

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

[ "for", "(", "auto", "*", "InnerML", ":", "*", "ML", ")", "Changed", "|=", "processPostOrderLoops", "(", "InnerML", ")", ";", "return", "Changed", "|", "fixBackwardsWLS", "(" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "offset", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "V", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "L", ";" ]

[ "<FIXS>", "cl", "::", "desc", "(", "<STR_LIT>", "Allow AArch64 SLI/SRI formation", "<STR_LIT>", ")", ",", "cl", "::", "init", "(", "false", ")", ")", ";", "cl", "::", "opt", "bool", ">", "EnableAArch64ELFLocalDynamicTLSGeneration", "(", "<STR_LIT>", "aarch64-elf-ldtls-generation", "<STR_LIT>", ",", "cl", "::", "Hidden", ",", "cl", "::", "desc", "(", "<STR_LIT>", "Allow AArch64 Local Dynamic TLS code generation", "<STR_LIT>", ")", ",", "cl", "::", "init", "(", "false", ")", ")", ";", "<FIXE>" ]

[ "static", "cl", "::", "opt", "bool", ">", "EnableAArch64SlrGeneration", "(", "<STR_LIT>", "aarch64-shift-insert-generation", "<STR_LIT>", ",", "cl", "::", "Hidden", ",", "<BUGS>", "cl", "::", "desc", "(", "<STR_LIT>", "Allow AArch64 SLI/SRI formation", "<STR_LIT>", ")", ",", "cl", "::", "init", "(", "false", ")", ")", ";", "<BUGE>", "AArch64TargetLowering", "::", "AArch64TargetLowering", "(", "const", "TargetMachine", "&", "TM", ",", "const", "AArch64Subtarget", "&", "STI", ")" ]

[ "<FIXS>", "case", "E_SFmode", ":", "<FIXE>", "<FIXS>", "case", "E_DFmode", ":", "<FIXE>" ]

[ "case", "FLOAT_EXTEND", ":", "switch", "(", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "{", "<BUGS>", "case", "SFmode", ":", "<BUGE>", "func", "=", "<STR_LIT>", "_Qp_stoq", "<STR_LIT>", ";", "break", ";", "<BUGS>", "case", "DFmode", ":", "<BUGE>", "func", "=", "<STR_LIT>", "_Qp_dtoq", "<STR_LIT>", ";", "break", ";", "default", ":" ]

[ ";" ]

[ "SmallVector", "<", "const", "MCInstrDesc", "*", ",", "MaxNumRepl", ">", "ReplInstrMCID", ";", "switch", "(", "SP", ")", "{", "case", "VectorElem", ":", "OriginalMCID", "=", "&", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "ReplInstrMCID", ".", "push_back", "(", "&", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "ReplInstrMCID", ".", "push_back", "(", "&", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "if", "(", "shouldReplaceInst", "(", "MF", ",", "OriginalMCID", ",", "ReplInstrMCID", ")", ")", "return", "false", ";", "break", ";", "case", "Interleave", ":", "std", "::", "string", "Subtarget", "=", "std", "::", "string", "(", "SchedModel", ".", "getSubtargetInfo", "(", ")", "->", "getCPU", "(", ")", ")", ";", "auto", "It", "=", "InterlEarlyExit", ".", "find", "(", "Subtarget", ")", ";", "if", "(", "It", "!=", "InterlEarlyExit", ".", "end", "(", ")", ")", "return", "It", "->", "second", ";", "for", "(", "auto", "&", "I", ":", "IRT", ")", "{", "OriginalMCID", "=", "&", "TII", "->", "get", "(", "I", ".", "OrigOpc", ")", ";", "for", "(", "auto", "&", "Repl", ":", "I", ".", "ReplOpc", ")", "ReplInstrMCID", ".", "push_back", "(", "&", "TII", "->", "get", "(", "Repl", ")", ")", ";", "if", "(", "shouldReplaceInst", "(", "MF", ",", "OriginalMCID", ",", "ReplInstrMCID", ")", ")", "{", "InterlEarlyExit", "[", "Subtarget", "]", "=", "false", ";", "return", "false" ]

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

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

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

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

[ "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_gathersiv4si", "(", "_", "_", "src", ",", "_", "_", "base", ",", "(", "_", "_", "v4si", ")", "_", "_", "index", ",", "_", "_", "mask", ",", "_", "_", "scale", ")", ";" ]

[ "_", "_", "v4si", "_", "_", "src", "=", "_", "_", "extension__", "(", "_", "_", "v4si", ")", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ";", "_", "_", "v4si", "_", "_", "mask", "=", "_", "_", "extension__", "(", "_", "_", "v4si", ")", "{", "~", "<NUM_LIT>", ",", "~", "<NUM_LIT>", ",", "~", "<NUM_LIT>", ",", "~", "<NUM_LIT>", "}", ";" ]

[ "<STR_LIT>" ]

[ "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "fix", ":", "SI", "(", "match_operand", ":", "IBM128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "clobber", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "clobber", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "clobber", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

[ "std", ":", ":", "swap", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")" ]

[ "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "lt", ":", "VI1_AVX2", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", "UNSPEC_BLENDV", ")", ")", "]", "{", "if", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "=", "=", "<NUM_LIT>", ")" ]

[ "SDValue", "PPCTargetLowering", "::", "LowerCall", "(", "TargetLowering", "::", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "SDLoc", "&", "dl", "=", "CLI", ".", "DL", ";", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", "=", "CLI", ".", "Outs", ";", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", "=", "CLI", ".", "OutVals", ";", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", "=", "CLI", ".", "Ins", ";", "SDValue", "Chain", "=", "CLI", ".", "Chain", ";", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "bool", "&", "isTailCall", "=", "CLI", ".", "IsTailCall", ";", "CallingConv", "::", "ID", "CallConv", "=", "CLI", ".", "CallConv", ";", "bool", "isVarArg", "=", "CLI", ".", "IsVarArg", ";", "if", "(", "isTailCall", ")", "isTailCall", "=", "IsEligibleForTailCallOptimization", "(", "Callee", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "DAG", ")", ";", "if", "(", "!", "isTailCall", "&&", "CLI", ".", "CS", "&&", "CLI", ".", "CS", "->", "isMustTailCall", "(", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "failed to perform tail call elimination on a call ", "<STR_LIT>", "<STR_LIT>", "site marked musttail", "<STR_LIT>", ")", ";", "if", "(", "PPCSubTarget", ".", "isSVR4ABI", "(", ")", ")", "{", "if", "(", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "return", "LowerCall_64SVR4", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "else", "return", "LowerCall_32SVR4", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "return", "LowerCall_Darwin", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "calls", "into", "the", "specified", "DAG", "." ]

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

[ "}", "}", "[", "(", "set", "(", "attr", "<STR_LIT>", ")", "<BUGS>", "(", "cond", "[", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "const_string", "<STR_LIT>", ")", "<BUGS>", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "const_string", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")" ]

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

[ "(", "unspec", ":", "DI", "[", "(", "unsigned_fix", ":", "SI", "(", "match_operand", ":", "SFDF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "UNSPEC_FCTIWUZ", ")", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "<STR_LIT>" ]

[ "<FIXS>", "let", "isCodeGenOnly", "=", "<NUM_LIT>", ",", "CCMaskFirst", "=", "<NUM_LIT>", "in", "{", "<FIXE>" ]

[ "let", "isBranch", "=", "<NUM_LIT>", ",", "isTerminator", "=", "<NUM_LIT>", ",", "Uses", "=", "[", "CC", "]", "in", "{", "<BUGS>", "let", "isCodeGenOnly", "=", "<NUM_LIT>", "in", "{", "<BUGE>", "def", "BRC", ":", "InstRI", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", "cond4", ":", "$", "valid", ",", "cond4", ":", "$", "R1", ",", "brtarget16", ":", "$", "I2", ")", ",", "<STR_LIT>", ",", "[", "(", "z_br_ccmask", "cond4", ":", "$", "valid", ",", "cond4", ":", "$", "R1", ",", "bb", ":", "$", "I2", ")", "]", ">", ";" ]

[ "}" ]

[ "void", "F2003fInstrInfo", "::", "getNoop", "(", "MCInst", "&", "NopInst", ")", "const", "{", "NopInst", ".", "setOpcode", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";" ]

[ "MI2", ",", "QII", ")", ";" ]

[ "if", "(", "PacketSU", "->", "Succs", "[", "i", "]", ".", "getSUnit", "(", ")", "==", "SU", "&&", "PacketSU", "->", "Succs", "[", "i", "]", ".", "getKind", "(", ")", "==", "SDep", "::", "Data", "&&", "Hexagon", "::", "PredRegsRegClass", ".", "contains", "(", "PacketSU", "->", "Succs", "[", "i", "]", ".", "getReg", "(", ")", ")", "&&", "RestrictingDepExistInPacket", "(", "*", "VIN", ",", "PacketSU", "->", "Succs", "[", "i", "]", ".", "getReg", "(", ")", ",", "MIToSUnit", ")", ")", "{", "return", "false", ";", "}", "}", "}", "}", "unsigned", "PReg1", "=", "getPredicatedRegister", "(", "MI1", ",", "QII", ")", ";", "unsigned", "PReg2", "=", "getPredicatedRegister", "(" ]

[ "_", "_", "rv", ".", "val", "[", "<NUM_LIT>", "]", "=", "_", "_", "builtin_shuffle", "(", "_", "_", "a", ",", "_", "_", "b", ",", "(", "uint16x4_t", ")", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ";" ]

[ "uint16x4x2_t", "_", "_", "rv", ";", "_", "_", "rv", ".", "val", "[", "<NUM_LIT>", "]", "=", "_", "_", "builtin_shuffle", "(", "_", "_", "a", ",", "_", "_", "b", ",", "(", "uint16x4_t", ")", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ";", "_", "_", "rv", ".", "val", "[", "<NUM_LIT>", "]", "=", "_", "_", "builtin_shuffle", "(", "_", "_", "a", ",", "_", "_", "b", ",", "(", "uint16x4_t", ")", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ";" ]

[ "<STR_LIT>", ")" ]

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

[ ")", ".", "getIndex", "(", ")", ";" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "if", "(", "!", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isFI", "(", ")", ")", "return", "<NUM_LIT>", ";", "FrameIndex", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>" ]

[ ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ",", "DL", ")", ")", ";" ]

[ "SDLoc", "DL", "(", "N", ")", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "SDValue", "Op0", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Op1", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "VT", ".", "isVector", "(", ")", "||", "!", "VT", ".", "isSimple", "(", ")", "||", "!", "(", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i32", ")", ")", "return", "SDValue", "(", ")", ";", "unsigned", "RegSize", "=", "<NUM_LIT>", ";", "if", "(", "Subtarget", ".", "hasBWI", "(", ")", ")", "RegSize", "=", "<NUM_LIT>", ";", "else", "if", "(", "Subtarget", ".", "hasAVX2", "(", ")", ")", "RegSize", "=", "<NUM_LIT>", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "/", "<NUM_LIT>", ">", "RegSize", ")", "return", "SDValue", "(", ")", ";", "SDValue", "SelectOp", ",", "Phi", ";", "if", "(", "Op0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "VSELECT", ")", "{", "SelectOp", "=", "Op0", ";", "Phi", "=", "Op1", ";", "}", "else", "if", "(", "Op1", ".", "getOpcode", "(", ")", "==", "ISD", "::", "VSELECT", ")", "{", "SelectOp", "=", "Op1", ";", "Phi", "=", "Op0", ";", "}", "else", "return", "SDValue", "(", ")", ";", "if", "(", "!", "detectZextAbsDiff", "(", "SelectOp", ",", "Op0", ",", "Op1", ")", ")", "return", "SDValue", "(", ")", ";", "SDValue", "Sad", "=", "createPSADBW", "(", "DAG", ",", "Op0", ",", "Op1", ",", "DL", ")", ";", "MVT", "ResVT", "=", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i32", ",", "Sad", ".", "getValueType", "(", ")", ".", "getSizeInBits", "(", ")", "/", "<NUM_LIT>", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", ">=", "ResVT", ".", "getSizeInBits", "(", ")", ")", "Sad", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "ResVT", ",", "Sad", ")", ";", "else", "Sad", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "VT", ",", "Sad", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", ">", "ResVT", ".", "getSizeInBits", "(", ")", ")", "{", "SDValue", "SubPhi", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "DL", ",", "ResVT", ",", "Phi" ]

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

[ "Unsigned", "=", "<NUM_LIT>", ";", "}", "else", "if", "(", "!", "isa", "<", "ZExtInst", ">", "(", "Extend", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "masked gathers: extend needed but not provided. ", "<STR_LIT>", "<<", "<STR_LIT>", "Expanding\\n", "<STR_LIT>", ")", ";", "return", "nullptr", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "masked gathers: found an extending gather\\n", "<STR_LIT>", ")", ";", "ResultTy", "=", "Extend", "->", "getType", "(", ")", ";", "if", "(", "ResultTy", "->", "getPrimitiveSizeInBits", "(", ")", "!=", "<NUM_LIT>", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "masked gathers: extending from the wrong type. ", "<STR_LIT>", "<<", "<STR_LIT>", "Expanding\\n", "<STR_LIT>", ")", ";", "return", "nullptr", ";", "}", "}", "GetElementPtrInst", "*", "GEP", "=", "dyn_cast", "<", "GetElementPtrInst", ">", "(", "Ptr", ")", ";", "Value", "*", "Offsets", ";", "Value", "*", "BasePtr", "=", "checkGEP", "(", "Offsets", ",", "ResultTy", ",", "GEP", ",", "Builder", ")", ";", "if", "(", "!", "BasePtr", ")", "return", "nullptr", ";", "Value", "*", "Load", "=", "tryCreateIncrementingGatScat", "(", "I", ",", "BasePtr", ",", "Offsets", ",", "GEP" ]

[ "<NUM_LIT>", ";" ]

[ "MachineInstr", "*", "predSet", "=", "findFirstPredicateSetterFrom", "(", "MBB", ",", "I", ")", ";", "clearFlag", "(", "*", "predSet", ",", "<NUM_LIT>", ",", "MO_FLAG_PUSH", ")", ";", "I", "->", "eraseFromParent", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "CfAlu", "=", "FindLastAluClause", "(", "MBB", ")", ";", "if", "(", "CfAlu", "==", "MBB", ".", "end", "(", ")", ")", "break", ";", "assert", "(", "CfAlu", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "CfAlu", "->", "setDesc", "(", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "break", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "I", "->", "eraseFromParent", "(", ")", ";", "break", ";", "}", "I", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "{", "return", "<NUM_LIT>", ";", "}", "--", "I", ";", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return" ]

[ "(", "DF" ]

[ "(", "BI", "<STR_LIT>", ")", "(", "QI", "<STR_LIT>", ")", "(", "HI", "<STR_LIT>", ")", "(", "SI", "<STR_LIT>", ")", "(", "DI", "<STR_LIT>", ")", "(", "SF", "<STR_LIT>", ")" ]

[ "if", "(", "TPCResult", ")", "llvm", "::", "errs", "(", ")", "<<", "<STR_LIT>", "print result: ", "<STR_LIT>", "+", "val", "+", "<STR_LIT>", "\\n", "<STR_LIT>", ";" ]

[ "DominatorTree", "&", "DT", "=", "getAnalysis", "<", "DominatorTreeWrapperPass", ">", "(", ")", ".", "getDomTree", "(", ")", ";", "SCE", "=", "new", "SCEVExpander", "(", "SE", ",", "SE", ".", "getDataLayout", "(", ")", ",", "<STR_LIT>", "expander", "<STR_LIT>", ")", ";", "TPC_DEBUG", "(", "<STR_LIT>", "Init graph presentation:\\n", "<STR_LIT>", ")", ";", "CostTree", "graph", "(", "&", "Fn", ",", "LI", ",", "SE", ",", "MLI", ",", "DT", ")", ";", "if", "(", "!", "graph", ".", "getValid", "(", ")", ")", "return", "false", ";", "if", "(", "printGraphB", ")", "printGraph", "(", "<STR_LIT>", "CFG-", "<STR_LIT>", ",", "graph", ")", ";", "TPC_DEBUG", "(", "<STR_LIT>", "Graph segmenting:\\n", "<STR_LIT>", ")", ";", "graph", ".", "consumeCircle", "(", ")", ";", "if", "(", "!", "graph", ".", "isValid", "(", ")", ")", "{", "TPC_DEBUG", "(", "<STR_LIT>", "not valid model", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "if", "(", "printGraphB", ")", "printGraph", "(", "<STR_LIT>", "cfg-cost", "<STR_LIT>", ",", "graph", ")", ";", "TPC_DEBUG", "(", "<STR_LIT>", "Graph calculation:\\n", "<STR_LIT>", ")", ";", "const", "SCEV", "*", "init", "=", "graph", ".", "computeCostTree", "(", "graph", ".", "getRoot", "(", ")", ",", "DT", ")", ";", "if", "(", "!", "init", ")", "{", "TPC_DEBUG", "(", "<STR_LIT>", "not valid model", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "llvm", "::", "Module", "*", "M", "=", "(", "llvm", "::", "Module", "*", ")", "Fn", ".", "getFunction", "(", ")", ".", "getParent", "(", ")", ";", "std", "::", "vector", "<", "const", "Argument", "*", ">", "argList", ";", "for", "(", "auto", "&", "fArg", ":", "Fn", ".", "getFunction", "(", ")", ".", "args", "(", ")", ")", "{", "argList", ".", "push_back", "(", "&", "fArg", ")", ";", "}", "string", "val", "=", "printHelper", "(", "init", ",", "argList", ")", ";", "if", "(", "!", "isValidCostModel", ")", "{", "TPC_DEBUG", "(", "<STR_LIT>", "not valid model", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "val", "=", "<STR_LIT>", "SCEVBEGIN SCEVCOST:", "<STR_LIT>", "+", "val", "+", "<STR_LIT>", "#SCEVEND", "<STR_LIT>", ";", "TPC_DEBUG", "(", "<STR_LIT>", "print result:", "<STR_LIT>", "+", "val", "+", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";" ]

[ "Reserved", ".", "set", "(", "AMDGPU", "::", "EXEC", ")", ";" ]

[ "BitVector", "SIRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";" ]

[ ";" ]

[ "BytesInStackArgArea", "=", "Bytes" ]

[ "let", "DecoderMethod", "=", "<STR_LIT>", "#", "shift", "#", "<STR_LIT>", ";" ]

[ "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "!", "cast", "<", "AsmOperandClass", ">", "(", "<STR_LIT>", "#", "shift", "#", "<STR_LIT>", ")", ";" ]

[ "<STR_LIT>", ")" ]

[ "(", "define_automaton" ]

[ ":", "$", "sy", ",", "v256f64", ":", "$", "vz", ",", "v512i1", ":", "$", "vm", ",", "i32", ":", "$", "vl", ",", "v256f64", ":", "$", "pt", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "int_ve_vl_pvfmin_vsvMvl", "i64", ":", "$", "sy", ",", "v256f64", ":", "$", "vz", ",", "v512i1", ":", "$", "vm", ",", "v256f64", ":", "$", "pt", ",", "i32", ":", "$", "vl", ")", ",", "(", "PVFMINrvml_v", "i64" ]

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

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