Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "}", ")" ]

[ "(", "define_peephole2", "[", "(", "set", "(", "match_operand", ":", "ALL1", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "lshiftrt", ":", "ALL1", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "match_scratch", ":", "QI", "<NUM_LIT>", "<STR_LIT>", ")", "]", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "rotate", ":", "QI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "and", ":", "QI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]", "{", "operands", "[", "<NUM_LIT>", "]", "=", "avr_to_int_mode", "(", "operands", "[", "<NUM_LIT>", "]", ")" ]

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

[ "(", "unspec", ":", "V2HI", "[", "(", "match_operand", ":", "V2SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "reg", ":", "DI", "GSR_REG", ")", "]", "UNSPEC_FPACKFIX", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ ")", ";" ]

[ "debug_tree", "(", "pop_target", ")", ";", "}", "else", "fprintf", "(", "stderr", ",", "<STR_LIT>", "pop_target: <NULL>\\n", "<STR_LIT>", ")", ";", "fprintf", "(", "stderr", ",", "<STR_LIT>", "--------------------\\n", "<STR_LIT>", ")", ";", "}", "if", "(", "!", "args", ")", "{", "cur_tree", "=", "(", "(", "pop_target", ")", "?", "pop_target", ":", "target_option_default_node", ")", ";", "cl_target_option_restore", "(", "&", "global_options", ",", "TREE_TARGET_OPTION", "(", "cur_tree", ")", ")", ";", "}", "else", "{", "rs6000_cpu_index", "=", "rs6000_tune_index", "=", "-", "<NUM_LIT>", ";", "if", "(", "!", "rs6000_inner_target_options", "(", "args", ",", "false", ")", "||", "!", "rs6000_option_override_internal", "(", "false", ")", "||", "(", "cur_tree", "=", "build_target_option_node", "(", "&", "global_options", ")", ")", "==", "NULL_TREE", ")", "{", "if", "(", "TARGET_DEBUG_BUILTIN", "||", "TARGET_DEBUG_TARGET", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "invalid pragma\\n", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "}", "target_option_current_node", "=", "cur_tree", ";", "if", "(", "rs6000_target_modify_macros_ptr", ")", "{", "prev_opt", "=", "TREE_TARGET_OPTION", "(", "prev_tree", ")", ";", "prev_bumask", "=", "prev_opt", "->", "x_rs6000_builtin_mask", ";", "prev_flags", "=", "prev_opt", "->", "x_rs6000_isa_flags", ";", "cur_opt", "=", "TREE_TARGET_OPTION", "(", "cur_tree" ]

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

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

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

[ "if", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "&", "~", "(", "unsigned", "HOST_WIDE_INT", ")", "<", "DSPV", ":", "dspshift_mask", ">", ")", "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "&", "<", "DSPV", ":", "dspshift_mask", ">", ")", "return", "<STR_LIT>", "}", "return", "<STR_LIT>", "}", "[", "(", "set_attr", "<STR_LIT>", "\t", "<STR_LIT>", ")" ]

[ "<FIXS>", ".", "addReg", "(", "DstReg", ",", "RegState", "::", "Kill", ")", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", ".", "addReg", "(", "DstReg", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "DstReg", ",", "RegState", "::", "Kill", ")", ";", "<FIXE>" ]

[ "buildMI", "(", "MBB", ",", "MBBI", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "DstReg", ",", "RegState", "::", "Define", "|", "getDeadRegState", "(", "DstIsDead", ")", ")", "<BUGS>", ".", "addReg", "(", "DstReg", ",", "getKillRegState", "(", "DstIsKill", ")", ")", "<BUGE>", "<BUGS>", "getOperand", "(", "<NUM_LIT>", ")", "<BUGE>", ".", "setIsUndef", "(", "true", ")", ";", "buildMI", "(", "MBB", ",", "MBBI", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "DstReg", ",", "RegState", "::", "Define", "|", "getDeadRegState", "(", "DstIsDead", ")", ")", "<BUGS>", ".", "addReg", "(", "DstReg", ",", "getKillRegState", "(", "DstIsKill", ")", ")", ".", "addReg", "(", "DstReg", ",", "getKillRegState", "(", "DstIsKill", ")", ")", ";", "<BUGE>", "auto", "MIRRC", "=", "buildMI", "(", "MBB", ",", "MBBI", ",", "<STR_LIT>", "::", "<STR_LIT>", ")" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "X87MODEI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "fix", ":", "X87MODEI", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "match_operand", ":", "X87MODEI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "clobber", "(", "match_scratch", ":", "XF", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr" ]

[ "createGenericVirtualRegister", "(", "PartLLT", ")", ";" ]

[ "EVT", "VT", "=", "EVT", "::", "getEVT", "(", "CurSplitArg", ".", "Ty", ")", ";", "LLT", "LLTy", "=", "getLLTForType", "(", "*", "CurSplitArg", ".", "Ty", ",", "DL", ")", ";", "unsigned", "NumParts", "=", "TLI", ".", "getNumRegistersForCallingConv", "(", "Ctx", ",", "CallConv", ",", "VT", ")", ";", "MVT", "RegVT", "=", "TLI", ".", "getRegisterTypeForCallingConv", "(", "Ctx", ",", "CallConv", ",", "VT", ")", ";", "if", "(", "NumParts", "==", "<NUM_LIT>", ")", "{", "SplitArgs", ".", "emplace_back", "(", "Reg", ",", "CurSplitArg", ".", "Ty", ",", "OrigArg", ".", "Flags", ",", "OrigArg", ".", "IsFixed", ")", ";", "continue", ";", "}", "SmallVector", "<", "Register", ",", "<NUM_LIT>", ">", "SplitRegs", ";", "Type", "*", "PartTy", "=", "EVT", "(", "RegVT", ")", ".", "getTypeForEVT", "(", "Ctx", ")", ";", "LLT", "PartLLT", "=", "getLLTForType", "(", "*", "PartTy", ",", "DL", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "*", "B", ".", "getMRI", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "NumParts", ";", "++", "i", ")", "{", "Register", "PartReg", "=", "MRI", "." ]

[ "<STR_LIT>" ]

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

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

[ "def", "UD", ":", "ASuInp", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "SPR", ":", "$", "Sd", ")", ",", "(", "ins", "DPR", ":", "$", "Dm", ")", ",", "NoItinerary", ",", "!", "strconcat", "(", "<STR_LIT>", ",", "opc", ",", "<STR_LIT>", ")", ",", "[", "]", ">", ",", "Requires", "<", "[", "HasFPARMv8", ",", "HasDPVFP", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Dm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "rm", ";" ]

[ "unsigned", "NumElts", "=", "std", "::", "min", "(", "DataVT", ".", "getVectorNumElements", "(", ")", ",", "IndexVT", ".", "getVectorNumElements", "(", ")", ")", ";" ]

[ "case", "GATHER", ":", "case", "GATHER_AVX2", ":", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "ptrVal", "=", "nullptr", ";", "MVT", "DataVT", "=", "MVT", "::", "getVT", "(", "I", ".", "getType", "(", ")", ")", ";", "MVT", "IndexVT", "=", "MVT", "::", "getVT", "(", "I", ".", "getArgOperand", "(", "<NUM_LIT>", ")", "->", "getType", "(", ")", ")", ";", "unsigned", "NumElts", "=", "std", "::", "min", "(", "DataVT", ".", "getVectorNumElements", "(", ")", ",", "IndexVT", ".", "getVectorNumElements", "(", ")", ")", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVectorVT", "(", "DataVT", ".", "getVectorElementType", "(", ")", ",", "NumElts", ")", ";", "Info", ".", "align", "=", "<NUM_LIT>", ";", "Info", ".", "flags", "|=", "MachineMemOperand", "::", "MOLoad", ";", "break", ";", "}", "case", "SCATTER", ":", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_VOID", ";", "Info", ".", "ptrVal", "=", "nullptr", ";", "MVT", "DataVT", "=", "MVT", "::", "getVT", "(", "I", ".", "getArgOperand", "(", "<NUM_LIT>", ")", "->", "getType", "(", ")", ")", ";", "MVT", "IndexVT", "=", "MVT", "::", "getVT", "(", "I", ".", "getArgOperand", "(", "<NUM_LIT>", ")", "->", "getType", "(", ")", ")", ";" ]

[ "}" ]

[ "SILowerControlFlowPass", "(", "TargetMachine", "&", "tm", ")", ":", "MachineFunctionPass", "(", "ID", ")", ",", "TRI", "(", "tm", ".", "getRegisterInfo", "(", ")", ")", ",", "TII", "(", "tm", ".", "getInstrInfo", "(", ")", ")", "{" ]

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

[ "if", "(", "InVT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", ")", "return", "LowerSIGN_EXTEND_Mask", "(", "Op", ",", "Subtarget", ",", "DAG", ")", ";", "assert", "(", "Subtarget", ".", "hasAVX", "(", ")", "&&", "<STR_LIT>", "Expected AVX support", "<STR_LIT>", ")", ";", "return", "LowerAVXExtend", "(", "Op", ",", "DAG" ]

[ "fputs", "(", "<STR_LIT>", "\\t.extern\\t", "<STR_LIT>", ",", "file", ")", ";" ]

[ "default_elf_asm_output_external", "(", "file", ",", "decl", ",", "name", ")", ";", "if", "(", "TREE_SYMBOL_REFERENCED", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ")", "{", "if", "(", "!", "TARGET_EXPLICIT_RELOCS", "&&", "mips_in_small_data_p", "(", "decl", ")", ")", "{" ]

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

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

[ "(", "ss_minus", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "truncate", ":", "SI", "(", "lshiftrt", ":", "DI", "(", "mult", ":", "DI", "(", "sign_extend", ":", "DI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "sign_extend", ":", "DI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

[ "<NUM_LIT>", ";" ]

[ "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "WordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=" ]

[ "static", "reg_class_t", "s390_secondary_reload", "(", "bool", "in_p", ",", "rtx", "x", ",", "reg_class_t", "rclass_i", ",", "machine_mode", "mode", ",", "secondary_reload_info", "*", "sri", ")", "{", "enum", "reg_class", "rclass", "=", "(", "enum", "reg_class", ")", "rclass_i", ";", "if", "(", "reg_classes_intersect_p", "(", "CC_REGS", ",", "rclass", ")", ")", "return", "GENERAL_REGS", ";", "if", "(", "TARGET_VX", ")", "{", "if", "(", "MEM_P", "(", "x", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "==", "CONST_INT", "&&", "!", "SHORT_DISP_IN_RANGE", "(", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ")", "&&", "reg_class_subset_p", "(", "rclass", ",", "VEC_REGS", ")", "&&", "(", "!", "reg_class_subset_p", "(", "rclass", ",", "FP_REGS", ")", "||", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "<NUM_LIT>", "&&", "s390_class_max_nregs", "(", "FP_REGS", ",", "mode", ")", "==", "<NUM_LIT>", ")", ")", ")", "{", "if", "(", "in_p", ")", "sri", "->", "icode", "=", "(", "TARGET_64BIT", "?", "CODE_FOR_reloaddi_la_in", ":", "CODE_FOR_reloadsi_la_in", ")", ";", "else", "sri", "->", "icode", "=", "(", "TARGET_64BIT", "?", "CODE_FOR_reloaddi_la_out", ":", "CODE_FOR_reloadsi_la_out", ")", ";", "}", "}", "if", "(", "TARGET_Z10", ")", "{", "HOST_WIDE_INT", "offset", ";", "rtx", "symref", ";", "if", "(", "in_p", "&&", "s390_loadrelative_operand_p", "(", "x", ",", "&", "symref", ",", "&", "offset", ")", "&&", "mode", "==", "Pmode", "&&", "(", "!", "SYMBOL_REF_P", "(", "symref", ")", "||", "!", "SYMBOL_FLAG_NOTALIGN2_P", "(", "symref", ")", ")", "&&", "(", "offset", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "sri", "->", "icode", "=", "(", "(", "mode", "==", "DImode", ")", "?", "CODE_FOR_reloaddi_larl_odd_addend_z10", ":", "CODE_FOR_reloadsi_larl_odd_addend_z10", ")", ";", "if", "(", "MEM_P", "(", "x", ")", "&&", "s390_loadrelative_operand_p", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "NULL", ",", "NULL", ")", "&&", "(", "mode", "==", "QImode", "||", "!", "reg_class_subset_p", "(", "rclass", ",", "GENERAL_REGS", ")", "||", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", "||", "!", "s390_check_symref_alignment", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ")", ")", "{", "case", "E_", "#", "#", "M", "#", "#", "mode", ":", "\\", "if", "(", "TARGET_64BIT", ")", "\\", "sri", "->", "icode", "=", "in_p", "?", "CODE_FOR_reload", "#", "#", "m", "#", "#", "di_toreg_z10", ":", "\\", "CODE_FOR_reload", "#", "#", "m", "#", "#", "di_tomem_z10", ";", "\\", "else", "\\", "sri", "->", "icode", "=", "in_p", "?", "CODE_FOR_reload", "#", "#", "m", "#", "#", "si_toreg_z10", ":", "\\", "CODE_FOR_reload", "#", "#", "m", "#", "#", "si_tomem_z10", ";", "\\", "break", ";", "switch", "(", "GET_MODE", "(", "x", ")", ")", "{", "_", "_", "SECONDARY_RELOAD_CASE", "(", "QI", ",", "qi", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "HI", ",", "hi", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "SI", ",", "si", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "DI", ",", "di", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "TI", ",", "ti", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "SF", ",", "sf", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "DF", ",", "df", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "TF", ",", "tf", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "SD", ",", "sd", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "DD", ",", "dd", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "TD", ",", "td", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "V1QI", ",", "v1qi", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "V2QI", ",", "v2qi", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "V4QI", ",", "v4qi", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "V8QI", ",", "v8qi", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "V16QI", ",", "v16qi", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "V1HI", ",", "v1hi", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "V2HI", ",", "v2hi", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "V4HI", ",", "v4hi", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "V8HI", ",", "v8hi", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "V1SI", ",", "v1si", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "V2SI", ",", "v2si", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "V4SI", ",", "v4si", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "V1DI", ",", "v1di", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "V2DI", ",", "v2di", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "V1TI", ",", "v1ti", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "V1SF", ",", "v1sf", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "V2SF", ",", "v2sf", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "V4SF", ",", "v4sf", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "V1DF", ",", "v1df", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "V2DF", ",", "v2df", ")", ";", "_", "_", "SECONDARY_RELOAD_CASE", "(", "V1TF", ",", "v1tf", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "}", "if", "(", "!", "lra_in_progress", "&&", "in_p", "&&", "s390_plus_operand", "(", "x", ",", "mode", ")", ")", "sri", "->", "icode", "=", "(", "TARGET_64BIT", "?", "CODE_FOR_reloaddi_plus", ":", "CODE_FOR_reloadsi_plus", ")", ";", "if", "(", "MEM_P", "(", "x", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "==", "CONST_INT", "&&", "!", "DISP_IN_RANGE", "(", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "+", "GET_MODE_SIZE", "(", "mode", ")", "-", "<NUM_LIT>", ")", ")", "{", "if", "(", "(", "reg_classes_intersect_p", "(", "GENERAL_REGS", ",", "rclass", ")", "&&", "s390_class_max_nregs", "(", "GENERAL_REGS", ",", "mode", ")", ">", "<NUM_LIT>", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "==", "PLUS", ")", "||", "(", "reg_classes_intersect_p", "(", "FP_REGS", ",", "rclass", ")", "&&", "s390_class_max_nregs", "(", "FP_REGS", ",", "mode", ")", ">", "<NUM_LIT>", ")", ")", "{", "if", "(", "in_p", ")", "sri", "->", "icode", "=", "(", "TARGET_64BIT", "?", "CODE_FOR_reloaddi_la_in", ":", "CODE_FOR_reloadsi_la_in", ")", ";", "else", "sri", "->", "icode", "=", "(", "TARGET_64BIT", "?", "CODE_FOR_reloaddi_la_out", ":", "CODE_FOR_reloadsi_la_out", ")", ";", "}", "}", "if", "(", "in_p", "&&", "SYMBOLIC_CONST", "(", "x", ")", "&&", "flag_pic", "==", "<NUM_LIT>", "&&", "rclass", "!=", "ADDR_REGS", ")", "sri", "->", "icode", "=", "(", "TARGET_64BIT", "?", "CODE_FOR_reloaddi_PIC_addr", ":", "CODE_FOR_reloadsi_PIC_addr", ")", ";", "return", "NO_REGS", ";", "}" ]

[ "Inform", "reload", "about", "cases", "where", "moving", "X", "with", "a", "mode", "MODE", "to", "a", "register", "in", "RCLASS", "requires", "an", "extra", "scratch", "or", "immediate", "register", ".", "Return", "the", "class", "needed", "for", "the", "immediate", "register", "." ]

[ "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";" ]

[ "let", "InOperandList", "=", "(", "ins", "DataType", ":", "$", "optype", ",", "Rsrc", ":", "$", "src", ",", "SwitchSet", ":", "$", "sw", ",", "Rdst", ":", "$", "income", ",", "SPred", ":", "$", "pred", ")", ";", "let", "Pattern", "=", "pattern", ";", "let", "Itinerary", "=", "IIC_LoadComplexOp", ";", "bits", "<", "<NUM_LIT>", ">", "dest", ";", "bits", "<", "<NUM_LIT>", ">", "src", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "SrcA", "=", "src", ";", "let", "Dest", "=", "dest", ";", "let", "SrcExtra", "=", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ";", "let", "Switches", "=", "sw", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "VectorPred", "=", "<NUM_LIT>", ";" ]

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

[ "bool", "S0IsUnsigned", "=", "Known0", ".", "countMinLeadingZeros", "(", ")", ">", "<NUM_LIT>", ";", "bool", "S0IsSigned", "=", "Known0", ".", "countMinLeadingOnes", "(", ")", ">", "<NUM_LIT>", ";", "auto", "Known1", "=", "DAG", ".", "computeKnownBits", "(", "S1Op", ",", "<NUM_LIT>", ")", ";", "bool", "S1IsUnsigned", "=", "Known1", ".", "countMinLeadingZeros", "(", ")", ">", "<NUM_LIT>", ";", "bool", "S1IsSigned", "=", "Known1", ".", "countMinLeadingOnes", "(", ")", ">", "<NUM_LIT>", ";", "assert", "(", "!", "(", "S0IsUnsigned", "&&", "S0IsSigned", ")", ")", ";", "assert", "(", "!", "(", "S1IsUnsigned", "&&", "S1IsSigned", ")", ")", ";", "if", "(", "(", "S0IsUnsigned", "&&", "S1IsUnsigned", ")", "||", "(", "S0IsSigned", "&&", "S1IsSigned", ")", ")", "return", "S0IsSigned", ";", "if", "(", "(", "S0IsUnsigned", "&&", "S1IsSigned", ")", "||", "(", "S0IsSigned", "&&", "S1IsUnsigned", ")", ")", "return", "std", "::", "nullopt", ";", "if", "(", "(", "S0IsSigned", "&&", "!", "(", "S1IsSigned", "||", "S1IsUnsigned", ")", ")", "||", "(", "(", "S1IsSigned", "&&", "!", "(", "S0IsSigned", "||", "S0IsUnsigned", ")", ")", ")", ")", "return", "true", ";", "if", "(", "(", "!", "(", "S1IsSigned", "||", "S1IsUnsigned", ")", "&&", "!", "(", "S0IsSigned", "||", "S0IsUnsigned", ")" ]

[ "}" ]

[ "if", "(", "EnableCCMP", ")", "addPass", "(", "createAArch64ConditionalCompares", "(", ")", ")", ";", "if", "(", "EnableMCR", ")", "addPass", "(", "&", "MachineCombinerID", ")", ";", "if", "(", "EnableCondBrTuning", ")", "addPass", "(", "createAArch64CondBrTuning", "(", ")", ")", ";", "if", "(", "EnableEarlyIfConversion", ")", "addPass", "(", "&", "EarlyIfConverterID", ")", ";", "if", "(", "EnableStPairSuppress", ")", "addPass", "(", "createAArch64StorePairSuppressPass", "(", ")", ")", ";", "addPass", "(", "createAArch64VectorByElementOptPass", "(", ")", ")", ";", "return", "true", ";" ]

[ "}" ]

[ "bool", "ARMBaseTargetMachine", "::", "addCodeEmitter", "(", "PassManagerBase", "&", "PM", ",", "JITCodeEmitter", "&", "JCE", ")", "{", "PM", ".", "add", "(", "createARMJITCodeEmitterPass", "(", "*", "this", ",", "JCE", ")", ")", ";", "return", "false", ";" ]

[ "<FIXS>", "insv", "and", "extzv", "will", "think", "that", "we", "cannot", "handle", "memory", ".", "However", ",", "<FIXE>" ]

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

[ "<STR_LIT>", ")" ]

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

[ "}" ]

[ "bool", "isCortexA7", "(", ")", "const", "{", "return", "ARMProcFamily", "==", "CortexA7", ";" ]

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

[ "_", "_", "builtin_neon_vst1q_x2v8hi", "(", "(", "_", "_", "builtin_neon_hi", "*", ")", "_", "_", "a", ",", "_", "_", "bu", ".", "_" ]

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

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

[ ")" ]

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

[ "}" ]

[ "Num", "=", "<NUM_LIT>", ";", "break", ";", "}", "unsigned", "char", "Val", "=", "(", "Bead", "&", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "\\tEncodeBits", "<STR_LIT>", "<<", "<STR_LIT>", " Num: ", "<STR_LIT>", "<<", "Num", "<<", "<STR_LIT>", " Val: 0x", "<STR_LIT>", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", ".", "write_hex", "(", "Val", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "Buffer", "|=", "(", "Val", "<<", "Offset", ")", ";", "return", "Num", ";" ]

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

[ "def", "L2_loadrd_pbr", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ",", "IntRegs", ":", "$", "Rx32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rx32in", ",", "ModRegs", ":", "$", "Mu2", ")", ",", "<STR_LIT>", ",", "tc_44d3da28", ",", "TypeLD", ">", ",", "Enc_7eee72", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-" ]

[ "_", "builtin_neon_si", "*", ")", "_", "_", "addr", ")", ";" ]

[ "_", "_", "arm_vld4q_s32", "(", "int32_t", "const", "*", "_", "_", "addr", ")", "{", "union", "{", "int32x4x4_t", "_", "_", "i", ";", "_", "_", "builtin_neon_xi", "_", "_", "o", ";", "}", "_", "_", "rv", ";", "_", "_", "rv", ".", "_", "_", "o", "=", "_", "_", "builtin_mve_vld4qv4si", "(", "(", "_" ]

[ "}", ")" ]

[ "(", "unspec", ":", "BLK", "[", "(", "match_dup", "<NUM_LIT>", ")", "]", "UNSPEC_SFENCE", ")", ")", "]", "<STR_LIT>", "{", "operands", "[", "<NUM_LIT>", "]", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "gen_rtx_SCRATCH", "(", "Pmode", ")", ")", "MEM_VOLATILE_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", "=", "<NUM_LIT>" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Q", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "U", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "size", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opcode", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "def", "A2_addp", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss32", ",", "DoubleRegs", ":", "$", "Rtt32", ")", ",", "<STR_LIT>", ",", "tc_946df596", ",", "TypeALU64", ">", ",", "Enc_a56825", "{", "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", "isCommutable", "=", "<NUM_LIT>", ";", "let", "isAdd", "=", "<NUM_LIT>", ";" ]

[ "void", "X86InstPrinterCommon", "::", "printPCRelImm", "(", "const", "MCInst", "*", "MI", ",", "uint64_t", "Address", ",", "unsigned", "OpNo", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "SymbolizeOperands", ")", "return", ";", "const", "MCOperand", "&", "Op", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "Op", ".", "isImm", "(", ")", ")", "{", "if", "(", "PrintBranchImmAsAddress", ")", "{", "uint64_t", "Target", "=", "Address", "+", "Op", ".", "getImm", "(", ")", ";", "if", "(", "MAI", ".", "getCodePointerSize", "(", ")", "==", "<NUM_LIT>", ")", "Target", "&=", "<NUM_LIT>", ";", "O", "<<", "formatHex", "(", "Target", ")", ";", "}", "else", "O", "<<", "formatImm", "(", "Op", ".", "getImm", "(", ")", ")", ";", "}", "else", "{", "assert", "(", "Op", ".", "isExpr", "(", ")", "&&", "<STR_LIT>", "unknown pcrel immediate operand", "<STR_LIT>", ")", ";", "const", "MCConstantExpr", "*", "BranchTarget", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "getExpr", "(", ")", ")", ";", "int64_t", "Address", ";", "if", "(", "BranchTarget", "&&", "BranchTarget", "->", "evaluateAsAbsolute", "(", "Address", ")", ")", "{", "O", "<<", "formatHex", "(", "(", "uint64_t", ")", "Address", ")", ";", "}", "else", "{", "Op", ".", "getExpr", "(", ")", "->", "print", "(", "O", ",", "&", "MAI", ")", ";", "}", "}", "}" ]

[ "value", "(", "e.g", "." ]

[ "<STR_LIT>", ")" ]

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

[ "else", "args", "=", "tree_cons", "(", "NULL_TREE", ",", "eltype", ",", "args", ")", ";" ]

[ "d", "->", "fcode", "=", "fcode", ";", "int", "op_num", "=", "insn_data", "[", "d", "->", "code", "]", ".", "n_operands", "-", "<NUM_LIT>", ";", "int", "arg_num", "=", "d", "->", "qualifiers", "[", "<NUM_LIT>", "]", "&", "qualifier_void", "?", "op_num", "+", "<NUM_LIT>", ":", "op_num", ";", "tree", "return_type", "=", "void_type_node", ",", "args", "=", "void_list_node", ";", "tree", "eltype", ";", "for", "(", ";", "op_num", ">=", "<NUM_LIT>", ";", "arg_num", "--", ",", "op_num", "--", ")", "{", "machine_mode", "op_mode", "=", "insn_data", "[", "d", "->", "code", "]", ".", "operand", "[", "op_num", "]", ".", "mode", ";", "enum", "arm_type_qualifiers", "qualifiers", "=", "d", "->", "qualifiers", "[", "arg_num", "]", ";", "if", "(", "qualifiers", "&", "qualifier_unsigned", ")", "{", "type_signature", "[", "arg_num", "]", "=", "'", "u", "'", ";", "print_type_signature_p", "=", "true", ";", "}", "else", "if", "(", "qualifiers", "&", "qualifier_poly", ")", "{", "type_signature", "[", "arg_num", "]", "=", "'", "p", "'", ";", "print_type_signature_p", "=", "true", ";", "}", "else", "type_signature", "[", "arg_num", "]", "=", "'", "s", "'", ";", "if", "(", "qualifiers", "&", "qualifier_internal", ")", "continue", ";", "if", "(", "qualifiers", "&", "qualifier_map_mode", ")", "op_mode", "=", "d", "->", "mode", ";", "if", "(", "qualifiers", "&", "qualifier_pointer", "&&", "VECTOR_MODE_P", "(", "op_mode", ")", ")", "op_mode", "=", "GET_MODE_INNER", "(", "op_mode", ")", ";", "eltype", "=", "arm_simd_builtin_type", "(", "op_mode", ",", "(", "qualifiers", "&", "qualifier_unsigned", ")", "!=", "<NUM_LIT>", ",", "(", "qualifiers", "&", "qualifier_poly", ")", "!=", "<NUM_LIT>", ")", ";", "gcc_assert", "(", "eltype", "!=", "NULL", ")", ";", "if", "(", "qualifiers", "&", "qualifier_const", ")", "eltype", "=", "build_qualified_type", "(", "eltype", ",", "TYPE_QUAL_CONST", ")", ";", "if", "(", "qualifiers", "&", "qualifier_pointer", ")", "eltype", "=", "build_pointer_type", "(", "eltype", ")", ";", "if", "(", "arg_num", "==", "<NUM_LIT>", ")", "return_type", "=", "eltype", ";" ]

[ "Value", "*", "AArch64TargetLowering", "::", "emitLoadLinked", "(", "IRBuilderBase", "&", "Builder", ",", "Type", "*", "ValueTy", ",", "Value", "*", "Addr", ",", "AtomicOrdering", "Ord", ")", "const", "{", "Module", "*", "M", "=", "Builder", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "bool", "IsAcquire", "=", "isAcquireOrStronger", "(", "Ord", ")", ";", "if", "(", "ValueTy", "->", "getPrimitiveSizeInBits", "(", ")", "==", "<NUM_LIT>", ")", "{", "Intrinsic", "::", "ID", "Int", "=", "IsAcquire", "?", "Intrinsic", "::", "aarch64_ldaxp", ":", "Intrinsic", "::", "aarch64_ldxp", ";", "Function", "*", "Ldxr", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ")", ";", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "Addr", ",", "Type", "::", "getInt8PtrTy", "(", "M", "->", "getContext", "(", ")", ")", ")", ";", "Value", "*", "LoHi", "=", "Builder", ".", "CreateCall", "(", "Ldxr", ",", "Addr", ",", "<STR_LIT>", "lohi", "<STR_LIT>", ")", ";", "Value", "*", "Lo", "=", "Builder", ".", "CreateExtractValue", "(", "LoHi", ",", "<NUM_LIT>", ",", "<STR_LIT>", "lo", "<STR_LIT>", ")", ";", "Value", "*", "Hi", "=", "Builder", ".", "CreateExtractValue", "(", "LoHi", ",", "<NUM_LIT>", ",", "<STR_LIT>", "hi", "<STR_LIT>", ")", ";", "Lo", "=", "Builder", ".", "CreateZExt", "(", "Lo", ",", "ValueTy", ",", "<STR_LIT>", "lo64", "<STR_LIT>", ")", ";", "Hi", "=", "Builder", ".", "CreateZExt", "(", "Hi", ",", "ValueTy", ",", "<STR_LIT>", "hi64", "<STR_LIT>", ")", ";", "return", "Builder", ".", "CreateOr", "(", "Lo", ",", "Builder", ".", "CreateShl", "(", "Hi", ",", "ConstantInt", "::", "get", "(", "ValueTy", ",", "<NUM_LIT>", ")", ")", ",", "<STR_LIT>", "val64", "<STR_LIT>", ")", ";", "}", "const", "DataLayout", "&", "DL", "=", "M", "->", "getDataLayout", "(", ")", ";", "IntegerType", "*", "IntEltTy", "=", "Builder", ".", "getIntNTy", "(", "DL", ".", "getTypeSizeInBits", "(", "ValueTy", ")", ")", ";", "if", "(", "ValueTy", "->", "isPointerTy", "(", ")", ")", "Addr", "=", "Builder", ".", "CreatePointerCast", "(", "Addr", ",", "IntEltTy", "->", "getPointerTo", "(", "Addr", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ")", ")", ";", "Type", "*", "Tys", "[", "]", "=", "{", "Addr", "->", "getType", "(", ")", "}", ";", "Intrinsic", "::", "ID", "Int", "=", "IsAcquire", "?", "Intrinsic", "::", "aarch64_ldaxr", ":", "Intrinsic", "::", "aarch64_ldxr", ";", "Function", "*", "Ldxr", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ",", "Tys", ")", ";", "Value", "*", "Trunc", "=", "Builder", ".", "CreateTrunc", "(", "Builder", ".", "CreateCall", "(", "Ldxr", ",", "Addr", ")", ",", "IntEltTy", ")", ";", "assert", "(", "!", "DL", ".", "isFatPointer", "(", "ValueTy", ")", "&&", "<STR_LIT>", "Should not be handled here!", "<STR_LIT>", ")", ";", "if", "(", "ValueTy", "->", "isPointerTy", "(", ")", ")", "return", "Builder", ".", "CreateIntToPtr", "(", "Trunc", ",", "ValueTy", ")", ";", "return", "Builder", ".", "CreateBitCast", "(", "Trunc", ",", "ValueTy", ")", ";", "}" ]

[ "Perform", "a", "load-linked", "operation", "on", "Addr", ",", "returning", "a", "``", "Value", "*", "''", "with", "the", "corresponding", "pointee", "type", "." ]

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

[ "if", "(", "FP_REG_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "return", "<STR_LIT>", "return", "<STR_LIT>", "<BUGS>", "}", ")", "<BUGE>", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "FP", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

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

[ "(", "match_operand", ":", "VSX_LE_128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "{", "rtx", "tmp", "=", "(", "can_create_pseudo_p", "(", ")", "?", "gen_reg_rtx_and_attrs", "(", "operands", "[", "<NUM_LIT>", "]", ")", ":", "operands", "[", "<NUM_LIT>", "]", ")", "rs6000_emit_le_vsx_permute", "(", "tmp", ",", "operands", "[", "<NUM_LIT>", "]", ",", "<", "MODE", ">", "mode", ")", "rs6000_emit_le_vsx_permute", "(", "operands", "[", "<NUM_LIT>", "]", ",", "tmp", ",", "<", "MODE", ">", "mode", ")", "DONE", "}", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "}" ]

[ "bool", "XCoreFrameInfo", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "DisableFramePointerElim", "(", "MF", ")", "||", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", ";" ]

[ "static", "void", "v850_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "chain_value", ")", "{", "rtx", "mem", ",", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "<NUM_LIT>", ")", ";", "emit_block_move", "(", "m_tramp", ",", "assemble_trampoline_template", "(", ")", ",", "GEN_INT", "(", "TRAMPOLINE_SIZE", ")", ",", "BLOCK_OP_NORMAL", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "<NUM_LIT>", ")", ";", "emit_move_insn", "(", "mem", ",", "chain_value", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "<NUM_LIT>", ")", ";", "emit_move_insn", "(", "mem", ",", "fnaddr", ")", ";", "}" ]

[ "Worker", "function", "for", "TARGET_TRAMPOLINE_INIT", "." ]

[ "unsigned", "CReg", "=", "fastEmit_i", "(", "VT", ",", "VT", ",", "ISD", "::", "Constant", ",", "Imm", ")", ";" ]

[ "unsigned", "AArch64FastISel", "::", "emitAdd_ri_", "(", "MVT", "VT", ",", "unsigned", "Op0", ",", "int64_t", "Imm", ")", "{", "unsigned", "ResultReg", ";", "if", "(", "Imm", "<", "<NUM_LIT>", ")", "ResultReg", "=", "emitAddSub_ri", "(", "false", ",", "VT", ",", "Op0", ",", "-", "Imm", ")", ";", "else", "ResultReg", "=", "emitAddSub_ri", "(", "true", ",", "VT", ",", "Op0", ",", "Imm", ")", ";", "if", "(", "ResultReg", ")", "return", "ResultReg", ";" ]

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

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

[ "if", "(", "CallMain", ")", "{" ]

[ "}", "}", "DenseMap", "<", "std", "::", "pair", "<", "Function", "*", ",", "FunctionType", "*", ">", ",", "Function", "*", ">", "Wrappers", ";", "for", "(", "auto", "&", "UseFunc", ":", "Uses", ")", "{", "Use", "*", "U", "=", "UseFunc", ".", "first", ";", "Function", "*", "F", "=", "UseFunc", ".", "second", ";", "auto", "*", "PTy", "=", "cast", "<", "PointerType", ">", "(", "U", "->", "get", "(", ")", "->", "getType", "(", ")", ")", ";", "auto", "*", "Ty", "=", "dyn_cast", "<", "FunctionType", ">", "(", "PTy", "->", "getElementType", "(", ")", ")", ";", "if", "(", "!", "Ty", ")", "continue", ";", "auto", "Pair", "=", "Wrappers", ".", "insert", "(", "std", "::", "make_pair", "(", "std", "::", "make_pair", "(", "F", ",", "Ty", ")", ",", "nullptr", ")", ")", ";", "if", "(", "Pair", ".", "second", ")", "Pair", ".", "first", "->", "second", "=", "createWrapper", "(", "F", ",", "Ty", ")", ";", "Function", "*", "Wrapper", "=", "Pair", ".", "first", "->", "second", ";", "if", "(", "!", "Wrapper", ")", "continue", ";", "if", "(", "isa", "<", "Constant", ">", "(", "U", "->", "get", "(", ")", ")", ")", "U", "->", "get", "(", ")", "->", "replaceAllUsesWith", "(", "Wrapper", ")", ";", "else", "U", "->", "set", "(", "Wrapper", ")", ";", "}" ]

[ "}" ]

[ "if", "(", "RegNo", ">", "<NUM_LIT>", ")", "return", "MCDisassembler", "::", "Fail", ";", "return", "DecodeGPRRegisterClass", "(", "Inst", ",", "RegNo", ",", "Address", ",", "Decoder", ")", ";" ]

[ "<FIXS>", "(", "inst", "$", "ptr", ",", "Offset", ":", "$", "offset", ",", "(", "i1", "<NUM_LIT>", ")", ",", "$", "in", ")", "<FIXE>" ]

[ "class", "DSReadPat_D16", "DS_Pseudo", "inst", ",", "PatFrag", "frag", ",", "ValueType", "vt", ">", ":", "GCNPat", "(", "frag", "(", "DS1Addr1Offset", "i32", ":", "$", "ptr", ",", "i32", ":", "$", "offset", ")", ",", "vt", ":", "$", "in", ")", ",", "<BUGS>", "(", "inst", "$", "ptr", ",", "offset", ":", "$", "offset", ",", "(", "i1", "<NUM_LIT>", ")", ",", "$", "in", ")", "<BUGE>", ">", ";", "defm", ":", "DSReadPat_mc", "DS_READ_I8", ",", "i32", ",", "<STR_LIT>", ">", ";" ]

[ "HOST_WIDE_INT", "sh_disp_addr_displacement", "(", "rtx", "x", ")", "{", "gcc_assert", "(", "satisfies_constraint_Sdd", "(", "x", ")", ")", ";", "return", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ";", "}" ]

[ "Return", "the", "displacement", "value", "of", "a", "displacement", "address", "." ]

[ "<STR_LIT>" ]

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

[ ")", ")", ",", "StackPtr", ",", "PtrOff", ")", ";" ]

[ "SDValue", "X86TargetLowering", "::", "LowerMemOpCallTo", "(", "SDValue", "Chain", ",", "SDValue", "StackPtr", ",", "SDValue", "Arg", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "const", "CCValAssign", "&", "VA", ",", "ISD", "::", "ArgFlagsTy", "Flags", ",", "bool", "isByVal", ")", "const", "{", "unsigned", "LocMemOffset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "SDValue", "PtrOff", "=", "DAG", ".", "getIntPtrConstant", "(", "LocMemOffset", ",", "dl", ")", ";", "PtrOff", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(" ]

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

[ "(", "match_test", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", "(", "ior", "(", "not", "(", "match_test", "<STR_LIT>", ")", ")", "<BUGS>", "(", "match_test", "<STR_LIT>", ")", ")", "(", "const_string", "<STR_LIT>", ")", "(", "match_test", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", "(", "match_test", "<STR_LIT>", ")", "<BUGE>", "(", "const_string", "<STR_LIT>", ")", "]", "(", "const_string", "<STR_LIT>", ")", ")" ]

[ "}" ]

[ "def", "MemoryUnscaledOperand", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", ";", "let", "DiagnosticType", "=", "<STR_LIT>", ";" ]

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

[ "(", "match_dup", "<NUM_LIT>", ")", "]", "<STR_LIT>", "[", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "match_dup", "<NUM_LIT>", ")", ")", "]" ]

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

[ "def", "A4_cround_ri", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "u5_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_002cb246", ",", "TypeS_2op", ">", ",", "Enc_a05677", "{", "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>", "(", "and", "(", "match_code", "<STR_LIT>", ")", "(", "match_test", "<STR_LIT>" ]

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

[ "initializeXCoreLowerThreadLocalPass", "(", "*", "PassRegistry", "::", "getPassRegistry", "(" ]

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

[ "(", "define_mode_attr", "iprefx", "[", "(", "QI", "<STR_LIT>", ")", "(", "HI", "<STR_LIT>" ]

[ "<FIXS>", "rtx", "reg", ";", "<FIXE>", "<FIXS>", "<FIXE>" ]

[ "static", "rtxhwloop_pattern_reg", "(", "rtx", "insn", ")", "{", "<BUGS>", "rtx", "pat", ",", "reg", ";", "<BUGE>", "if", "(", "!", "JUMP_P", "(", "insn", ")", "||", "recog_memoized", "(", "insn", ")", "!=", "CODE_FOR_loop_end", ")", "return", "NULL_RTX", ";", "<BUGS>", "pat", "=", "PATTERN", "(", "insn", ")", ";", "<BUGE>", "reg", "=", "SET_DEST", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "REG_P", "(", "reg", ")", ")", "return", "NULL_RTX", ";" ]

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

[ "(", "minus", ":", "HI", "(", "match_dup", "<NUM_LIT>", ")", "(", "mult", ":", "HI", "(", "any_extend", ":", "HI", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "any_extend2", ":", "HI", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "REG_CC", ")" ]

[ ":", "QI", "<NUM_LIT>", "<STR_LIT>", ")" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "(", "call", "(", "match_operand" ]

[ "<FIXS>", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ",", "false", ",", "false", ",", "DstSV", ",", "<NUM_LIT>", ",", "SrcSV", ",", "<NUM_LIT>", ")", ";", "<FIXE>" ]

[ "DebugLoc", "dl", "=", "Op", ".", "getDebugLoc", "(", ")", ";", "return", "DAG", ".", "getMemcpy", "(", "Chain", ",", "dl", ",", "DstPtr", ",", "SrcPtr", ",", "<BUGS>", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ",", "false", ",", "DstSV", ",", "<NUM_LIT>", ",", "SrcSV", ",", "<NUM_LIT>", ")", ";", "<BUGE>", "}", "SDValue" ]

[ ")", "]" ]

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

[ "emit_move_insn", "(", "gen_frame_mem", "(", "Pmode", ",", "addr", ")", ",", "source", ")", ";" ]

[ "if", "(", "mask", "&", "(", "<NUM_LIT>", "<<", "LR_REGNUM", ")", ")", "{", "offsets", "=", "arm_get_frame_offsets", "(", ")", ";", "if", "(", "frame_pointer_needed", ")", "{", "delta", "=", "offsets", "->", "soft_frame", "-", "offsets", "->", "saved_args", ";", "reg", "=", "THUMB_HARD_FRAME_POINTER_REGNUM", ";", "}", "else", "{", "delta", "=", "offsets", "->", "outgoing_args", "-", "offsets", "->", "saved_args", ";", "reg", "=", "SP_REGNUM", ";", "}", "if", "(", "TARGET_BACKTRACE", ")", "delta", "-=", "<NUM_LIT>", ";", "delta", "-=", "<NUM_LIT>", ";", "addr", "=", "gen_rtx_REG", "(", "SImode", ",", "reg", ")", ";", "if", "(", "(", "reg", "!=", "SP_REGNUM", "&&", "delta", ">=", "<NUM_LIT>", ")", "||", "delta", ">=", "<NUM_LIT>", ")", "{", "emit_insn", "(", "gen_movsi", "(", "scratch", ",", "GEN_INT", "(", "delta", ")", ")", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "scratch", ",", "scratch", ",", "stack_pointer_rtx", ")", ")", ";", "addr", "=", "scratch", ";", "}", "else", "addr", "=", "plus_constant", "(", "addr", ",", "delta", ")", ";" ]

[ "=", "insn", ";" ]

[ "last_call", "=", "NULL", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "next", ")", "{", "next", "=", "NEXT_INSN", "(", "insn", ")", ";", "if", "(", "CALL_P", "(", "insn", ")", "||", "(", "INSN_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SEQUENCE", "&&", "CALL_P", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ")", ")", "last_call", "=", "insn", ";", "if", "(", "!", "NOTE_P", "(", "insn", ")", "||", "NOTE_KIND", "(", "insn", ")", "!=", "NOTE_INSN_CALL_ARG_LOCATION", ")", "continue", ";", "if", "(", "NEXT_INSN", "(", "last_call", ")", "==", "insn", ")", "continue", ";", "SET_NEXT_INSN", "(", "PREV_INSN", "(", "insn", ")", ")", "=", "NEXT_INSN", "(", "insn", ")", ";", "SET_PREV_INSN", "(", "NEXT_INSN", "(", "insn", ")", ")", "=", "PREV_INSN", "(", "insn", ")", ";", "SET_PREV_INSN", "(", "insn", ")", "=", "last_call", ";", "SET_NEXT_INSN", "(", "insn", ")", "=", "NEXT_INSN", "(", "last_call", ")", ";", "SET_PREV_INSN", "(", "NEXT_INSN", "(", "insn", ")", ")" ]

[ "}" ]

[ "dag", "OutOperandList", "=", "oops", ";", "dag", "InOperandList", "=", "iops", ";", "let", "AsmString", "=", "!", "strconcat", "(", "asm", ",", "operands", ")", ";" ]

[ ",", "vsfrc", ",", "vsfrc", ",", "IIC_VecFP", ",", "[", "]", ">", ";" ]

[ "def", "XSMAXCDP", ":", "XX3_XT5_XA5_XB5", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<STR_LIT>", ",", "vsrc" ]

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

[ "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "ashift", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "ashift", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")" ]

[ "let", "Defs", "=", "[", "PC", ",", "R31", "]", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isCall", "=", "<NUM_LIT>", ";", "let", "prefersSlot3", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "R29", "]", ";" ]

[ "<STR_LIT>", ")" ]

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

[ "}" ]

[ "static", "MCInstPrinter", "*", "createMSP430MCInstPrinter", "(", "const", "Target", "&", "T", ",", "unsigned", "SyntaxVariant", ",", "const", "MCAsmInfo", "&", "MAI", ",", "const", "MCRegisterInfo", "&", "MRI", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "if", "(", "SyntaxVariant", "==", "<NUM_LIT>", ")", "return", "new", "MSP430InstPrinter", "(", "MAI", ",", "MRI", ")", ";", "return", "<NUM_LIT>", ";" ]

[ "bool", "HexagonGenInsert", "::", "removeDeadCode", "(", "MachineDomTreeNode", "*", "N", ")", "{", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "*", "DTN", ":", "children", "<", "MachineDomTreeNode", "*", ">", "(", "N", ")", ")", "Changed", "|=", "removeDeadCode", "(", "DTN", ")", ";", "MachineBasicBlock", "*", "B", "=", "N", "->", "getBlock", "(", ")", ";", "std", "::", "vector", "<", "MachineInstr", "*", ">", "Instrs", ";", "for", "(", "MachineInstr", "&", "MI", ":", "llvm", "::", "reverse", "(", "*", "B", ")", ")", "Instrs", ".", "push_back", "(", "&", "MI", ")", ";", "for", "(", "MachineInstr", "*", "MI", ":", "Instrs", ")", "{", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "TargetOpcode", "::", "LIFETIME_START", "||", "Opc", "==", "TargetOpcode", "::", "LIFETIME_END", ")", "continue", ";", "bool", "Store", "=", "false", ";", "if", "(", "MI", "->", "isInlineAsm", "(", ")", "||", "!", "MI", "->", "isSafeToMove", "(", "nullptr", ",", "Store", ")", ")", "continue", ";", "bool", "AllDead", "=", "true", ";", "SmallVector", "<", "unsigned", ",", "<NUM_LIT>", ">", "Regs", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", "->", "operands", "(", ")", ")", "{", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "!", "MO", ".", "isDef", "(", ")", ")", "continue", ";", "Register", "R", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "!", "R", ".", "isVirtual", "(", ")", "||", "!", "MRI", "->", "use_nodbg_empty", "(", "R", ")", ")", "{", "AllDead", "=", "false", ";", "break", ";", "}", "Regs", ".", "push_back", "(", "R", ")", ";", "}", "if", "(", "!", "AllDead", ")", "continue", ";", "B", "->", "erase", "(", "MI", ")", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "N", "=", "Regs", ".", "size", "(", ")", ";", "I", "!=", "N", ";", "++", "I", ")", "MRI", "->", "markUsesInDebugValueAsUndef", "(", "Regs", "[", "I", "]", ")", ";", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}" ]

[ "Remove", "all", "dead", "instructions", "between", "the", "I", "and", "E", "." ]

[ "return", "UseCycle", ";" ]

[ "UseCycle", "+=", "<NUM_LIT>", ";", "}", "else", "if", "(", "Subtarget", ".", "isLikeA9", "(", ")", "||", "Subtarget", ".", "isSwift", "(", ")", ")", "{", "UseCycle", "=", "(", "RegNo", "/", "<NUM_LIT>", ")", ";", "if", "(", "(", "RegNo", "%", "<NUM_LIT>", ")", "||", "UseAlign", "<", "<NUM_LIT>", ")", "++", "UseCycle", ";", "}", "else", "{", "UseCycle", "=", "<NUM_LIT>", ";", "}" ]

[ "<FIXS>", "for", "(", "MVT", "VT", ":", "MVT", "::", "fixedlen_vector_valuetypes", "(", ")", ")", "{", "<FIXE>" ]

[ "setTruncStoreAction", "(", "MVT", "::", "v2i32", ",", "MVT", "::", "v2i16", ",", "Expand", ")", ";", "<BUGS>", "for", "(", "MVT", "VT", ":", "MVT", "::", "vector_valuetypes", "(", ")", ")", "{", "<BUGE>", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "VT", ",", "Expand", ")", ";", "if", "(", "VT", "==", "MVT", "::", "v16i8", "||", "VT", "==", "MVT", "::", "v8i16", "||", "VT", "==", "MVT", "::", "v4i32", ")", "{" ]

[ "<STR_LIT>", ")" ]

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

[ "SDValue", "PPCTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Wasn't expecting to be able to lower this!", "<STR_LIT>", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INIT_TRAMPOLINE", ":", "return", "LowerINIT_TRAMPOLINE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADJUST_TRAMPOLINE", ":", "return", "LowerADJUST_TRAMPOLINE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "LowerVAARG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VACOPY", ":", "return", "LowerVACOPY", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STACKRESTORE", ":", "return", "LowerSTACKRESTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GET_DYNAMIC_AREA_OFFSET", ":", "return", "LowerGET_DYNAMIC_AREA_OFFSET", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_DWARF_CFA", ":", "return", "LowerEH_DWARF_CFA", "(", "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", "::", "LOAD", ":", "return", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "TRUNCATE", ":", "return", "LowerTRUNCATE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_INT", "(", "Op", ",", "DAG", ",", "SDLoc", "(", "Op", ")", ")", ";", "case", "ISD", "::", "UINT_TO_FP", ":", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FLT_ROUNDS_", ":", "return", "LowerFLT_ROUNDS_", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "LowerSHL_PARTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "return", "LowerSRL_PARTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA_PARTS", ":", "return", "LowerSRA_PARTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "LowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SCALAR_TO_VECTOR", ":", "return", "LowerSCALAR_TO_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", "LowerSIGN_EXTEND_INREG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "LowerEXTRACT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "LowerINSERT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "LowerMUL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "}", "}" ]

[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]

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

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

[ "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "add", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";" ]

[ "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "add", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "add", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "add", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "add", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "add", "(", "MI" ]

[ "_", "_", "mmask8", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "mmask8", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_test_epi32_mask", "(", "_", "_", "m128i", "_", "_", "A", ",", "_", "_", "m128i", "_", "_", "B", ")", "{", "return", "(", "_", "_", "mmask8", ")", "_", "_", "builtin_ia32_ptestmd128", "(", "(", "_", "_", "v4si", ")", "_", "_", "A", ",", "(", "_", "_", "v4si", ")", "_", "_", "B", ",", "(" ]

[ "}" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "ARM", "::", "STMDB", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "ARM", "::", "STMIB", ";", "}", "break", ";", "case", "ARM", "::", "t2LDRi8", ":", "case", "ARM", "::", "t2LDRi12", ":", "++", "NumLDMGened", ";", "switch", "(", "Mode", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unhandled submode!", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "ARM", "::", "t2LDMIA", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "ARM", "::", "t2LDMDB", ";", "}", "break", ";", "case", "ARM", "::", "t2STRi8", ":", "case", "ARM", "::", "t2STRi12", ":", "++", "NumSTMGened", ";", "switch", "(", "Mode", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unhandled submode!", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "ARM", "::", "t2STMIA", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "ARM", "::", "t2STMDB", ";", "}", "break", ";", "case", "ARM", "::", "VLDRS", ":", "++", "NumVLDMGened", ";", "switch", "(", "Mode", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unhandled submode!", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "ARM", "::", "VLDMSIA", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<NUM_LIT>", ";", "}", "break", ";", "case", "ARM", "::", "VSTRS", ":", "++", "NumVSTMGened", ";", "switch", "(", "Mode", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unhandled submode!", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "ARM", "::", "VSTMSIA", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<NUM_LIT>", ";", "}", "break", ";", "case", "ARM", "::", "VLDRD", ":", "++", "NumVLDMGened", ";", "switch", "(", "Mode", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unhandled submode!", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "ARM", "::", "VLDMDIA", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<NUM_LIT>", ";", "}", "break", ";", "case", "ARM", "::", "VSTRD", ":", "++", "NumVSTMGened", ";", "switch", "(", "Mode", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unhandled submode!", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "ARM", "::", "VSTMDIA", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<NUM_LIT>", ";" ]

[ "}" ]

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

[ ")", ")" ]

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

[ "}" ]

[ "destReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "return", "true", ";", "}", "}", "else", "if", "(", "oc", "==", "PPC", "::", "ADDI", ")", "{", "assert", "(", "MI", ".", "getNumOperands", "(", ")", ">=", "<NUM_LIT>", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "&&", "<STR_LIT>", "invalid PPC ADDI instruction!", "<STR_LIT>", ")", ";", "if", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", ")", "{", "sourceReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "destReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "return", "true", ";", "}", "}", "else", "if", "(", "oc", "==", "PPC", "::", "ORI", ")", "{", "assert", "(", "MI", ".", "getNumOperands", "(", ")", ">=", "<NUM_LIT>", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "&&", "<STR_LIT>", "invalid PPC ORI instruction!", "<STR_LIT>", ")", ";", "if", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", ")", "{", "sourceReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "destReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "return", "true", ";", "}", "}", "else", "if", "(", "oc", "==", "PPC", "::", "FMR", "||", "oc", "==", "PPC", "::", "FMRSD", ")", "{", "assert", "(", "MI", ".", "getNumOperands", "(", ")", ">=", "<NUM_LIT>", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "<STR_LIT>", "invalid PPC FMR instruction", "<STR_LIT>", ")", ";", "sourceReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "destReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "return", "true", ";", "}", "else", "if", "(", "oc", "==", "PPC", "::", "MCRF", ")", "{", "assert", "(", "MI", ".", "getNumOperands", "(", ")", ">=", "<NUM_LIT>", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "<STR_LIT>", "invalid PPC MCRF instruction", "<STR_LIT>", ")", ";", "sourceReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "destReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "return", "true", ";", "}", "return", "false", ";" ]

[ ";" ]

[ "if", "(", "!", "IsVector", "&&", "!", "Op", "->", "isRegList", "(", ")", ")", "return", "Error", "(", "L", ",", "<STR_LIT>", ".save expects GPR registers", "<STR_LIT>", ")", ";", "if", "(", "IsVector", "&&", "!", "Op", "->", "isDPRRegList", "(", ")", ")", "return", "Error", "(", "L", ",", "<STR_LIT>", ".vsave expects DPR registers", "<STR_LIT>", ")", ";", "getParser", "(", ")", ".", "getStreamer", "(", ")", ".", "EmitRegSave", "(", "Op", "->", "getRegList", "(", ")", ",", "IsVector", ")", ";", "return", "false" ]

[ "if", "(", "EltSize", "==", "<NUM_LIT>", ")", "{" ]

[ "assert", "(", "Val", "->", "isVectorTy", "(", ")", "&&", "<STR_LIT>", "This must be a vector type", "<STR_LIT>", ")", ";", "int", "ISD", "=", "TLI", "->", "InstructionOpcodeToISD", "(", "Opcode", ")", ";", "assert", "(", "ISD", "&&", "<STR_LIT>", "Invalid opcode", "<STR_LIT>", ")", ";", "int", "Cost", "=", "BaseT", "::", "getVectorInstrCost", "(", "Opcode", ",", "Val", ",", "Index", ")", ";", "Cost", "=", "vectorCostAdjustment", "(", "Cost", ",", "Opcode", ",", "Val", ",", "nullptr", ")", ";", "if", "(", "ST", "->", "hasVSX", "(", ")", "&&", "Val", "->", "getScalarType", "(", ")", "->", "isDoubleTy", "(", ")", ")", "{", "if", "(", "ISD", "==", "ISD", "::", "EXTRACT_VECTOR_ELT", "&&", "Index", "==", "(", "ST", "->", "isLittleEndian", "(", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ")", "return", "<NUM_LIT>", ";", "return", "Cost", ";", "}", "else", "if", "(", "Val", "->", "getScalarType", "(", ")", "->", "isIntegerTy", "(", ")", "&&", "Index", "!=", "-", "<NUM_LIT>", "U", ")", "{", "if", "(", "ST", "->", "hasP9Altivec", "(", ")", ")", "{", "if", "(", "ISD", "==", "ISD", "::", "INSERT_VECTOR_ELT", ")", "return", "vectorCostAdjustment", "(", "<NUM_LIT>", ",", "Opcode", ",", "Val", ",", "nullptr", ")", ";", "unsigned", "EltSize", "=", "Val", "->", "getScalarSizeInBits", "(", ")", ";" ]

[ "<FIXS>", "switch", "(", "class_letter", ")", "<FIXE>" ]

[ "if", "(", "type", "!=", "CPP_CHAR", ")", "goto", "syntax_error", ";", "class_letter", "=", "tree_to_uhwi", "(", "val", ")", ";", "<BUGS>", "if", "(", "class_letter", ">=", "'", "A", "'", "&&", "class_letter", "<=", "'", "D", "'", ")", "switch", "(", "class_letter", ")", "{", "case", "'", "A", "'", ":", "rclass", "=", "USER0_REGS", ";", "break", ";", "case", "'", "B", "'", ":", "rclass", "=", "USER1_REGS", ";", "break", ";", "case", "'", "C", "'", ":", "rclass", "=", "USER2_REGS", ";", "break", ";", "case", "'", "D", "'", ":", "rclass", "=", "USER3_REGS", ";", "break", ";", "}", "else", "<BUGE>", "{", "error", "(", "<STR_LIT>", "#pragma GCC coprocessor subclass letter must be in [ABCD]", "<STR_LIT>", ")", ";", "return", ";", "}" ]

[ "<FIXS>", "Src2RC", ":", "$", "src2", ",", "Clamp0", ":", "$", "clamp", ",", "omod0", ":", "$", "omod", ")", ",", "<FIXE>", "<FIXS>", "Src2RC", ":", "$", "src2", ",", "Clamp0", ":", "$", "clamp", ")", ",", "<FIXE>", "<FIXS>", "(", "ins", "Src0RC", ":", "$", "src0", ",", "Src1RC", ":", "$", "src1", ",", "Src2RC", ":", "$", "src2", ",", "Clamp0", ":", "$", "clamp", ")", ",", "<FIXE>" ]

[ "!", "if", "(", "HasOMod", ",", "(", "ins", "Src0Mod", ":", "$", "src0_modifiers", ",", "Src0RC", ":", "$", "src0", ",", "Src1Mod", ":", "$", "src1_modifiers", ",", "Src1RC", ":", "$", "src1", ",", "<BUGS>", "Src2RC", ":", "$", "src2", ",", "clampmod0", ":", "$", "clamp", ",", "omod0", ":", "$", "omod", ")", ",", "<BUGE>", "!", "if", "(", "HasClamp", ",", "(", "ins", "Src0Mod", ":", "$", "src0_modifiers", ",", "Src0RC", ":", "$", "src0", ",", "Src1Mod", ":", "$", "src1_modifiers", ",", "Src1RC", ":", "$", "src1", ",", "<BUGS>", "Src2RC", ":", "$", "src2", ",", "clampmod0", ":", "$", "clamp", ")", ",", "<BUGE>", "(", "ins", "Src0Mod", ":", "$", "src0_modifiers", ",", "Src0RC", ":", "$", "src0", ",", "Src1Mod", ":", "$", "src1_modifiers", ",", "Src1RC", ":", "$", "src1", ",", "Src2RC", ":", "$", "src2", ")", ")", ")", ")", ",", "!", "if", "(", "HasClamp", ",", "<BUGS>", "(", "ins", "Src0RC", ":", "$", "src0", ",", "Src1RC", ":", "$", "src1", ",", "Src2RC", ":", "$", "src2", ",", "clampmod0", ":", "$", "clamp", ")", ",", "<BUGE>", "(", "ins", "Src0RC", ":", "$", "src0", ",", "Src1RC", ":", "$", "src1", ",", "Src2RC", ":", "$", "src2", ")", ")", ")", ")", ")", ")", ";", "}" ]

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

[ "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseRegOffset", ";", "let", "accessSize", "=", "ByteAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";" ]

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

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

[ "}" ]

[ "bool", "IsVarArg", "=", "false", ";", "return", "FunctionType", "::", "get", "(", "ResultTy", ",", "ArgTys", ",", "IsVarArg", ")", ";" ]

[ "<FIXS>", "static", "SDValue", "LowerUINT_TO_FP", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ",", "const", "SparcTargetLowering", "&", "TLI", ",", "bool", "hasHardQuad", ")", "{", "<FIXE>", "<FIXS>", "if", "(", "Op", ".", "getValueType", "(", ")", "!=", "MVT", "::", "f128", "||", "(", "hasHardQuad", "&&", "TLI", ".", "isTypeLegal", "(", "OpVT", ")", ")", ")", "return", "SDValue", "(", ")", ";", "<FIXE>", "<FIXS>", "return", "TLI", ".", "LowerF128Op", "(", "Op", ",", "DAG", ",", "TLI", ".", "getLibcallName", "(", "OpVT", "==", "MVT", "::", "i32", "?", "RTLIB", "::", "UINTTOFP_I32_F128", ":", "RTLIB", "::", "UINTTOFP_I64_F128", ")", ",", "<NUM_LIT>", ")", ";", "<FIXE>" ]

[ "<NUM_LIT>", ")", ";", "}", "<BUGS>", "SDValue", "SparcTargetLowering", "::", "LowerBITCAST", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDLoc", "dl", "(", "Op", ")", ";", "EVT", "SrcVT", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ";", "EVT", "DstVT", "=", "Op", ".", "getValueType", "(", ")", ";", "if", "(", "Subtarget", "->", "isVIS3", "(", ")", ")", "{", "if", "(", "DstVT", "==", "MVT", "::", "f32", "&&", "SrcVT", "==", "MVT", "::", "i32", ")", "{", "return", "Op", ";", "}", "else", "if", "(", "DstVT", "==", "MVT", "::", "f64", "&&", "SrcVT", "==", "MVT", "::", "i64", ")", "{", "return", "(", "Subtarget", "->", "is64Bit", "(", ")", ")", "?", "Op", ":", "SDValue", "(", ")", ";", "}", "else", "if", "(", "DstVT", "==", "MVT", "::", "i64", "&&", "SrcVT", "==", "MVT", "::", "f64", ")", "{", "return", "(", "Subtarget", "->", "is64Bit", "(", ")", ")", "?", "Op", ":", "SDValue", "(", ")", ";", "}", "}", "return", "SDValue", "(", ")", ";", "}", "SDValue", "SparcTargetLowering", "::", "LowerUINT_TO_FP", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "<BUGE>", "SDLoc", "dl", "(", "Op", ")", ";", "EVT", "OpVT", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ";", "assert", "(", "OpVT", "==", "MVT", "::", "i32", "||", "OpVT", "==", "MVT", "::", "i64", ")", ";", "<BUGS>", "if", "(", "Op", ".", "getValueType", "(", ")", "==", "MVT", "::", "f128", "&&", "(", "!", "Subtarget", "->", "hasHardQuad", "(", ")", "||", "!", "isTypeLegal", "(", "OpVT", ")", ")", ")", "{", "return", "LowerF128Op", "(", "Op", ",", "DAG", ",", "getLibcallName", "(", "OpVT", "==", "MVT", "::", "i32", "?", "RTLIB", "::", "UINTTOFP_I32_F128", ":", "RTLIB", "::", "UINTTOFP_I64_F128", ")", ",", "<NUM_LIT>", ")", ";", "}", "if", "(", "DAG", ".", "SignBitIsZero", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{", "EVT", "floatVT", "=", "MVT", "::", "f32", ";", "unsigned", "IntToFloatOpcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "OpVT", "==", "MVT", "::", "i64", ")", "{", "floatVT", "=", "MVT", "::", "f64", ";", "IntToFloatOpcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "SDValue", "FloatTmp", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "floatVT", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "IntToFloatOpcode", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ",", "FloatTmp", ")", ";", "}", "if", "(", "OpVT", "==", "MVT", "::", "i32", "&&", "Subtarget", "->", "is64Bit", "(", ")", ")", "{", "SDValue", "Int64Tmp", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "MVT", "::", "i64", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "Float64Tmp", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "MVT", "::", "f64", ",", "Int64Tmp", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ",", "Float64Tmp", ")", ";", "}", "<BUGE>", "<BUGS>", "return", "SDValue", "(", ")", ";", "<BUGE>", "}", "static", "SDValue", "LowerBR_CC", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", "," ]

[ "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{" ]

[ "cerr", "<<", "<STR_LIT>", "loadRegToAddr() invoked!\\n", "<STR_LIT>", ";", "abort", "(", ")", ";", "if", "(", "Addr", "[", "<NUM_LIT>", "]", ".", "isFI", "(", ")", ")", "{", "}", "else", "{", "unsigned", "Opc", "=", "<NUM_LIT>", ";", "if", "(", "RC", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "}", "else", "if", "(", "RC", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "}", "else", "if", "(", "RC", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "}", "else", "if", "(", "RC", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "}", "else", "if", "(", "RC", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "}", "else", "if", "(", "RC", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "}", "else", "if", "(", "RC" ]

[ "return", "MCDisassembler", "::", "Success", ";" ]

[ "static", "DecodeStatus", "DecodeDPRRegisterClass", "(", "MCInst", "&", "Inst", ",", "unsigned", "RegNo", ",", "uint64_t", "Address", ",", "const", "void", "*", "Decoder", ")", "{", "const", "FeatureBitset", "&", "featureBits", "=", "(", "(", "const", "MCDisassembler", "*", ")", "Decoder", ")", "->", "getSubtargetInfo", "(", ")", ".", "getFeatureBits", "(", ")", ";", "bool", "hasD32", "=", "featureBits", "[", "ARM", "::", "FeatureD32", "]", ";", "if", "(", "RegNo", ">", "<NUM_LIT>", "||", "(", "!", "hasD32", "&&", "RegNo", ">", "<NUM_LIT>", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "unsigned", "Register", "=", "DPRDecoderTable", "[", "RegNo", "]", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "Register", ")", ")", ";" ]

[ "return", "new", "ELFX86_32AsmBackend", "(", "T", ",", "OSABI", ")", ";" ]

[ "if", "(", "TheTriple", ".", "isOSWindows", "(", ")", ")", "return", "new", "WindowsX86AsmBackend", "(", "T", ",", "false", ")", ";", "uint8_t", "OSABI", "=", "MCELFObjectTargetWriter", "::", "getOSABI", "(", "TheTriple", ".", "getOS", "(", ")", ")", ";" ]

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

[ "def", "C2_tfrpr", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Ps4", ")", ",", "<STR_LIT>", ",", "tc_0ae0825c", ",", "TypeS_2op", ">", ",", "Enc_f5e933", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "BI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", ":", "BI", "(", "eq", ":", "BI", "(", "and", ":", "DI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")" ]

[ "static", "unsigned", "HOST_WIDE_INT", "aarch64_asan_shadow_offset", "(", "void", ")", "{", "return", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", ";", "}" ]

[ "Implement", "the", "TARGET_ASAN_SHADOW_OFFSET", "hook", "." ]

[ "}" ]

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

[ "}" ]

[ "class", "OneXRegData", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "string", "asm", ",", "SDPatternOperator", "node", ">", ":", "BaseOneOperandData", "<", "opc", ",", "GPR64", ",", "asm", ",", "node", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

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

[ "if", "(", "!", "Memory", ".", "OffsetImm", ")", "return", "true", ";", "if", "(", "const", "auto", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Memory", ".", "OffsetImm", ")", ")", "{", "int64_t", "Val", "=", "CE", "->" ]

[ "}" ]

[ "const", "TargetRegisterClass", "*", "ARMBaseRegisterInfo", "::", "getLargestLegalSuperClass", "(", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "const", "TargetRegisterClass", "*", "Super", "=", "RC", ";", "TargetRegisterClass", "::", "sc_iterator", "I", "=", "RC", "->", "getSuperClasses", "(", ")", ";", "do", "{", "switch", "(", "Super", "->", "getID", "(", ")", ")", "{", "case", "ARM", "::", "GPRRegClassID", ":", "case", "ARM", "::", "SPRRegClassID", ":", "case", "ARM", "::", "DPRRegClassID", ":", "case", "ARM", "::", "QPRRegClassID", ":", "case", "ARM", "::", "QQPRRegClassID", ":", "case", "ARM", "::", "QQQQPRRegClassID", ":", "return", "Super", ";", "}", "Super", "=", "*", "I", "++", ";", "}", "while", "(", "Super", ")", ";", "return", "RC", ";" ]