Datasets:

docz1105

/

ComBack_Plus_Plus

like 0

[ "<STR_LIT>", ";" ]

[ "def", "memrix", ":", "Operand", "<", "iPTR", ">", "{", "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "MIOperandInfo", "=", "(", "ops", "dispRIX", ":", "$", "imm", ",", "ptr_rc_nor0", ":", "$", "reg", ")", ";", "let", "EncoderMethod", "=" ]

[ "static", "bool", "pru_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "switch", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", "{", "case", "<NUM_LIT>", ":", "return", "true", ";", "case", "<NUM_LIT>", ":", "return", "(", "regno", "%", "<NUM_LIT>", ")", "<=", "<NUM_LIT>", ";", "case", "<NUM_LIT>", ":", "return", "(", "regno", "%", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ";", "case", "<NUM_LIT>", ":", "return", "(", "regno", "%", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ";", "case", "<NUM_LIT>", ":", "return", "(", "regno", "%", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ";", "case", "<NUM_LIT>", ":", "return", "(", "regno", "%", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ";", "default", ":", "gcc_assert", "(", "mode", "==", "BLKmode", "||", "mode", "==", "VOIDmode", ")", ";", "return", "(", "regno", "%", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ";", "}", "}" ]

[ "Implement", "TARGET_HARD_REGNO_MODE_OK", "." ]

[ "v2i64", ",", "v1i64", ">", ";" ]

[ "def", ":", "ConcatPat", "<" ]

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

[ "}", "if", "(", "i", "!=", "PR_REG", "&&", "(", "i", "!=", "FPSCR_REG", "||", "!", "skip_fpscr", ")", "&&", "TEST_HARD_REG_BIT", "(", "*", "mask", ",", "i", ")", ")", "{", "if", "(", "!", "(", "sh_cfun_resbank_handler_p", "(", ")", "&&", "(", "(", "i", ">=", "FIRST_GENERAL_REG", "&&", "i", "<", "LAST_GENERAL_REG", ")", "||", "i", "==", "MACH_REG", "||", "i", "==", "MACL_REG", "||", "i", "==", "GBR_REG", ")", ")", ")", "push", "(", "i", ")", ";", "}", "}", "if", "(", "interrupt_handler", ")", "{", "bool", "use_movml", "=", "false", ";", "if", "(", "TARGET_SH2A", ")", "{", "unsigned", "int", "count", "=", "<NUM_LIT>", ";", "for", "(", "i", "=", "FIRST_BANKED_REG", ";", "i", "<=", "LAST_BANKED_REG", ";", "i", "++", ")", "if", "(", "TEST_HARD_REG_BIT", "(", "*", "mask", ",", "i", ")", ")", "count", "++", ";", "else", "break", ";", "if", "(", "count", "==", "LAST_BANKED_REG", "-", "FIRST_BANKED_REG", "+", "<NUM_LIT>", ")", "use_movml", "=", "true", ";", "}", "if", "(", "sh_cfun_resbank_handler_p", "(", ")", ")", ";", "else", "if", "(", "use_movml", ")", "{", "rtx", "x", ",", "mem", ",", "reg", ",", "set", ";", "rtx", "sp_reg", "=", "gen_rtx_REG", "(", "SImode", ",", "STACK_POINTER_REGNUM", ")", ";", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "x", "=", "gen_movml_push_banked", "(" ]

[ ",", "const", "MCRegisterInfo", "&", "MRI", ",", "const", "MCTargetOptions", "&", "Options", ")", "{" ]

[ "MCAsmBackend", "*", "llvm", "::", "createARMBEAsmBackend", "(", "const", "Target", "&", "T", ",", "const", "MCSubtargetInfo", "&", "STI" ]

[ "Rdd32", ";" ]

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

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

[ "field", "bits", "<", "<NUM_LIT>", ">", "SoftFail", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "V1", ";", "bits", "<", "<NUM_LIT>", ">", "BD2", ";", "bits", "<", "<NUM_LIT>", ">", "I3", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "I3", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "BD2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "V1", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ ";" ]

[ "virtual", "bool", "doFinalization", "(", "Module", "&", "M", ")", "{", "return", "false" ]

[ "pc_rtx", ",", "lab_ref", ")", ";" ]

[ "rtx", "lab_ref", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "strncmp_label", ")", ";", "rtx", "src_check", "=", "copy_addr_to_reg", "(", "XEXP", "(", "src", ",", "<NUM_LIT>", ")", ")", ";", "if", "(", "GET_MODE", "(", "src_check", ")", "==", "SImode", ")", "emit_insn", "(", "gen_andsi3", "(", "src_check", ",", "src_check", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ";", "else", "emit_insn", "(", "gen_anddi3", "(", "src_check", ",", "src_check", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ";", "rtx", "cond", "=", "gen_reg_rtx", "(", "CCmode", ")", ";", "emit_move_insn", "(", "cond", ",", "gen_rtx_COMPARE", "(", "CCmode", ",", "src_check", ",", "GEN_INT", "(", "<NUM_LIT>", "-", "bytes", ")", ")", ")", ";", "rtx", "cmp_rtx", "=", "gen_rtx_LT", "(", "VOIDmode", ",", "cond", ",", "const0_rtx", ")", ";", "rtx", "ifelse", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "cmp_rtx", "," ]

[ ":", "$", "Rm", ")", ")", ")", "]", ">", ";" ]

[ "def", "i32", ":", "BaseSIMDThreeScalarMixed", "<", "U", ",", "<NUM_LIT>", ",", "opc", ",", "(", "outs", "FPR64", ":", "$", "Rd", ")", ",", "(", "ins", "FPR32", ":", "$", "Rn", ",", "FPR32", ":", "$", "Rm", ")", ",", "asm", ",", "<STR_LIT>", ",", "[", "(", "set", "(", "i64", "FPR64", ":", "$", "Rd", ")", ",", "(", "OpNode", "(", "i32", "FPR32", ":", "$", "Rn", ")", ",", "(", "i32", "FPR32" ]

[ "return", "makeLibCall", "(", "DAG", ",", "LC", ",", "Op", ".", "getValueType", "(", ")", ",", "&", "SrcVal", ",", "<NUM_LIT>", ",", "false", ",", "SDLoc", "(", "Op", ")", ")", ".", "first", ";" ]

[ "RTLIB", "::", "Libcall", "LC", ";", "LC", "=", "RTLIB", "::", "getFPROUND", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "SDValue", "SrcVal", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";" ]

[ "let", "accessSize", "=", "ByteAccess", ";" ]

[ "def", "L2_loadrb_io", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "s32_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_17e0d2cd", ",", "TypeLD", ">", ",", "Enc_211aaa", ",", "AddrModeRel", ",", "PostInc_BaseImm", "{", "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", "addrMode", "=", "BaseImmOffset", ";" ]

[ "if", "(", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "predicate", ")", "(", "op0", ",", "mode2", ")", ")", "op0", "=", "copy_to_mode_reg", "(", "mode2", ",", "op0", ")", ";" ]

[ "machine_mode", "mode1", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "mode", ";", "machine_mode", "mode2", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "mode", ";", "if", "(", "arg0", "==", "error_mark_node", "||", "arg1", "==", "error_mark_node", "||", "arg2", "==", "error_mark_node", ")", "return", "const0_rtx", ";" ]

[ "_", "v32hi", ")", "_", "_", "Y", ",", "<NUM_LIT>", ",", "(", "_", "_", "mmask32", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "return", "(", "_", "_", "mmask32", ")", "_", "_", "builtin_ia32_cmpw512_mask", "(", "(", "_", "_", "v32hi", ")", "_", "_", "X", ",", "(", "_" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";" ]

[ ">", ",", "SDTCisVT", "<", "<NUM_LIT>", ",", "i32", ">", ",", "SDTCisSameAs", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ">", "]", ">", ";" ]

[ "def", "SDT_Ext", ":", "SDTypeProfile", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "[", "SDTCisInt", "<", "<NUM_LIT>", ">", ",", "SDTCisSameAs", "<", "<NUM_LIT>", ",", "<NUM_LIT>" ]

[ "]", ")" ]

[ "(", "define_mode_iterator", "CM", "[", "SI", "SF", "DF" ]

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

[ "SDValue", "One", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "InpTy", ")", ";", "SDValue", "IsZero", "=", "DAG", ".", "getSetCC", "(", "dl", ",", "PredTy", ",", "Op0", ",", "Zero", ",", "ISD", "::", "SETEQ", ")", ";", "SDValue", "Abs", "=", "Signed", "?", "DAG", ".", "getNode", "(", "ISD", "::", "ABS", ",", "dl", ",", "InpTy", ",", "Op0", ")", ":", "Op0", ";", "SDValue", "Clz", "=", "DAG", ".", "getNode", "(", "ISD", "::", "CTLZ", ",", "dl", ",", "InpTy", ",", "Abs", ")", ";", "SDValue", "NLeft", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "InpTy", ",", "{", "Clz", ",", "One", "}", ")", ";", "SDValue", "Frac0", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "dl", ",", "InpTy", ",", "{", "Abs", ",", "NLeft", "}", ")", ";", "auto", "[", "Frac", ",", "Ovf", "]", "=", "emitHvxShiftRightRnd", "(", "Frac0", ",", "ExpWidth", "+", "<NUM_LIT>", ",", "false", ",", "DAG", ")", ";", "if", "(", "Signed", ")", "{", "SDValue", "IsNeg", "=", "DAG", ".", "getSetCC", "(", "dl", ",", "PredTy", ",", "Op0", ",", "Zero", ",", "ISD", "::", "SETLT", ")", ";", "SDValue", "M80", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", "ull", "<<", "(", "ElemWidth", "-", "<NUM_LIT>", ")", ",", "dl", ",", "InpTy", ")", ";", "SDValue", "Sign", "=", "DAG", ".", "getNode", "(", "ISD", "::", "VSELECT", ",", "dl", ",", "InpTy", ",", "{", "IsNeg", ",", "M80", ",", "Zero", "}", ")", ";", "Frac", "=", "DAG", ".", "getNode", "(", "ISD", "::", "OR", ",", "dl", ",", "InpTy", ",", "{", "Sign", ",", "Frac", "}", ")", ";", "}", "SDValue", "Rnrm", "=", "DAG", ".", "getZExtOrTrunc", "(", "Ovf", ",", "dl", ",", "InpTy", ")", ";", "SDValue", "Exp0", "=", "DAG", ".", "getConstant", "(", "ElemWidth", "+", "ExpBias", ",", "dl", ",", "InpTy", ")", ";", "SDValue", "Exp1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "InpTy", ",", "{", "Rnrm", ",", "Exp0", "}", ")", ";", "SDValue", "Exp2", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SUB", ",", "dl", ",", "InpTy", ",", "{", "Exp1", ",", "NLeft", "}", ")", ";", "SDValue", "Exp3", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "dl", ",", "InpTy", ",", "{", "Exp2", ",", "DAG", ".", "getConstant", "(", "FracWidth", ",", "dl", ",", "InpTy", ")", "}", ")", ";", "SDValue", "Flt0", "=", "DAG", ".", "getNode", "(", "ISD", "::", "OR", ",", "dl", ",", "InpTy", ",", "{", "Frac", ",", "Exp3", "}", ")", ";", "SDValue", "Flt1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "VSELECT", ",", "dl", ",", "InpTy", ",", "{", "IsZero", ",", "Zero", ",", "Flt0", "}", ")", ";", "SDValue", "Flt", "=", "DAG", ".", "getBitcast", "(", "ResTy", "," ]

[ ",", "asm", ",", "PPR32", ">", ";" ]

[ "def", "_S", ":", "sve_int_perm_bin_perm_pp", "<", "opc", ",", "<NUM_LIT>" ]

[ "<FIXS>", "simplifyCFG", "(", "BB", ",", "TTI", ",", "RequireAndPreserveDomTree", "?", "&", "DTU", ":", "nullptr", ",", "<FIXE>" ]

[ "BB", "->", "getTerminator", "(", ")", "->", "eraseFromParent", "(", ")", ";", "BranchInst", "::", "Create", "(", "NewRetBlock", ",", "BB", ")", ";", "}", "for", "(", "BasicBlock", "*", "BB", ":", "ReturningBlocks", ")", "{", "<BUGS>", "simplifyCFG", "(", "BB", ",", "TTI", ",", "nullptr", ",", "<BUGE>", "SimplifyCFGOptions", "(", ")", ".", "bonusInstThreshold", "(", "<NUM_LIT>", ")", ")", ";", "}" ]

[ "}" ]

[ "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P0", "]", ";", "let", "Defs", "=", "[", "P0", ",", "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>", ";" ]

[ "<FIXS>", "MachineInstr", "*", "Begin", "=", "BuildMI", "(", "*", "Header", ",", "InsertPos", ",", "MBB", ".", "findDebugLoc", "(", "InsertPos", ")", ",", "<FIXE>", "<FIXS>", ".", "addImm", "(", "int64_t", "(", "WebAssembly", "::", "ExprType", "::", "Void", ")", ")", ";", "<FIXE>" ]

[ "}", "<BUGS>", "MachineInstr", "*", "Begin", "=", "BuildMI", "(", "*", "Header", ",", "InsertPos", ",", "DebugLoc", "(", ")", ",", "<BUGE>", "TII", ".", "get", "(", "WebAssembly", "::", "BLOCK", ")", ")", "<BUGS>", ".", "addImm", "(", "int64_t", "(", "WebAssembly", "::", "ExprType", "::", "Void", ")", ")", ";", "<BUGE>", "InsertPos", "=", "MBB", ".", "begin", "(", ")", ";" ]

[ "}" ]

[ "void", "RegDefsUses", "::", "addLiveOut", "(", "const", "MachineBasicBlock", "&", "MBB", ",", "const", "MachineBasicBlock", "&", "SuccBB", ")", "{", "for", "(", "MachineBasicBlock", "::", "const_succ_iterator", "SI", "=", "MBB", ".", "succ_begin", "(", ")", ",", "SE", "=", "MBB", ".", "succ_end", "(", ")", ";", "SI", "!=", "SE", ";", "++", "SI", ")", "if", "(", "*", "SI", "!=", "&", "SuccBB", ")", "for", "(", "unsigned", "LI", ":", "(", "*", "SI", ")", "->", "liveins", "(", ")", ")", "Uses", ".", "set", "(", "LI", ")", ";" ]

[ "<STR_LIT>" ]

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

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

[ "function_instance", "(", "const", "char", "*", "base_name_in", ",", "const", "function_base", "*", "base_in", ",", "const", "function_shape", "*", "shape_in", ",", "mode_suffix_index", "mode_suffix_id_in", ",", "const", "type_suffix_pair", "&", "type_suffix_ids_in", ",", "predication_index", "pred_in", ")", ":", "base_name", "(", "base_name_in", ")", ",", "base", "(", "base_in", ")", ",", "shape", "(", "shape_in", ")", ",", "mode_suffix_id", "(", "mode_suffix_id_in", ")", ",", "pred", "(", "pred_in", ")", "{", "memcpy", "(", "type_suffix_ids", ",", "type_suffix_ids_in", ",", "sizeof" ]

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

[ "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "sign_extend", ":", "DI", "(", "match_dup", "<NUM_LIT>" ]

[ ")", ")" ]

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

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

[ "MachineRegisterInfo", "&", "MRI", "=", "MBB", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "Register", "Reg", "=", "MRI", ".", "createVirtualRegister", "(", "RI", ".", "getBoolRC" ]

[ ")", "(", "nil", ")", "]", ")" ]

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

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

[ "using", "namespace", "llvm", ";", "void", "ARMJITInfo", "::", "replaceMachineCodeForFunction", "(", "void", "*", "Old", ",", "void", "*", "New", ")", "{", "<BUGS>", "unsigned", "char", "*", "OldByte", "=", "(", "unsigned", "char", "*", ")", "Old", ";", "*", "OldByte", "++", "=", "<NUM_LIT>", ";", "unsigned", "*", "OldWord", "=", "(", "unsigned", "*", ")", "OldByte", ";", "unsigned", "NewAddr", "=", "(", "intptr_t", ")", "New", ";", "unsigned", "OldAddr", "=", "(", "intptr_t", ")", "OldWord", ";", "*", "OldWord", "=", "NewAddr", "-", "OldAddr", "-", "<NUM_LIT>", ";", "<BUGE>", "}" ]

[ ";" ]

[ "PDT", "=", "&", "getAnalysis", "<", "MachinePostDominatorTree", ">", "(", ")", ";", "ST", "=", "&", "MF", "->", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", "->", "getInstrInfo", "(", ")", ";", "lowerCopiesFromI1", "(", ")", ";", "lowerPhis", "(", ")", ";", "lowerCopiesToI1", "(", ")" ]

[ "if", "(", "float_mode_p", ")", "*", "total", "=", "cost_data", "->", "fp_add", ";" ]

[ "int", "code", "=", "GET_CODE", "(", "x", ")", ";", "bool", "float_mode_p", "=", "FLOAT_MODE_P", "(", "mode", ")", ";", "const", "struct", "alpha_rtx_cost_data", "*", "cost_data", ";", "if", "(", "!", "speed", ")", "cost_data", "=", "&", "alpha_rtx_cost_size", ";", "else", "cost_data", "=", "&", "alpha_rtx_cost_data", "[", "alpha_tune", "]", ";", "switch", "(", "code", ")", "{", "case", "CONST_INT", ":", "if", "(", "INTVAL", "(", "x", ")", ">=", "<NUM_LIT>", "&&", "INTVAL", "(", "x", ")", "<", "<NUM_LIT>", ")", "{", "*", "total", "=", "<NUM_LIT>", ";", "return", "true", ";", "}", "case", "CONST_DOUBLE", ":", "case", "CONST_WIDE_INT", ":", "if", "(", "x", "==", "CONST0_RTX", "(", "mode", ")", ")", "*", "total", "=", "<NUM_LIT>", ";", "else", "if", "(", "(", "outer_code", "==", "PLUS", "&&", "add_operand", "(", "x", ",", "VOIDmode", ")", ")", "||", "(", "outer_code", "==", "AND", "&&", "and", "_", "operand", "(", "x", ",", "VOIDmode", ")", ")", ")", "*", "total", "=", "<NUM_LIT>", ";", "else", "if", "(", "add_operand", "(", "x", ",", "VOIDmode", ")", "||", "and", "_", "operand", "(", "x", ",", "VOIDmode", ")", ")", "*", "total", "=", "<NUM_LIT>", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "if", "(", "TARGET_EXPLICIT_RELOCS", "&&", "small_symbolic_operand", "(", "x", ",", "VOIDmode", ")", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "outer_code", "!=", "MEM", ")", ";", "else", "if", "(", "TARGET_EXPLICIT_RELOCS", "&&", "local_symbolic_operand", "(", "x", ",", "VOIDmode", ")", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", "+", "(", "outer_code", "!=", "MEM", ")", ")", ";", "else", "if", "(", "tls_symbolic_operand_type", "(", "x", ")", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "!", "speed", "?", "<NUM_LIT>", ":", "alpha_memory_latency", ")", ";", "return", "true", ";", "case", "HIGH", ":", "*", "total", "=", "<NUM_LIT>", ";", "return", "true", ";", "case", "PLUS", ":", "case", "MINUS", ":", "if", "(", "float_mode_p", ")", "*", "total", "=", "cost_data", "->", "fp_add", ";", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "MULT", "&&", "const48_operand", "(", "XEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ",", "VOIDmode", ")", ")", "{", "*", "total", "=", "(", "rtx_cost", "(", "XEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ",", "mode", ",", "(", "enum", "rtx_code", ")", "outer_code", ",", "opno", ",", "speed", ")", "+", "rtx_cost", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "mode", ",", "(", "enum", "rtx_code", ")", "outer_code", ",", "opno", ",", "speed", ")", "+", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "case", "MULT", ":", "if", "(", "float_mode_p", ")", "*", "total", "=", "cost_data", "->", "fp_mult", ";", "else", "if", "(", "mode", "==", "DImode", ")", "*", "total", "=", "cost_data", "->", "int_mult_di", ";", "else", "*", "total", "=", "cost_data", "->", "int_mult_si", ";", "return", "false", ";", "case", "ASHIFT", ":", "if", "(", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "&&", "INTVAL", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "<=", "<NUM_LIT>", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "return", "false", ";", "}", "case", "ASHIFTRT", ":", "case", "LSHIFTRT", ":", "*", "total", "=", "cost_data", "->", "int_shift", ";", "return", "false", ";", "case", "IF_THEN_ELSE", ":" ]

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

[ "assert", "(", "TM", ".", "getInstrItineraryData", "(", ")", "&&", "!", "TM", ".", "getInstrItineraryData", "(", ")", "->", "isEmpty", "(", ")", ")", ";", "unsigned", "NumCycles", "=", "<NUM_LIT>", ";", "CustomListScheduler", "*", "Scheduler", "=", "new", "CustomListScheduler", "(", "Fn", ",", "MLI", ",", "MDT", ",", "HR", ",", "AA", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "Fn", ".", "begin", "(", ")", ",", "MBBe", "=", "Fn", ".", "end", "(", ")", ";", "MBB", "!=", "MBBe", ";", "++", "MBB", ")", "{", "unsigned", "BlockCycles", "=", "<NUM_LIT>", ";", "addTerminatorInstr", "(", "MBB", ")", ";", "bool", "BlockHasTerm", "=", "prior", "(", "MBB", "->", "end", "(", ")", ")", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ";", "Scheduler", "->", "StartBlock", "(", "MBB", ")", ";", "MachineBasicBlock", "::", "iterator", "Current", "=", "MBB", "->", "end", "(", ")", ";", "unsigned", "Count", "=", "MBB", "->", "size", "(", ")", ",", "CurrentCount", "=", "Count", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "Current", ";", "I", "!=", "MBB", "->", "begin", "(", ")", ";", ")", "{", "MachineInstr", "*", "MI", "=", "prior", "(", "I", ")", ";", "if", "(", "isSchedulingBoundary", "(", "MI", ",", "Fn", ")", ")", "{", "Scheduler", "->", "Run", "(", "MBB", ",", "I", ",", "Current", ",", "CurrentCount", ")", ";", "BlockCycles", "+=", "Scheduler", "->", "getCycles", "(", ")", ";", "Scheduler", "->", "EmitSchedule", "(", ")", ";", "Current", "=", "MI", ";", "CurrentCount", "=", "Count", "-", "<NUM_LIT>", ";", "Scheduler", "->", "Observe", "(", "MI", ",", "CurrentCount", ")", ";", "}", "I", "=", "MI", ";", "--", "Count", ";", "}", "assert", "(", "Count", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Instruction count mismatch!", "<STR_LIT>", ")", ";", "assert", "(", "(", "MBB", "->", "begin", "(", ")", "==", "Current", "||", "CurrentCount", "!=", "<NUM_LIT>", ")", "&&", "<STR_LIT>", "Instruction count mismatch!", "<STR_LIT>", ")", ";", "Scheduler", "->", "Run", "(", "MBB", ",", "MBB", "->", "begin", "(", ")", ",", "Current", ",", "CurrentCount", ")", ";", "BlockCycles", "+=", "Scheduler", "->", "getCycles", "(", ")", ";", "Scheduler", "->", "EmitSchedule", "(", ")", ";", "if", "(", "BlockHasTerm", ")", "{", "MachineBasicBlock", "::", "iterator", "LastMI", "=", "MBB", "->", "end", "(", ")", ";", "do", "{", "LastMI", "=", "prior", "(" ]

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

[ "class", "Inst_r", "<", "bits", "<", "<NUM_LIT>", ">", "opclass", ",", "bits", "<", "<NUM_LIT>", ">", "opcode", ",", "dag", "outs", ",", "dag", "ins", ",", "string", "asmstr", ",", "list", "<", "dag", ">", "pattern", ">", ":", "Inst_rrr", "<", "opclass", ",", "opcode", ",", "outs", ",", "ins", ",", "asmstr", ",", "pattern", ">", "{", "let", "rA", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "const", "uint16_t", "*", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", "=", "<NUM_LIT>", ")", "const", ";", "<FIXE>" ]

[ "void", "adjustMipsStackFrame", "(", "MachineFunction", "&", "MF", ")", "const", ";", "<BUGS>", "const", "uint16_t", "*", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", "=", "<NUM_LIT>", ")", "const", ";", "<BUGE>", "const", "uint32_t", "*", "getCallPreservedMask", "(", "CallingConv", "::", "ID", ")", "const", ";", "BitVector", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", ";" ]

[ "<FIXS>", "stack_pointer_rtx", ",", "<NUM_LIT>", ",", "NULL", ")", ";", "<FIXE>" ]

[ "output_stack_adjust", "(", "extra_push", "+", "current_function_pretend_args_size", "<BUGS>", "stack_pointer_rtx", ",", "<NUM_LIT>", ",", "emit_insn", ")", ";", "<BUGE>", "if", "(", "current_function_calls_eh_return", ")", "emit_insn", "(", "GEN_ADD3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", "," ]

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

[ "for", "(", "auto", "HMI", ":", "HexagonMCInstrInfo", "::", "bundleInstructions", "(", "MCB", ")", ")", "{", "MCInst", "const", "&", "MCI", "=", "*", "HMI", ".", "getInst", "(", ")", ";", "if", "(", "HexagonMCInstrInfo", "::", "isImmext", "(", "MCI", ")", ")", "continue", ";", "if", "(", "HexagonMCInstrInfo", "::", "isDuplex", "(", "MCII", ",", "MCI", ")", ")", "slotsUsed" ]

[ ")", "{" ]

[ "const", "MCInstrDesc", "&", "MCID", "=", "MI", "->", "getDesc", "(", ")", ";", "unsigned", "NumOps", "=", "MCID", ".", "getNumOperands", "(", ")", ";", "unsigned", "JTOpIdx", "=", "NumOps", "-", "(", "MI", "->", "isPredicable", "(", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "MachineOperand", "JTOP", "=", "MI", "->", "getOperand", "(", "JTOpIdx", ")", ";", "unsigned", "JTI", "=", "JTOP", ".", "getIndex", "(", ")", ";", "assert", "(", "JTI", "<", "JT", ".", "size", "(", ")", ")", ";", "int", "JTNumber", "=", "MI", "->", "getParent", "(", ")", "->", "getNumber", "(", ")", ";", "const", "std", "::", "vector", "<", "MachineBasicBlock", "*", ">", "&", "JTBBs", "=", "JT", "[", "JTI", "]", ".", "MBBs", ";", "for", "(", "MachineBasicBlock", "*", "MBB", ":", "JTBBs", ")", "{", "int", "DTNumber", "=", "MBB", "->", "getNumber", "(", ")", ";", "if", "(", "DTNumber", "<", "JTNumber" ]

[ "<FIXS>", "static", "void", "fail", "(", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ",", "const", "char", "*", "Msg", ")", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "DAG", ".", "getContext", "(", ")", "->", "diagnose", "(", "DiagnosticInfoUnsupported", "(", "*", "MF", ".", "getFunction", "(", ")", ",", "Msg", ",", "DL", ".", "getDebugLoc", "(", ")", ")", ")", ";", "}", "<FIXE>", "<FIXS>", "static", "void", "fail", "(", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ",", "const", "char", "*", "Msg", ",", "SDValue", "Val", ")", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "std", "::", "string", "Str", ";", "raw_string_ostream", "OS", "(", "Str", ")", ";", "OS", "<<", "Msg", ";", "Val", "->", "print", "(", "OS", ")", ";", "OS", ".", "flush", "(", ")", ";", "DAG", ".", "getContext", "(", ")", "->", "diagnose", "(", "DiagnosticInfoUnsupported", "(", "*", "MF", ".", "getFunction", "(", ")", ",", "Str", ",", "DL", ".", "getDebugLoc", "(", ")", ")", ")", ";", "<FIXE>" ]

[ "#", "define", "DEBUG_TYPE", "<STR_LIT>", "bpf-lower", "<STR_LIT>", "<BUGS>", "namespace", "{", "class", "DiagnosticInfoUnsupported", ":", "public", "DiagnosticInfo", "{", "private", ":", "DebugLoc", "DLoc", ";", "const", "Twine", "&", "Description", ";", "const", "Function", "&", "Fn", ";", "SDValue", "Value", ";", "static", "int", "KindID", ";", "static", "int", "getKindID", "(", ")", "{", "if", "(", "KindID", "==", "<NUM_LIT>", ")", "KindID", "=", "llvm", "::", "getNextAvailablePluginDiagnosticKind", "(", ")", ";", "return", "KindID", ";", "}", "public", ":", "DiagnosticInfoUnsupported", "(", "SDLoc", "DLoc", ",", "const", "Function", "&", "Fn", ",", "const", "Twine", "&", "Desc", ",", "SDValue", "Value", ")", ":", "DiagnosticInfo", "(", "getKindID", "(", ")", ",", "DS_Error", ")", ",", "DLoc", "(", "DLoc", ".", "getDebugLoc", "(", ")", ")", ",", "Description", "(", "Desc", ")", ",", "Fn", "(", "Fn", ")", ",", "Value", "(", "Value", ")", "{", "}", "void", "print", "(", "DiagnosticPrinter", "&", "DP", ")", "const", "override", "{", "std", "::", "string", "Str", ";", "raw_string_ostream", "OS", "(", "Str", ")", ";", "if", "(", "DLoc", ")", "{", "auto", "DIL", "=", "DLoc", ".", "get", "(", ")", ";", "StringRef", "Filename", "=", "DIL", "->", "getFilename", "(", ")", ";", "unsigned", "Line", "=", "DIL", "->", "getLine", "(", ")", ";", "unsigned", "Column", "=", "DIL", "->", "getColumn", "(", ")", ";", "OS", "<<", "Filename", "<<", "'", ":", "'", "<<", "Line", "<<", "'", ":", "'", "<<", "Column", "<<", "'", "'", ";", "}", "OS", "<<", "<STR_LIT>", "in function ", "<STR_LIT>", "<<", "Fn", ".", "getName", "(", ")", "<<", "'", "'", "<<", "*", "Fn", ".", "getFunctionType", "(", ")", "<<", "'", "\\n", "'", "<<", "Description", ";", "if", "(", "Value", ")", "Value", "->", "print", "(", "OS", ")", ";", "OS", "<<", "'", "\\n", "'", ";", "OS", ".", "flush", "(", ")", ";", "DP", "<<", "Str", ";", "}", "static", "bool", "classof", "(", "const", "DiagnosticInfo", "*", "DI", ")", "{", "return", "DI", "->", "getKind", "(", ")", "==", "getKindID", "(", ")", ";", "}", "}", ";", "<BUGE>", "<BUGS>", "int", "DiagnosticInfoUnsupported", "::", "KindID", "=", "<NUM_LIT>", ";", "<BUGE>", "}", "BPFTargetLowering", "::", "BPFTargetLowering", "(", "const", "TargetMachine", "&", "TM", "," ]

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

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

[ "(", "_", "_", "v16sf", ")", "_", "mm512_setzero_ps", "(", ")", ",", "(", "_", "_", "mmask16", ")", "_", "_", "U", ",", "_", "MM_FROUND_CUR_DIRECTION", ")", ";" ]

[ "return", "(", "_", "_", "m512", ")", "_", "_", "builtin_ia32_divps512_mask", "(", "(", "_", "_", "v16sf", ")", "_", "_", "A", ",", "(", "_", "_", "v16sf", ")", "_", "_", "B", "," ]

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

[ "return", "_", "_", "builtin_neon_sudot_lanev16qi_sssus", "(", "_", "_", "r", ",", "_", "_", "a", ",", "_", "_" ]

[ "(", "define_bypass", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "(", "define_bypass", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "<STR_LIT>", "OR1K DAG->DAG Pattern Instruction Selection", "<STR_LIT>", ";", "}" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

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

[ "const", "MachineOperand", "&", "MO1", "=", "MI", "->", "getOperand", "(", "Op", ")", ";", "const", "MachineOperand", "&", "MO2", "=", "MI", "->", "getOperand", "(", "Op", "+", "<NUM_LIT>", ")", ";", "O", "<<", "<STR_LIT>", "[", "<STR_LIT>", "<<", "getRegisterName", "(", "MO1", "." ]

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

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

[ ")", "{" ]

[ "parseRegForInlineAsmConstraint", "(", "const", "StringRef", "&", "C", ",", "MVT", "VT", ")", "const", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "getTargetMachine", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", ";", "std", "::", "string", "Prefix", ";", "unsigned", "long", "long", "Reg", ";", "std", "::", "pair", "<", "bool", ",", "bool", ">", "R", "=", "parsePhysicalReg", "(", "C", ",", "Prefix", ",", "Reg", ")", ";", "if", "(", "!", "R", ".", "first", ")", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "<NUM_LIT>", ",", "(", "const", "TargetRegisterClass", "*", ")", "<NUM_LIT>", ")", ";", "if", "(", "(", "Prefix", "==", "<STR_LIT>", "hi", "<STR_LIT>", "||", "Prefix", "==", "<STR_LIT>", "lo", "<STR_LIT>", ")", ")", "{", "if", "(", "R", ".", "second", ")", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "<NUM_LIT>", ",", "(", "const", "TargetRegisterClass", "*", ")", "<NUM_LIT>", ")", ";", "RC", "=", "TRI", "->", "getRegClass", "(", "Prefix", "==", "<STR_LIT>", "hi", "<STR_LIT>", "?", "Mips", "::", "HI32RegClassID", ":", "Mips", "::", "LO32RegClassID", ")", ";", "return", "std", "::", "make_pair", "(", "*", "(", "RC", "->", "begin", "(", ")", ")", ",", "RC", ")", ";", "}", "if", "(", "!", "R", ".", "second", ")", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "<NUM_LIT>", ",", "(", "const", "TargetRegisterClass", "*", ")", "<NUM_LIT>", ")", ";", "if", "(", "Prefix", "==", "<STR_LIT>", "$f", "<STR_LIT>" ]

[ "void", "s390_d_target_versions", "(", "void", ")", "{", "if", "(", "TARGET_64BIT", ")", "{", "d_add_builtin_version", "(", "<STR_LIT>", "S390X", "<STR_LIT>", ")", ";", "d_add_builtin_version", "(", "<STR_LIT>", "SystemZ", "<STR_LIT>", ")", ";", "}", "else", "d_add_builtin_version", "(", "<STR_LIT>", "S390", "<STR_LIT>", ")", ";", "if", "(", "TARGET_SOFT_FLOAT", ")", "d_add_builtin_version", "(", "<STR_LIT>", "D_SoftFloat", "<STR_LIT>", ")", ";", "else", "if", "(", "TARGET_HARD_FLOAT", ")", "d_add_builtin_version", "(", "<STR_LIT>", "D_HardFloat", "<STR_LIT>", ")", ";", "}" ]

[ "Implement", "TARGET_D_CPU_VERSIONS", "for", "S/390", "and", "zSeries", "targets", "." ]

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

[ "def", "A2_aslh", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_57890846", ",", "TypeALU32_2op", ">", ",", "Enc_5e2823", ",", "PredNewRel", "{", "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", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isPredicable" ]

[ "}" ]

[ "void", "DCPU16InstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ")", "{", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";" ]

[ "const", "char", "*", "getClearCacheBuiltinName", "(", ")", "const", "override", "{", "report_fatal_error", "(", "<STR_LIT>", "llvm.clear_cache is not supported on wasm", "<STR_LIT>", ")", ";", "}" ]

[ "Intel", "processors", "have", "a", "unified", "instruction", "and", "data", "cache", "." ]

[ "<FIXS>", "argt", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "getValueType", "(", "I", "->", "getType", "(", ")", ")", ",", "<FIXE>" ]

[ "argt", "=", "new", "root", "=", "DAG", ".", "getCopyFromReg", "(", "DAG", ".", "getRoot", "(", ")", ",", "argVreg", "[", "count", "]", ",", "MVT", "::", "i64", ")", ";", "if", "(", "getValueType", "(", "I", "->", "getType", "(", ")", ")", "!=", "MVT", "::", "i64", ")", "<BUGS>", "argt", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "getValueType", "(", "I", "->", "getType", "(", ")", ")", ",", "<BUGE>", "new", "root", ")", ";", "break", ";", "}" ]

[ "static", "void", "save_reg", "(", "int", "regno", ",", "unsigned", "offset", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "rtx", "addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "gen_int_mode", "(", "offset", ",", "Pmode", ")", ")", ";", "rtx", "insn", "=", "emit_move_insn", "(", "gen_frame_mem", "(", "Pmode", ",", "addr", ")", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "}" ]

[ "Generate", "save/restore", "of", "register", "REGNO", "at", "SP", "+", "OFFSET", ".", "Used", "by", "the", "prologue/epilogue", "expand", "routines", "." ]

[ "PA", ".", "Addr", "->", "addMember", "(", "PUA", ",", "*", "this", ")", ";" ]

[ "BlockRefsMap", "RefM", ";", "buildBlockRefs", "(", "EA", ",", "RefM", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "MachineBasicBlock", "&", "EntryB", "=", "*", "EA", ".", "Addr", "->", "getCode", "(", ")", ";", "assert", "(", "EntryB", ".", "pred_empty", "(", ")", "&&", "<STR_LIT>", "Function entry block has predecessors", "<STR_LIT>", ")", ";", "for", "(", "auto", "I", "=", "MRI", ".", "livein_begin", "(", ")", ",", "E", "=", "MRI", ".", "livein_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "LiveIns", ".", "insert", "(", "RegisterRef", "(", "I", "->", "first", ")", ")", ";", "for", "(", "auto", "I", ":", "EntryB", ".", "liveins", "(", ")", ")", "LiveIns", ".", "insert", "(", "RegisterRef", "(", "I", ".", "PhysReg", ",", "I", ".", "LaneMask", ")", ")", ";", "for", "(", "std", "::", "pair", "<", "RegisterId", ",", "LaneBitmask", ">", "P", ":", "LiveIns", ")", "{", "NodeAddr", "<", "PhiNode", "*", ">", "PA", "=", "new", "Phi", "(", "EA", ")", ";", "uint16_t", "PhiFlags", "=", "NodeAttrs", "::", "PhiRef", "|", "NodeAttrs", "::", "Preserving", ";", "RegisterRef", "RR", "(", "P", ".", "first", ",", "P", ".", "second", ")", ";", "NodeAddr", "<", "DefNode", "*", ">", "DA", "=", "new", "Def", "(", "PA", ",", "RR", ",", "PhiFlags", ")", ";", "PA", ".", "Addr", "->", "addMember", "(", "DA", ",", "*", "this", ")", ";", "}", "RegisterSet", "EHRegs", "=", "getLandingPadLiveIns", "(", ")", ";", "if", "(", "!", "EHRegs", ".", "empty", "(", ")", ")", "{", "for", "(", "NodeAddr", "<", "BlockNode", "*", ">", "BA", ":", "Blocks", ")", "{", "const", "MachineBasicBlock", "&", "B", "=", "*", "BA", ".", "Addr", "->", "getCode", "(", ")", ";", "if", "(", "!", "B", ".", "isEHPad", "(", ")", ")", "continue", ";", "NodeList", "Preds", ";", "for", "(", "MachineBasicBlock", "*", "PB", ":", "B", ".", "predecessors", "(", ")", ")", "Preds", ".", "push_back", "(", "findBlock", "(", "PB", ")", ")", ";", "for", "(", "RegisterRef", "RR", ":", "EHRegs", ")", "{", "NodeAddr", "<", "PhiNode", "*", ">", "PA", "=", "new", "Phi", "(", "BA", ")", ";", "uint16_t", "PhiFlags", "=", "NodeAttrs", "::", "PhiRef", "|", "NodeAttrs", "::", "Preserving", ";", "NodeAddr", "<", "DefNode", "*", ">", "DA", "=", "new", "Def", "(", "PA", ",", "RR", ",", "PhiFlags", ")", ";", "PA", ".", "Addr", "->", "addMember", "(", "DA", ",", "*", "this", ")", ";", "for", "(", "NodeAddr", "<", "BlockNode", "*", ">", "PBA", ":", "Preds", ")", "{", "NodeAddr", "<", "PhiUseNode", "*", ">", "PUA", "=", "new", "PhiUse", "(", "PA", ",", "RR", ",", "PBA", ")", ";" ]

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

[ "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "MID", "=", "MI", "->", "getDesc", "(", ")", ";", "unsigned", "Count", "=", "<NUM_LIT>", ";", "for", "(", "unsigned", "OpIdx", "=", "<NUM_LIT>", ";", "OpIdx", "<", "MID", ".", "getNumOperands", "(", ")", ";", "OpIdx", "++", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "TII", "->", "getRegClass", "(", "MID", ",", "OpIdx", ",", "TRI", ",", "MF", ")", ";", "if", "(", "RC", "==", "nullptr", ")", "continue", ";", "if", "(", "OpIdx", ">=", "MID", ".", "getNumDefs", "(", ")", "&&", "MID", ".", "getOperandConstraint", "(", "OpIdx", ",", "MCOI", "::", "TIED_TO", ")", "!=", "-", "<NUM_LIT>", ")", "continue", ";", "Count", "++", ";", "}" ]

[ "SETEQ", ")", "{" ]

[ "SDValue", "Dest", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDLoc", "dl", "(", "Op", ")", ";", "if", "(", "LHS", ".", "getValueType", "(", ")", ".", "isInteger", "(", ")", ")", "{", "const", "ConstantSDNode", "*", "RHSC", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "RHS", ")", ";", "if", "(", "RHSC", "&&", "RHSC", "->", "getZExtValue", "(", ")", "==", "<NUM_LIT>", ")", "{", "if", "(", "CC", "==", "ISD", "::" ]

[ "=", "sat", ";" ]

[ "class", "MVE_ScalarShiftDRegRegWithSat", "<", "string", "iname", ",", "bit", "op5", ",", "list", "<", "dag", ">", "pattern", "=", "[", "]", ">", ":", "MVE_ScalarShiftDRegRegBase", "<", "iname", ",", "(", "ins", "tGPREven", ":", "$", "RdaLo_src", ",", "tGPROdd", ":", "$", "RdaHi_src", ",", "rGPR", ":", "$", "Rm", ",", "saturateop", ":", "$", "sat", ")", ",", "<STR_LIT>", ",", "op5", ",", "<NUM_LIT>", ",", "pattern", ">", "{", "bit", "sat", ";", "let", "Inst", "{", "<NUM_LIT>", "}" ]

[ "static", "rtx", "ix86_expand_vec_init_builtin", "(", "tree", "type", ",", "tree", "exp", ",", "rtx", "target", ")", "{", "machine_mode", "tmode", "=", "TYPE_MODE", "(", "type", ")", ";", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "tmode", ")", ";", "int", "i", ",", "n_elt", "=", "GET_MODE_NUNITS", "(", "tmode", ")", ";", "rtvec", "v", "=", "rtvec_alloc", "(", "n_elt", ")", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "tmode", ")", ")", ";", "gcc_assert", "(", "call_expr_nargs", "(", "exp", ")", "==", "n_elt", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "n_elt", ";", "++", "i", ")", "{", "rtx", "x", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "i", ")", ")", ";", "RTVEC_ELT", "(", "v", ",", "i", ")", "=", "gen_lowpart", "(", "inner_mode", ",", "x", ")", ";", "}", "if", "(", "!", "target", "||", "!", "register_operand", "(", "target", ",", "tmode", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "ix86_expand_vector_init", "(", "true", ",", "target", ",", "gen_rtx_PARALLEL", "(", "tmode", ",", "v", ")", ")", ";", "return", "target", ";", "}" ]

[ "A", "subroutine", "of", "ix86_expand_builtin", ".", "These", "builtins", "are", "a", "wrapper", "around", "ix86_expand_vector_init", ".", "We", "DO", "have", "language-level", "syntax", "for", "this", ",", "in", "the", "form", "of", "(", "type", ")", "{", "init-list", "}", ".", "Except", "that", "since", "we", "ca", "n't", "place", "emms", "instructions", "from", "inside", "the", "compiler", ",", "we", "ca", "n't", "allow", "the", "use", "of", "MMX", "registers", "unless", "the", "user", "explicitly", "asks", "for", "it", ".", "So", "we", "do", "*", "not", "*", "define", "vec_set/vec_extract/vec_init", "patterns", "for", "MMX", "modes", "in", "mmx.md", ".", "Instead", "we", "have", "builtins", "invoked", "by", "mmintrin.h", "that", "gives", "us", "license", "to", "emit", "these", "sorts", "of", "instructions", "." ]

[ "<STR_LIT>" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "<", "avx512fmaskmode", ">", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operator", ":", "<", "avx512fmaskmode", ">", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", ":", "VI12_AVX512VL", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VI12_AVX512VL", "<NUM_LIT>", "<STR_LIT>", ")", "]", ")", ")", "]" ]

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

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

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

[ "bits", "<", "<NUM_LIT>", ">", "op2", ";", "bits", "<", "<NUM_LIT>", ">", "dt", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "op1", ";", "let", "SrcB", "=", "op2", ";", "let", "OperandType", "=", "optype", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Switches", "=", "sw", ";", "let", "VectorPred", "=", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Pred", ")", ",", "<STR_LIT>", ")", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";" ]

[ ")", ";" ]

[ "setOperationAction", "(", "ISD", "::", "STORE", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "STORE", ",", "MVT", "::", "i64", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "STORE", ",", "MVT", "::", "v2i32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "STORE", ",", "MVT", "::", "v4i32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SELECT", ",", "MVT", "::", "i64", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SELECT", ",", "MVT", "::", "f64", ",", "Promote", ")", ";", "AddPromotedToType", "(", "ISD", "::", "SELECT", ",", "MVT", "::", "f64", ",", "MVT", "::", "i64", ")", ";", "setOperationAction", "(", "ISD", "::", "SELECT_CC", ",", "MVT", "::", "f32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SELECT_CC", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SELECT_CC", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SETCC", ",", "MVT", "::", "v2i1", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SETCC", ",", "MVT", "::", "v4i1", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ANY_EXTEND", ",", "MVT", "::", "i64", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND", ",", "MVT", "::", "i64", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "ZERO_EXTEND", ",", "MVT", "::", "i64", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "i1", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "v2i1", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "v4i1", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "i8", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "v2i8", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "v4i8", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "i16", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "v2i16", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "v4i16", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "Other", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "INTRINSIC_WO_CHAIN", ",", "MVT", "::", "Other", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "INTRINSIC_WO_CHAIN", ",", "MVT", "::", "f32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "INTRINSIC_WO_CHAIN", ",", "MVT", "::", "v16i8", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "INTRINSIC_WO_CHAIN", ",", "MVT", "::", "v4f32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "INTRINSIC_VOID", ",", "MVT", "::", "Other", ",", "Custom", ")", ";", "setLoadExtAction", "(", "ISD", "::", "SEXTLOAD", ",", "MVT", "::", "i1", ",", "Promote", ")", ";", "setLoadExtAction", "(", "ISD", "::", "SEXTLOAD", ",", "MVT", "::", "i8", ",", "Custom", ")", ";", "setLoadExtAction", "(", "ISD", "::", "SEXTLOAD", ",", "MVT", "::", "i16", ",", "Custom", ")", ";", "setLoadExtAction", "(", "ISD", "::", "SEXTLOAD", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setLoadExtAction", "(", "ISD", "::", "SEXTLOAD", ",", "MVT", "::", "v8i16", ",", "Expand", ")", ";", "setLoadExtAction", "(", "ISD", "::", "SEXTLOAD", ",", "MVT", "::", "v16i16", ",", "Expand", ")", ";", "setLoadExtAction", "(", "ISD", "::", "ZEXTLOAD", ",", "MVT", "::", "i1", ",", "Promote", ")", ";", "setLoadExtAction", "(", "ISD", "::", "ZEXTLOAD", ",", "MVT", "::", "i8", ",", "Custom", ")", ";", "setLoadExtAction", "(", "ISD", "::", "ZEXTLOAD", ",", "MVT", "::", "i16", ",", "Custom", ")", ";", "setLoadExtAction", "(", "ISD", "::", "ZEXTLOAD", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setLoadExtAction", "(", "ISD", "::", "EXTLOAD", ",", "MVT", "::", "i1", ",", "Promote", ")", ";", "setLoadExtAction", "(", "ISD", "::", "EXTLOAD", ",", "MVT", "::", "i8", ",", "Custom", ")", ";", "setLoadExtAction", "(", "ISD", "::", "EXTLOAD", ",", "MVT", "::", "i16", ",", "Custom", ")", ";", "setLoadExtAction", "(", "ISD", "::", "EXTLOAD", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setLoadExtAction", "(", "ISD", "::", "EXTLOAD", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setTruncStoreAction", "(", "MVT", "::", "i32", ",", "MVT", "::", "i8", ",", "Custom", ")", ";", "setTruncStoreAction", "(", "MVT", "::", "i32", ",", "MVT", "::", "i16", ",", "Custom", ")", ";", "setTruncStoreAction", "(", "MVT", "::", "f64", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setTruncStoreAction", "(", "MVT", "::", "i64", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setTruncStoreAction", "(", "MVT", "::", "v8i32", ",", "MVT", "::", "v8i16", ",", "Expand", ")", ";", "setTruncStoreAction", "(", "MVT", "::", "v16i32", ",", "MVT", "::", "v16i16", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "LOAD", ",", "MVT", "::", "i1", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "GlobalAddress", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "GlobalAddress", ",", "MVT", "::", "i64", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "FrameIndex", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "UDIV", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UREM", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "MVT", "VecTypes", "[", "]", "=", "{", "MVT", "::", "v8i32", ",", "MVT", "::", "v8f32", ",", "MVT", "::", "v16i32", ",", "MVT", "::", "v16f32", "}", ";", "const", "size_t", "NumVecTypes", "=", "array_lengthof", "(", "VecTypes", ")", ";", "for", "(", "unsigned", "Type", "=", "<NUM_LIT>", ";", "Type", "<", "NumVecTypes", ";", "++", "Type", ")", "{", "for", "(", "unsigned", "Op", "=", "<NUM_LIT>", ";", "Op", "<", "ISD", "::", "BUILTIN_OP_END", ";", "++", "Op", ")", "{", "switch", "(", "Op", ")", "{", "case", "ISD", "::", "LOAD", ":", "case", "ISD", "::", "STORE", ":", "case", "ISD", "::", "BUILD_VECTOR", ":", "case", "ISD", "::", "BITCAST", ":", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "case", "ISD", "::", "CONCAT_VECTORS", ":", "case", "ISD", "::", "INSERT_SUBVECTOR", ":", "case", "ISD", "::", "EXTRACT_SUBVECTOR", ":", "break", ";", "default", ":", "setOperationAction", "(", "Op", ",", "VecTypes", "[", "Type", "]", ",", "Expand", ")", ";", "break", ";", "}", "}", "}", "for", "(", "int", "I", "=", "MVT", "::", "v1f64", ";", "I", "<=", "MVT", "::", "v8f64", ";", "++", "I", ")", "{", "MVT", "::", "SimpleValueType", "VT", "=", "static_cast", "<", "MVT", "::", "SimpleValueType", ">", "(", "I", ")", ";", "setOperationAction", "(", "ISD", "::", "FTRUNC", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FCEIL", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FFLOOR", ",", "VT", ",", "Expand", ")", ";", "}", "if", "(", "Subtarget", "->", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "SEA_ISLANDS", ")", "{", "setOperationAction", "(", "ISD", "::", "FTRUNC", ",", "MVT", "::", "f64", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "FCEIL", ",", "MVT", "::", "f64", ",", "Legal" ]

[ "if", "(", "TARGET_BIG_ENDIAN", ")", "builtin_define", "(", "<STR_LIT>", "__big_endian__", "<STR_LIT>", ")", ";" ]

[ "void", "nds32_cpu_cpp_builtins", "(", "struct", "cpp_reader", "*", "pfile", ")", "{", "builtin_define", "(", "<STR_LIT>", "__nds32__", "<STR_LIT>", ")", ";", "builtin_define", "(", "<STR_LIT>", "__NDS32__", "<STR_LIT>", ")", ";", "if", "(", "TARGET_HARD_FLOAT", ")", "builtin_define", "(", "<STR_LIT>", "__NDS32_ABI_2FP_PLUS__", "<STR_LIT>", ")", ";", "else", "builtin_define", "(", "<STR_LIT>", "__NDS32_ABI_2__", "<STR_LIT>", ")", ";", "if", "(", "TARGET_ISA_V2", ")", "builtin_define", "(", "<STR_LIT>", "__NDS32_ISA_V2__", "<STR_LIT>", ")", ";", "if", "(", "TARGET_ISA_V3", ")", "builtin_define", "(", "<STR_LIT>", "__NDS32_ISA_V3__", "<STR_LIT>", ")", ";", "if", "(", "TARGET_ISA_V3M", ")", "builtin_define", "(", "<STR_LIT>", "__NDS32_ISA_V3M__", "<STR_LIT>", ")", ";", "if", "(", "TARGET_FPU_SINGLE", ")", "builtin_define", "(", "<STR_LIT>", "__NDS32_EXT_FPU_SP__", "<STR_LIT>", ")", ";", "if", "(", "TARGET_FPU_DOUBLE", ")", "builtin_define", "(", "<STR_LIT>", "__NDS32_EXT_FPU_DP__", "<STR_LIT>", ")", ";", "if", "(", "TARGET_EXT_FPU_FMA", ")", "builtin_define", "(", "<STR_LIT>", "__NDS32_EXT_FPU_FMA__", "<STR_LIT>", ")", ";", "if", "(", "NDS32_EXT_FPU_DOT_E", ")", "builtin_define", "(", "<STR_LIT>", "__NDS32_EXT_FPU_DOT_E__", "<STR_LIT>", ")", ";", "if", "(", "TARGET_FPU_SINGLE", "||", "TARGET_FPU_DOUBLE", ")", "{", "switch", "(", "nds32_fp_regnum", ")", "{", "case", "<NUM_LIT>", ":", "case", "<NUM_LIT>", ":", "builtin_define", "(", "<STR_LIT>", "__NDS32_EXT_FPU_CONFIG_0__", "<STR_LIT>", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "case", "<NUM_LIT>", ":", "builtin_define", "(", "<STR_LIT>", "__NDS32_EXT_FPU_CONFIG_1__", "<STR_LIT>", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "case", "<NUM_LIT>", ":", "builtin_define", "(", "<STR_LIT>", "__NDS32_EXT_FPU_CONFIG_2__", "<STR_LIT>", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "case", "<NUM_LIT>", ":", "builtin_define", "(", "<STR_LIT>", "__NDS32_EXT_FPU_CONFIG_3__", "<STR_LIT>", ")", ";", "break", ";", "default", ":", "abort", "(", ")", ";", "}", "}", "if", "(", "TARGET_BIG_ENDIAN", ")", "builtin_define", "(", "<STR_LIT>", "__NDS32_EB__", "<STR_LIT>", ")", ";", "else", "builtin_define", "(", "<STR_LIT>", "__NDS32_EL__", "<STR_LIT>", ")", ";", "if", "(", "TARGET_REDUCED_REGS", ")", "builtin_define", "(", "<STR_LIT>", "__NDS32_REDUCED_REGS__", "<STR_LIT>", ")", ";", "if", "(", "TARGET_CMOV", ")", "builtin_define", "(", "<STR_LIT>", "__NDS32_CMOV__", "<STR_LIT>", ")", ";", "if", "(", "TARGET_EXT_PERF", ")", "builtin_define", "(", "<STR_LIT>", "__NDS32_EXT_PERF__", "<STR_LIT>", ")", ";", "if", "(", "TARGET_EXT_PERF2", ")", "builtin_define", "(", "<STR_LIT>", "__NDS32_EXT_PERF2__", "<STR_LIT>", ")", ";", "if", "(", "TARGET_EXT_STRING", ")", "builtin_define", "(", "<STR_LIT>", "__NDS32_EXT_STRING__", "<STR_LIT>", ")", ";", "if", "(", "TARGET_16_BIT", ")", "builtin_define", "(", "<STR_LIT>", "__NDS32_16_BIT__", "<STR_LIT>", ")", ";", "if", "(", "TARGET_GP_DIRECT", ")", "builtin_define", "(", "<STR_LIT>", "__NDS32_GP_DIRECT__", "<STR_LIT>", ")", ";", "if", "(", "TARGET_VH", ")", "builtin_define", "(", "<STR_LIT>", "__NDS32_VH__", "<STR_LIT>", ")", ";" ]

[ "let", "Uses", "=", "[", "CS", "]", ";" ]

[ "def", "L2_loadrh_pcr", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ",", "IntRegs", ":", "$", "Rx32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rx32in", ",", "ModRegs", ":", "$", "Mu2", ")", ",", "<STR_LIT>", ",", "tc_44d3da28", ",", "TypeLD", ">", ",", "Enc_74d4e5", "{", "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", "addrMode", "=", "PostInc", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";" ]

[ "bool", "canMergeStoresTo", "(", "unsigned", "AddressSpace", ",", "EVT", "MemVT", ",", "const", "SelectionDAG", "&", "DAG", ")", "const", "override", "{", "bool", "NoFloat", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ";", "if", "(", "NoFloat", ")", "return", "(", "MemVT", ".", "getSizeInBits", "(", ")", "<=", "<NUM_LIT>", ")", ";", "return", "true", ";", "}" ]

[ "Returns", "if", "it", "'s", "reasonable", "to", "merge", "stores", "to", "MemVT", "size", "." ]

[ "<STR_LIT>", ")" ]

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

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

[ "return", "new", "MipsDisassembler", "(" ]

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

[ "MIB", "=", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "PtrLoadOpc", ")", ",", "Tmp", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "X86", "::", "AddrNumOperands", ";", "++", "i", ")", "{", "if", "(", "i", "==", "X86", "::", "AddrDisp", ")", "MIB", ".", "addDisp", "(", "MI", "->", "getOperand", "(", "i", ")", ",", "LabelOffset", ")", ";", "else", "MIB", ".", "addOperand", "(", "MI", "->", "getOperand", "(", "i", ")", ")", ";", "}", "MIB", ".", "setMemRefs", "(", "MMOBegin", ",", "MMOEnd", ")", ";", "MIB", "=", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "PtrLoadOpc", ")", ",", "SP", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "X86", "::", "AddrNumOperands", ";", "++", "i", ")", "{", "if", "(", "i", "==", "X86", "::", "AddrDisp", ")", "MIB", ".", "addDisp", "(", "MI", "->", "getOperand", "(", "i", ")", ",", "SPOffset", ")", ";", "else", "MIB", ".", "addOperand", "(", "MI", "->", "getOperand", "(", "i", ")", ")", ";", "}", "MIB", ".", "setMemRefs", "(", "MMOBegin", ",", "MMOEnd", ")", ";", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "IJmpOpc", ")", ")", ".", "addReg", "(", "Tmp", ")", ";" ]

[ "virtual", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "switch", "(", "Kind", ")", "{", "case", "k_Token", ":", "OS", "<<", "<STR_LIT>", "Token: ", "<STR_LIT>", "<<", "getToken", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "break", ";", "case", "k_Register", ":", "OS", "<<", "<STR_LIT>", "Reg: #", "<STR_LIT>", "<<", "getReg", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "break", ";", "case", "k_Immediate", ":", "OS", "<<", "<STR_LIT>", "Imm: ", "<STR_LIT>", "<<", "getImm", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "break", ";", "case", "k_MemoryReg", ":", "OS", "<<", "<STR_LIT>", "Mem: ", "<STR_LIT>", "<<", "getMemBase", "(", ")", "<<", "<STR_LIT>", "+", "<STR_LIT>", "<<", "getMemOffsetReg", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "break", ";", "case", "k_MemoryImm", ":", "assert", "(", "getMemOff", "(", ")", "!=", "<NUM_LIT>", ")", ";", "OS", "<<", "<STR_LIT>", "Mem: ", "<STR_LIT>", "<<", "getMemBase", "(", ")", "<<", "<STR_LIT>", "+", "<STR_LIT>", "<<", "*", "getMemOff", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "break", ";", "}", "}" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "}" ]

[ "vqshlu_n_s32", "(", "int32x2_t", "_", "_", "a", ",", "const", "int", "_", "_", "b", ")", "{", "return", "(", "uint32x2_t", ")", "_", "_", "builtin_neon_vqshlu_nv2si", "(", "_", "_", "a", ",", "_", "_", "b", ")", ";" ]

[ "$", "r1", ",", "(", "CapTagGet", "CheriOpnd", ":", "$", "r2", ")", ")", "]", ">", ";" ]

[ "def", "CGetTag", ":", "CheriFmt2Op", "<", "<NUM_LIT>", ",", "(", "outs", "GPR64Opnd", ":", "$", "r1", ")", ",", "(", "ins", "CheriOpnd", ":", "$", "r2", ")", ",", "<STR_LIT>", ",", "[", "(", "set", "GPR64Opnd", ":" ]

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

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

[ "if", "(", "*", "imm1", ">", "*", "imm2", ")", "return", "+", "<NUM_LIT>", ";" ]

[ "static", "int", "aarch64_bitmasks_cmp", "(", "const", "void", "*", "i1", ",", "const", "void", "*", "i2", ")", "{", "const", "unsigned", "HOST_WIDE_INT", "*", "imm1", "=", "(", "const", "unsigned", "HOST_WIDE_INT", "*", ")", "i1", ";", "const", "unsigned", "HOST_WIDE_INT", "*", "imm2", "=", "(", "const", "unsigned", "HOST_WIDE_INT", "*", ")", "i2", ";", "if", "(", "*", "imm1", "<", "*", "imm2", ")", "return", "-", "<NUM_LIT>", ";" ]

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

[ "*", "disp", "=", "<NUM_LIT>", ";", "return", ";", "case", "POST_INC", ":", "*", "base", "=", "REGNO", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ")", ";", "*", "incdec", "=", "<NUM_LIT>", ";", "*", "disp", "=", "<NUM_LIT>", ";", "return", ";", "case", "POST_MODIFY", ":", "*", "base", "=", "REGNO", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ")", ";", "if", "(", "REG_P", "(", "XEXP", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ")", "{", "*", "index", "=", "REGNO", "(", "XEXP", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ";", "*", "disp", "=", "<NUM_LIT>", ";", "}", "else", "*", "disp", "=", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ";", "*", "incdec", "=", "<NUM_LIT>", ";", "return", ";", "case", "PRE_MODIFY", ":", "*", "base", "=", "REGNO", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ")", ";", "if", "(", "REG_P", "(", "XEXP", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ")", "{", "*", "index", "=", "REGNO", "(", "XEXP", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ";" ]

[ "MovImm32ShifterOperand", ";" ]

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

[ "<FIXS>", "if", "(", "!", "TYPE_NO_NAMED_ARGS_STDARG_P", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ")", "gcc_assert", "(", "arg", ".", "mode", "!=", "BLKmode", ")", ";", "<FIXE>", "<FIXS>", "if", "(", "!", "TYPE_NO_NAMED_ARGS_STDARG_P", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ")", "first_anon_arg", "=", "(", "ROUND_ADVANCE_CUM", "(", "*", "get_cumulative_args", "(", "cum", ")", ",", "arg", ".", "mode", ",", "arg", ".", "type", ")", "+", "ROUND_ADVANCE_ARG", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ")", ";", "elsefirst_anon_arg", "=", "*", "get_cumulative_args", "(", "cum", ")", ";", "<FIXE>" ]

[ "return", ";", "<BUGS>", "gcc_assert", "(", "arg", ".", "mode", "!=", "BLKmode", ")", ";", "<BUGE>", "<BUGS>", "first_anon_arg", "=", "(", "ROUND_ADVANCE_CUM", "(", "*", "get_cumulative_args", "(", "cum", ")", ",", "arg", ".", "mode", ",", "arg", ".", "type", ")", "+", "ROUND_ADVANCE_ARG", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ")", ";", "<BUGE>", "if", "(", "first_anon_arg", "M32R_MAX_PARM_REGS", ")", "{" ]

[ "}" ]

[ "bool", "tilegx_can_use_return_insn_p", "(", "void", ")", "{", "return", "(", "reload_completed", "&&", "!", "cfun", "->", "static_chain_decl", "&&", "!", "compute_total_frame_size", "(", ")", "&&", "tilegx_current_function_is_leaf", "(", ")", "&&", "!", "crtl", "->", "profile", "&&", "!", "df_regs_ever_live_p", "(", "TILEGX_LINK_REGNUM", ")", ")", ";" ]

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

[ "for", "(", "MachineBasicBlock", "::", "iterator", "MII", "=", "MBB", "->", "end", "(", ")", ",", "E", "=", "MBB", "->", "begin", "(", ")", ";", "MII", "!=", "E", ";", ")", "{", "MachineInstr", "*", "MI", "=", "--", "MII", ";", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "{", "continue", ";", "}", "if", "(", "(", "nvjCount", "==", "<NUM_LIT>", ")", "||", "(", "nvjCount", ">", "-", "<NUM_LIT>", "&&", "nvjCount", "<=", "nvjGenerated", ")", ")", "break", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Instr: ", "<STR_LIT>", ";", "MI", "->", "dump", "(", ")", ";", "dbgs", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "if", "(", "!", "foundJump", "&&", "(", "MI", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "J2_jumpt", "||", "MI", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "J2_jumpf", "||", "MI", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "J2_jumptnewpt", "||", "MI", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "J2_jumptnew", "||", "MI", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "J2_jumpfnewpt", "||", "MI", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "J2_jumpfnew", ")", ")", "{", "jmpPos", "=", "MII", ";", "jmpInstr", "=", "MI", ";", "predReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "afterRA", "=", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "predReg", ")", ";", "bool", "predLive", "=", "false", ";", "for", "(", "MachineBasicBlock", "::", "const_succ_iterator", "SI", "=", "MBB", "->", "succ_begin", "(", ")", ",", "SIE", "=", "MBB", "->", "succ_end", "(", ")", ";", "SI", "!=", "SIE", ";", "++", "SI", ")", "{", "MachineBasicBlock", "*", "succMBB", "=", "*", "SI", ";", "if", "(", "succMBB", "->", "isLiveIn", "(", "predReg", ")", ")", "{", "predLive", "=", "true", ";", "}", "}", "if", "(", "predLive", ")", "break", ";", "jmpTarget", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "foundJump", "=", "true", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "J2_jumpf", "||", "MI", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "J2_jumpfnewpt", "||", "MI", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "J2_jumpfnew", ")", "{", "invertPredicate", "=", "true", ";", "}", "continue", ";", "}", "if", "(", "foundJump", "&&", "MI", "->", "getNumOperands", "(", ")", "==", "<NUM_LIT>", ")", "break", ";", "if", "(", "foundJump", "&&", "!", "foundCompare", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "predReg", ")", "{", "if", "(", "QII", "->", "isNewValueJumpCandidate", "(", "MI", ")", ")", "{", "assert", "(", "(", "MI", "->", "getDesc", "(", ")", ".", "isCompare", "(", ")", ")", "&&", "<STR_LIT>", "Only compare instruction can be collapsed into New Value Jump", "<STR_LIT>", ")", ";", "isSecondOpReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", ";", "if", "(", "!", "canCompareBeNewValueJump", "(", "QII", ",", "QRI", ",", "MII", ",", "predReg", ",", "isSecondOpReg", ",", "afterRA", ",", "jmpPos", ",", "MF", ")", ")", "break", ";", "cmpInstr", "=", "MI", ";", "cmpPos", "=", "MII", ";", "foundCompare", "=", "true", ";", "cmpReg1", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isKill", "(", ")", ")", "MO1IsKill", "=", "true", ";", "if", "(", "isSecondOpReg", ")", "{", "cmpOp2", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isKill", "(", ")", ")", "MO2IsKill", "=", "true", ";", "}", "else", "cmpOp2", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "continue", ";", "}", "}", "if", "(", "foundCompare", "&&", "foundJump", ")", "{", "if", "(", "!", "commonChecksToProhibitNewValueJump", "(", "afterRA", ",", "MII", ")", ")", "break", ";", "bool", "foundFeeder", "=", "false", ";", "MachineBasicBlock", "::", "iterator", "feederPos", "=", "MII", ";", "if", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isDef", "(", ")", "&&", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "cmpReg1", "||", "(", "isSecondOpReg", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "(", "unsigned", ")", "cmpOp2", ")", ")", ")", "{", "unsigned", "feederReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "feederReg", "==", "cmpReg1", ")", "{", "if", "(", "!", "canBeFeederToNewValueJump", "(", "QII", ",", "QRI", ",", "MII", ",", "jmpPos", ",", "cmpPos", ",", "MF", ")", ")", "{", "if", "(", "!", "isSecondOpReg", ")", "break", ";", "else", "continue", ";", "}", "else", "foundFeeder", "=", "true", ";", "}", "if", "(", "!", "foundFeeder", "&&", "isSecondOpReg", "&&", "feederReg", "==", "(", "unsigned", ")", "cmpOp2", ")", "if", "(", "!", "canBeFeederToNewValueJump", "(", "QII", ",", "QRI", ",", "MII", ",", "jmpPos", ",", "cmpPos", ",", "MF", ")", ")", "break", ";" ]

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

[ "bool", "isFP", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getSimpleValueType", "(", ")", ".", "isFloatingPoint", "(", ")", ";", "SDLoc", "dl", "(", "Op", ")", ";", "if", "(", "isFP", ")", "{", "MVT", "EltVT", "=", "Op0", ".", "getSimpleValueType", "(", ")", ".", "getVectorElementType", "(", ")", ";", "assert", "(", "EltVT", "==", "MVT", "::", "f32", "||", "EltVT", "==", "MVT", "::", "f64", ")", ";", "unsigned", "SSECC", "=", "translateX86FSETCC", "(", "SetCCOpcode", ",", "Op0", ",", "Op1", ")", ";", "unsigned", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "Subtarget", "->", "hasAVX512", "(", ")", "&&", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", ")", "{", "assert", "(", "VT", ".", "getVectorNumElements", "(", ")", "<=", "<NUM_LIT>", ")", ";", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "if", "(", "SSECC", "==", "<NUM_LIT>", ")", "{", "unsigned", "CC0", ",", "CC1", ";", "unsigned", "CombineOpc", ";", "if", "(", "SetCCOpcode", "==", "ISD", "::", "SETUEQ", ")", "{", "CC0", "=", "<NUM_LIT>", ";", "CC1", "=", "<NUM_LIT>", ";", "CombineOpc", "=", "ISD", "::", "OR", ";", "}", "else", "{", "assert", "(", "SetCCOpcode", "==", "ISD", "::", "SETONE", ")", ";", "CC0", "=", "<NUM_LIT>", ";", "CC1", "=", "<NUM_LIT>", ";", "CombineOpc", "=", "ISD", "::", "AND", ";", "}", "SDValue", "Cmp0", "=", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "VT", ",", "Op0", ",", "Op1", ",", "DAG", ".", "getConstant", "(", "CC0", ",", "MVT", "::", "i8", ")", ")", ";", "SDValue", "Cmp1", "=", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "VT", ",", "Op0", ",", "Op1", ",", "DAG", ".", "getConstant", "(", "CC1", ",", "MVT", "::", "i8", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "CombineOpc", ",", "dl", ",", "VT", ",", "Cmp0", ",", "Cmp1", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "VT", ",", "Op0", ",", "Op1", ",", "DAG", ".", "getConstant", "(", "SSECC", ",", "MVT", "::", "i8", ")", ")", ";", "}", "if", "(", "VT", ".", "is256BitVector", "(", ")", "&&", "!", "Subtarget", "->", "hasInt256", "(", ")", ")", "return", "Lower256IntVSETCC", "(", "Op", ",", "DAG", ")", ";", "bool", "MaskResult", "=", "(", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", ")", ";", "EVT", "OpVT", "=", "Op1", ".", "getValueType", "(", ")", ";", "if", "(", "Subtarget", "->", "hasAVX512", "(", ")", ")", "{", "if", "(", "Op1", ".", "getValueType", "(", ")", ".", "is512BitVector", "(", ")", "||", "(", "MaskResult", "&&", "OpVT", ".", "getVectorElementType", "(", ")", ".", "getSizeInBits", "(", ")", ">=", "<NUM_LIT>", ")", ")", "return", "LowerIntVSETCC_AVX512", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ";", "if", "(", "MaskResult", "&&", "(", "OpVT", ".", "getVectorElementType", "(", ")", ".", "getSizeInBits", "(", ")", "<", "<NUM_LIT>", "&&", "OpVT", ".", "getVectorElementType", "(", ")", ".", "getSizeInBits", "(", ")", ">=", "<NUM_LIT>", ")", ")", "return", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VT", ",", "DAG", ".", "getNode", "(", "ISD", "::", "SETCC", ",", "dl", ",", "OpVT", ",", "Op0", ",", "Op1", ",", "CC", ")", ")", ";", "}", "unsigned", "Opc", ";", "bool", "Swap", "=", "false", ",", "Invert", "=", "false", ",", "FlipSigns", "=", "false", ",", "MinMax", "=", "false", ";", "bool", "Subus", "=", "false", ";", "switch", "(", "SetCCOpcode", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected SETCC condition", "<STR_LIT>", ")", ";", "case", "ISD", "::", "SETNE", ":", "Invert", "=", "true", ";", "case", "ISD", "::", "SETEQ", ":", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SETLT", ":", "Swap", "=", "true", ";", "case", "ISD", "::", "SETGT", ":", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SETGE", ":", "Swap", "=", "true", ";", "case", "ISD", "::", "SETLE", ":", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Invert", "=", "true", ";", "break", ";", "case", "ISD", "::", "SETULT", ":", "Swap", "=", "true", ";", "case", "ISD", "::", "SETUGT", ":", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "FlipSigns", "=", "true", ";", "break", ";", "case", "ISD", "::", "SETUGE", ":", "Swap", "=", "true", ";", "case", "ISD", "::", "SETULE", ":", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "FlipSigns", "=", "true", ";", "Invert", "=", "true", ";", "break", ";", "}", "MVT", "VET", "=", "VT", ".", "getVectorElementType", "(", ")", ";", "bool", "hasMinMax", "=", "(", "Subtarget", "->", "hasSSE41", "(", ")", "&&", "(", "VET", ">=", "MVT", "::", "i8", "&&", "VET", "<=", "MVT", "::", "i32", ")", ")", "||", "(", "Subtarget", "->", "hasSSE2", "(", ")", "&&", "(", "VET", "==", "MVT", "::", "i8", ")", ")", ";", "if", "(", "hasMinMax", ")", "{", "switch", "(", "SetCCOpcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "SETULE", ":", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "MinMax", "=", "true", ";", "break", ";", "case", "ISD", "::", "SETUGE", ":", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "MinMax", "=", "true", ";", "break", ";", "}", "if", "(", "MinMax", ")", "{", "Swap", "=", "false", ";", "Invert", "=", "false", ";", "FlipSigns", "=", "false", ";", "}", "}", "bool", "hasSubus", "=", "Subtarget", "->", "hasSSE2", "(", ")", "&&", "(", "VET", "==", "MVT", "::", "i8", "||", "VET", "==", "MVT", "::", "i16", ")", ";", "if", "(", "!", "MinMax", "&&", "hasSubus", ")", "{", "switch", "(", "SetCCOpcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "SETULT", ":", "{", "if", "(", "Subtarget", "->", "hasAVX", "(", ")", ")", "break", ";", "SDValue", "ULEOp1", "=", "ChangeVSETULTtoVSETULE", "(", "dl", ",", "Op1", "," ]

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

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

[ "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "RegsToPass", "[", "i", "]", ".", "first", ",", "RegsToPass", "[", "i", "]", ".", "second", ",", "InFlag", ")", ";" ]

[ "if", "(", "GlobalAddressSDNode", "*", "GA", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "{", "const", "Function", "*", "CalleeFn", "=", "nullptr", ";", "Callee", "=", "DAG", ".", "getTargetGlobalAddress", "(", "GA", "->", "getGlobal", "(", ")", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "if", "(", "(", "CalleeFn", "=", "dyn_cast", "<", "Function", ">", "(", "GA", "->", "getGlobal", "(", ")", ")", ")", ")", "{", "if", "(", "CalleeFn", "->", "isVarArg", "(", ")", "&&", "CalleeFn", "->", "getFunctionType", "(", ")", "->", "getNumParams", "(", ")", "!=", "<NUM_LIT>", ")", "{", "NumNamedVarArgParams", "=", "CalleeFn", "->", "getFunctionType", "(", ")", "->", "getNumParams", "(", ")", ";", "}", "}", "}", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "ArgLocs", ";", "HexagonCCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ",", "NumNamedVarArgParams", ")", ";", "if", "(", "isVarArg", ")", "CCInfo", ".", "AnalyzeCallOperands", "(", "Outs", ",", "CC_Hexagon_VarArg", ")", ";", "else", "CCInfo", ".", "AnalyzeCallOperands", "(", "Outs", ",", "CC_Hexagon", ")", ";", "if", "(", "DAG", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableTailCalls", ")", "isTailCall", "=", "false", ";", "if", "(", "isTailCall", ")", "{", "bool", "StructAttrFlag", "=", "MF", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ";", "isTailCall", "=", "IsEligibleForTailCallOptimization", "(", "Callee", ",", "CallConv", ",", "isVarArg", ",", "IsStructRet", ",", "StructAttrFlag", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "DAG", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "if", "(", "VA", ".", "isMemLoc", "(", ")", ")", "{", "isTailCall", "=", "false", ";", "break", ";", "}", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "(", "isTailCall", "?", "<STR_LIT>", "Eligible for Tail Call\\n", "<STR_LIT>", ":", "<STR_LIT>", "Argument must be passed on stack. ", "<STR_LIT>", "<STR_LIT>", "Not eligible for Tail Call\\n", "<STR_LIT>", ")", ")", ";", "}", "unsigned", "NumBytes", "=", "CCInfo", ".", "getNextStackOffset", "(", ")", ";", "SmallVector", "<", "std", "::", "pair", "<", "unsigned", ",", "SDValue", ">", ",", "<NUM_LIT>", ">", "RegsToPass", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "MemOpChains", ";", "auto", "&", "HRI", "=", "*", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "SDValue", "StackPtr", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "HRI", ".", "getStackRegister", "(", ")", ",", "getPointerTy", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "SDValue", "Arg", "=", "OutVals", "[", "i", "]", ";", "ISD", "::", "ArgFlagsTy", "Flags", "=", "Outs", "[", "i", "]", ".", "Flags", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown loc info!", "<STR_LIT>", ")", ";", "case", "CCValAssign", "::", "BCvt", ":", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "SExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SIGN_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "case", "CCValAssign", "::", "ZExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "case", "CCValAssign", "::", "AExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "}", "if", "(", "VA", ".", "isMemLoc", "(", ")", ")", "{", "unsigned", "LocMemOffset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "SDValue", "MemAddr", "=", "DAG", ".", "getConstant", "(", "LocMemOffset", ",", "dl", ",", "StackPtr", ".", "getValueType", "(", ")", ")", ";", "MemAddr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "MVT", "::", "i32", ",", "StackPtr", ",", "MemAddr", ")", ";", "if", "(", "Flags", ".", "isByVal", "(", ")", ")", "{", "MemOpChains", ".", "push_back", "(", "CreateCopyOfByValArgument", "(", "Arg", ",", "MemAddr", ",", "Chain", ",", "Flags", ",", "DAG", ",", "dl", ")", ")", ";", "}", "else", "{", "MachinePointerInfo", "LocPI", "=", "MachinePointerInfo", "::", "getStack", "(", "LocMemOffset", ")", ";", "SDValue", "S", "=", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "Arg", ",", "MemAddr", ",", "LocPI", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "MemOpChains", ".", "push_back", "(", "S", ")", ";", "}", "continue", ";", "}", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "VA", ".", "getLocReg", "(", ")", ",", "Arg", ")", ")", ";", "}", "if", "(", "!", "MemOpChains", ".", "empty", "(", ")", ")", "Chain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "dl", ",", "MVT", "::", "Other", ",", "MemOpChains", ")", ";", "if", "(", "!", "isTailCall", ")", "{", "SDValue", "C", "=", "DAG", ".", "getConstant", "(", "NumBytes", ",", "dl", ",", "getPointerTy", "(", ")", ",", "true", ")", ";", "Chain", "=", "DAG", ".", "getCALLSEQ_START", "(", "Chain", ",", "C", ",", "dl", ")", ";", "}", "SDValue", "InFlag", ";", "if", "(", "!", "isTailCall", ")", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "RegsToPass", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "RegsToPass", "[", "i", "]", ".", "first", ",", "RegsToPass", "[", "i", "]", ".", "second", ",", "InFlag", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "}", "}", "else", "{", "InFlag", "=", "SDValue", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "RegsToPass", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{" ]

[ "void", "sh_init_cumulative_args", "(", "CUMULATIVE_ARGS", "*", "pcum", ",", "tree", "fntype", ",", "rtx", "libname", "ATTRIBUTE_UNUSED", ",", "tree", "fndecl", ",", "signed", "int", "n_named_args", ",", "machine_mode", "mode", ")", "{", "pcum", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_FLOAT", "]", "=", "<NUM_LIT>", ";", "pcum", "->", "free_single_fp_reg", "=", "<NUM_LIT>", ";", "pcum", "->", "outgoing", "=", "n_named_args", "!=", "-", "<NUM_LIT>", ";", "pcum", "->", "renesas_abi", "=", "sh_attr_renesas_p", "(", "fntype", ")", ";", "if", "(", "fntype", ")", "{", "pcum", "->", "force_mem", "=", "(", "(", "TARGET_HITACHI", "||", "pcum", "->", "renesas_abi", ")", "&&", "aggregate_value_p", "(", "TREE_TYPE", "(", "fntype", ")", ",", "fndecl", ")", ")", ";", "pcum", "->", "prototype_p", "=", "prototype_p", "(", "fntype", ")", ";", "pcum", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_INT", "]", "=", "false", ";", "}", "else", "{", "pcum", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_INT", "]", "=", "<NUM_LIT>", ";", "pcum", "->", "prototype_p", "=", "false", ";", "if", "(", "mode", "!=", "VOIDmode", ")", "{", "pcum", "->", "force_mem", "=", "(", "TARGET_DEFAULT", "&", "MASK_HITACHI", ")", "&&", "(", "mode", "==", "BLKmode", "||", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "<NUM_LIT>", "&&", "!", "(", "mode", "==", "DFmode", "&&", "TARGET_FPU_DOUBLE", ")", ")", ")", ";", "}", "else", "pcum", "->", "force_mem", "=", "false", ";", "}", "}" ]

[ "Initialize", "the", "CUMULATIVE_ARGS", "structure", "." ]

[ "<FIXS>", "Type", "*", "RetTy", "=", "(", "Type", "*", ")", "StructType", "::", "get", "(", "Ty", ",", "Ty", ",", "nullptr", ")", ";", "<FIXE>" ]

[ "SDValue", "Callee", "=", "DAG", ".", "getExternalSymbol", "(", "getLibcallName", "(", "LC", ")", ",", "getPointerTy", "(", ")", ")", ";", "<BUGS>", "Type", "*", "RetTy", "=", "(", "Type", "*", ")", "StructType", "::", "get", "(", "Ty", ",", "Ty", ",", "NULL", ")", ";", "<BUGE>", "SDLoc", "dl", "(", "Op", ")", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "DAG", ")", ";" ]

[ "<NUM_LIT>", ")" ]

[ "[", "(", "parallel", "[", "(", "set", "(", "zero_extract", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "subreg", ":", "SI", "(", "any_or", ":", "QI", "(", "subreg", ":", "QI", "(", "zero_extract", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")" ]

[ "users", "(", ")", ")", "{" ]

[ "if", "(", "!", "TPC", ")", "return", "false", ";", "const", "TargetMachine", "&", "TM", "=", "TPC", "->", "getTM", "<", "TargetMachine", ">", "(", ")", ";", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", "F", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "*", "U", ":", "F", "." ]

[ "FMAXNAN", ":" ]

[ "case", "ISD", "::", "FP_EXTEND", ":", "return", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ".", "getScalarType", "(", ")", "!=", "MVT", "::", "f16", "||", "ST", "->", "hasFP16Denormals", "(", ")", ";", "case", "ISD", "::", "FP16_TO_FP", ":", "case", "ISD", "::", "FP_TO_FP16", ":", "return", "ST", "->", "hasFP16Denormals", "(", ")", ";", "case", "ISD", "::", "FNEG", ":", "case", "ISD", "::", "FABS", ":", "return", "(", "MaxDepth", ">", "<NUM_LIT>", ")", "&&", "isCanonicalized", "(", "DAG", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "ST", ",", "MaxDepth", "-", "<NUM_LIT>", ")", ";", "case", "ISD", "::", "FSIN", ":", "case", "ISD", "::", "FCOS", ":", "case", "ISD", "::", "FSINCOS", ":", "return", "Op", ".", "getValueType", "(", ")", ".", "getScalarType", "(", ")", "!=", "MVT", "::", "f16", ";", "case", "ISD", "::", "FMINNUM", ":", "case", "ISD", "::", "FMAXNUM", ":", "case", "ISD", "::", "FMINNAN", ":", "case", "ISD", "::" ]

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

[ "(", "minus", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "if", "(", "Function", "*", "F", "=", "dyn_cast", "<", "Function", ">", "(", "SecurityCheckCookie", ".", "getCallee", "(", ")", ")", ")", "{" ]

[ "M", ".", "getOrInsertGlobal", "(", "<STR_LIT>", "__security_cookie", "<STR_LIT>", ",", "PointerType", "::", "getUnqual", "(", "M", ".", "getContext", "(", ")", ")", ")", ";", "FunctionCallee", "SecurityCheckCookie", "=", "M", ".", "getOrInsertFunction", "(", "<STR_LIT>", "__security_check_cookie", "<STR_LIT>", ",", "Type", "::", "getVoidTy", "(", "M", ".", "getContext", "(", ")", ")", ",", "PointerType", "::", "getUnqual", "(", "M", ".", "getContext", "(", ")", ")", ")", ";" ]

[ ",", "_", "_", "R", ")", ";" ]

[ "return", "(", "_", "_", "m512d", ")", "_", "_", "builtin_ia32_vfmaddpd512_mask", "(", "(", "_", "_", "v8df", ")", "_", "_", "A", ",", "(", "_", "_", "v8df", ")", "_", "_", "B", ",", "(", "_", "_", "v8df", ")", "_", "_", "C", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U" ]

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

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

[ ",", "getKillRegState", "(", "isKill", ")", ")", ",", "FrameIdx", ")", ";" ]

[ "unsigned", "LoadOpcode", ",", "StoreOpcode", ";", "getLoadStoreOpcodes", "(", "RC", ",", "LoadOpcode", ",", "StoreOpcode", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "StoreOpcode", ")", ")", ".", "addReg", "(", "SrcReg" ]

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

[ "rtx_code_label", "*", "end_label", ";", "if", "(", "min_len", "==", "<NUM_LIT>", ")", "{", "end_label", "=", "gen_label_rtx", "(", ")", ";", "emit_cmp_and_jump_insns", "(", "len", ",", "const0_rtx", ",", "EQ", ",", "NULL_RTX", ",", "GET_MODE", "(", "len", ")", ",", "<NUM_LIT>", ",", "end_label", ",", "profile_probability", "::", "very_unlikely", "(", ")", ")", ";", "}", "rtx", "lenm1", ";", "if", "(", "CONST_INT_P", "(", "len", ")", ")", "{", "lenm1", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_move_insn", "(", "lenm1", ",", "GEN_INT", "(", "UINTVAL", "(", "len", ")", "-", "<NUM_LIT>", ")", ")", ";", "}", "else", "lenm1", "=", "expand_binop", "(", "SImode", ",", "add_optab", ",", "convert_to_mode", "(", "SImode", ",", "len", ",", "<NUM_LIT>", ")", ",", "constm1_rtx", ",", "NULL_RTX", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "rtx", "tmp", "=", "gen_reg_rtx", "(", "V16QImode", ")", ";", "emit_insn", "(", "gen_vllv16qi", "(", "tmp", ",", "lenm1", ",", "src", ")", ")", ";", "emit_insn", "(", "gen_vstlv16qi", "(", "tmp", ",", "lenm1", ",", "dst", ")", ")", ";", "if", "(", "min_len", "==", "<NUM_LIT>", ")", "emit_label", "(", "end_label", ")", ";", "return", "true", ";", "}", "else", "if", "(", "max_len", "<=", "<NUM_LIT>", "&&", "TARGET_Z15", ")", "{", "rtx_code_label", "*", "end_label", "=", "gen_label_rtx", "(", ")", ";", "if", "(", "min_len", "==", "<NUM_LIT>", ")", "emit_cmp_and_jump_insns", "(", "len", ",", "const0_rtx", ",", "EQ", ",", "NULL_RTX", ",", "GET_MODE", "(", "len", ")", ",", "<NUM_LIT>", ",", "end_label", ",", "profile_probability", "::", "very_unlikely", "(", ")", ")", ";", "rtx", "dst_addr", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "rtx", "src_addr", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_move_insn", "(", "dst_addr", ",", "force_operand", "(", "XEXP", "(", "dst", ",", "<NUM_LIT>", ")", ",", "NULL_RTX", ")", ")", ";", "emit_move_insn", "(", "src_addr", ",", "force_operand", "(", "XEXP", "(", "src", ",", "<NUM_LIT>", ")", ",", "NULL_RTX", ")", ")", ";", "rtx", "lenm1", "=", "CONST_INT_P", "(", "len", ")", "?", "GEN_INT", "(", "UINTVAL", "(", "len", ")", "-", "<NUM_LIT>", ")", ":", "expand_binop", "(", "GET_MODE", "(", "len", ")", ",", "add_optab", ",", "len", ",", "constm1_rtx", ",", "NULL_RTX", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "rtx_code_label", "*", "right_to_left_label", "=", "gen_label_rtx", "(", ")", ";", "emit_cmp_and_jump_insns", "(", "src_addr", ",", "dst_addr", ",", "LT", ",", "NULL_RTX", ",", "GET_MODE", "(", "len", ")", ",", "<NUM_LIT>", ",", "right_to_left_label", ")", ";", "emit_insn", "(", "gen_cpymem_short", "(", "dst", ",", "src", ",", "convert_to_mode", "(", "Pmode", ",", "lenm1", ",", "<NUM_LIT>", ")", ")", ")", ";", "emit_jump", "(", "end_label", ")", ";", "emit_label", "(", "right_to_left_label", ")", ";", "emit_insn", "(", "gen_mvcrl", "(", "dst", ",", "src", ",", "convert_to_mode", "(", "SImode", ",", "lenm1", ",", "<NUM_LIT>", ")", ")", ")", ";", "emit_label", "(", "end_label", ")", ";" ]

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

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

[ "break", ";" ]

[ "U", "=", "I", ";", "}", "}", "else", "if", "(", "const", "ConstantExpr", "*", "C", "=", "dyn_cast", "<", "ConstantExpr", ">", "(", "V", ")", ")", "{", "Opcode", "=", "C", "->", "getOpcode", "(", ")", ";", "U", "=", "C", ";", "}", "if", "(", "PointerType", "*", "Ty", "=", "dyn_cast", "<", "PointerType", ">", "(", "V", "->", "getType", "(", ")", ")", ")", "if", "(", "Ty", "->", "getAddressSpace", "(", ")", ">", "<NUM_LIT>", ")", "return", "false", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "Instruction", "::", "BitCast", ":", "return", "X86SelectAddress", "(", "U", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "AM", ")", ";", "case", "Instruction", "::", "IntToPtr", ":", "if", "(", "TLI", ".", "getValueType", "(", "U", "->", "getOperand", "(", "<NUM_LIT>", ")", "->", "getType", "(", ")", ")", "==", "TLI", ".", "getPointerTy", "(", ")", ")", "return", "X86SelectAddress", "(", "U", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "AM", ")", ";", "break", ";", "case", "Instruction", "::", "PtrToInt", ":", "if", "(", "TLI", ".", "getValueType", "(", "U", "->", "getType", "(", ")", ")", "==", "TLI", ".", "getPointerTy", "(", ")", ")", "return", "X86SelectAddress", "(", "U", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "AM", ")", ";", "break", ";", "case", "Instruction", "::", "Alloca", ":", "{", "const", "AllocaInst", "*", "A", "=", "cast", "<", "AllocaInst", ">", "(", "V", ")", ";", "DenseMap", "<", "const", "AllocaInst", "*", ",", "int", ">", "::", "iterator", "SI", "=", "FuncInfo", ".", "StaticAllocaMap", ".", "find", "(", "A", ")", ";", "if", "(", "SI", "!=", "FuncInfo", ".", "StaticAllocaMap", ".", "end", "(", ")", ")", "{", "AM", ".", "BaseType", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "AM", ".", "Base", ".", "FrameIndex", "=", "SI", "->", "second", ";", "return", "isLegalAddressingModeForNaCl", "(", "Subtarget", ",", "AM", ")", ";", "}", "break", ";", "}", "case", "Instruction", "::", "Add", ":", "{", "if", "(", "const", "ConstantInt", "*", "CI", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "U", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{", "uint64_t", "Disp", "=", "(", "int32_t", ")", "AM", ".", "Disp", "+", "(", "uint64_t", ")", "CI", "->", "getSExtValue", "(", ")", ";", "if", "(", "isInt", "<", "<NUM_LIT>", ">", "(", "Disp", ")", ")", "{", "AM", ".", "Disp", "=", "(", "uint32_t", ")", "Disp", ";", "return", "X86SelectAddress", "(", "U", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "AM", ")", ";", "}", "}", "break", ";", "}", "case", "Instruction", "::", "GetElementPtr", ":", "{", "X86AddressMode", "SavedAM", "=", "AM", ";", "uint64_t", "Disp", "=", "(", "int32_t", ")", "AM", ".", "Disp", ";", "unsigned", "IndexReg", "=", "AM", ".", "IndexReg", ";", "unsigned", "Scale", "=", "AM", ".", "Scale", ";", "gep_type_iterator", "GTI", "=", "gep_type_begin", "(", "U", ")", ";", "for", "(", "User", "::", "const_op_iterator", "i", "=", "U", "->", "op_begin", "(", ")", "+", "<NUM_LIT>", ",", "e", "=", "U", "->", "op_end", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ",", "++", "GTI", ")", "{", "const", "Value", "*", "Op", "=", "*", "i", ";", "if", "(", "StructType", "*", "STy", "=", "dyn_cast", "<", "StructType", ">", "(", "*", "GTI", ")", ")", "{", "const", "StructLayout", "*", "SL", "=", "DL", ".", "getStructLayout", "(", "STy", ")", ";", "Disp", "+=", "SL", "->", "getElementOffset", "(", "cast", "<", "ConstantInt", ">", "(", "Op", ")", "->", "getZExtValue", "(", ")", ")", ";", "continue", ";", "}", "uint64_t", "S", "=", "DL", ".", "getTypeAllocSize", "(", "GTI", ".", "getIndexedType", "(", ")", ")", ";", "for", "(", ";", ";", ")", "{", "if", "(", "const", "ConstantInt", "*", "CI", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "Op", ")", ")", "{", "Disp", "+=", "CI", "->", "getSExtValue", "(", ")", "*", "S", ";", "break", ";", "}", "if", "(", "canFoldAddIntoGEP", "(", "U", ",", "Op", ")", ")", "{", "ConstantInt", "*", "CI", "=", "cast", "<", "ConstantInt", ">", "(", "cast", "<", "AddOperator", ">", "(", "Op", ")", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "Disp", "+=", "CI", "->", "getSExtValue", "(", ")", "*", "S", ";", "Op", "=", "cast", "<", "AddOperator", ">", "(", "Op", ")", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "continue", ";", "}", "if", "(", "IndexReg", "==", "<NUM_LIT>", "&&", "(", "!", "AM", ".", "GV", "||", "!", "Subtarget", "->", "isPICStyleRIPRel", "(", ")", ")", "&&", "(", "S", "==", "<NUM_LIT>", "||", "S", "==", "<NUM_LIT>", "||", "S", "==", "<NUM_LIT>", "||", "S", "==", "<NUM_LIT>", ")", ")", "{", "Scale", "=", "S", ";", "IndexReg", "=", "getRegForGEPIndex", "(", "Op", ")", ".", "first", ";", "if", "(", "IndexReg", "==", "<NUM_LIT>", ")", "return", "false", ";" ]

[ "return", "DAG", ".", "getNode", "(", "Opcode", ",", "dl", ",", "MVT", "::", "Other", ",", "Ops", ".", "data", "(", ")", ",", "Ops", ".", "size", "(", ")", ")", ";" ]

[ "if", "(", "!", "VT", ".", "is64BitVector", "(", ")", ")", "return", "SDValue", "(", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Ops", ";", "Ops", ".", "push_back", "(", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "Ops", ".", "push_back", "(", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "for", "(", "unsigned", "N", "=", "<NUM_LIT>", ";", "N", "<", "NumVecs", ";", "++", "N", ")", "Ops", ".", "push_back", "(", "Node", "->", "getOperand", "(", "N", "+", "<NUM_LIT>", ")", ")", ";" ]

[ "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ",", "Val", ")", ";" ]

[ "assert", "(", "Op", ".", "getValueType", "(", ")", ".", "is128BitVector", "(", ")", "&&", "Op", ".", "getNumOperands", "(", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "unexpected CONCAT_VECTORS", "<STR_LIT>", ")", ";", "DebugLoc", "dl", "=", "Op", ".", "getDebugLoc", "(", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getUNDEF", "(", "MVT", "::", "v2f64", ")", ";", "SDValue", "Op0", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Op1", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Op0", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "UNDEF", ")", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "INSERT_VECTOR_ELT", ",", "dl", ",", "MVT", "::", "v2f64", ",", "Val", ",", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "MVT", "::", "f64", ",", "Op0", ")", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "Op1", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "UNDEF", ")", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "INSERT_VECTOR_ELT", ",", "dl", ",", "MVT", "::", "v2f64", ",", "Val", ",", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "MVT", "::", "f64", ",", "Op1", ")", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ")", ")", ";" ]

[ "case", "MVT", "::", "v16i16", ":" ]

[ "V1", "=", "DAG", ".", "getBitcast", "(", "FpVT", ",", "V1", ")", ";", "V2", "=", "DAG", ".", "getBitcast", "(", "FpVT", ",", "V2", ")", ";", "return", "DAG", ".", "getBitcast", "(", "VT", ",", "DAG", ".", "getVectorShuffle", "(", "FpVT", ",", "DL", ",", "V1", ",", "V2", ",", "Mask", ")", ")", ";", "}", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "case", "MVT", "::", "v4f64", ":", "return", "lowerV4F64Shuffle", "(", "DL", ",", "Mask", ",", "Zeroable", ",", "V1", ",", "V2", ",", "Subtarget", ",", "DAG", ")", ";", "case", "MVT", "::", "v4i64", ":", "return", "lowerV4I64Shuffle", "(", "DL", ",", "Mask", ",", "Zeroable", ",", "V1", ",", "V2", ",", "Subtarget", ",", "DAG", ")", ";", "case", "MVT", "::", "v8f32", ":", "return", "lowerV8F32Shuffle", "(", "DL", ",", "Mask", ",", "Zeroable", ",", "V1", ",", "V2", ",", "Subtarget", ",", "DAG", ")", ";", "case", "MVT", "::", "v8i32", ":", "return", "lowerV8I32Shuffle", "(", "DL", ",", "Mask", ",", "Zeroable", ",", "V1", ",", "V2", ",", "Subtarget", ",", "DAG", ")", ";" ]

[ "bool", "alpha_expand_mov", "(", "machine_mode", "mode", ",", "rtx", "*", "operands", ")", "{", "rtx", "tmp", ";", "if", "(", "MEM_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", "&&", "!", "reg_or_0_operand", "(", "operands", "[", "<NUM_LIT>", "]", ",", "mode", ")", ")", "operands", "[", "<NUM_LIT>", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "if", "(", "mode", "==", "Pmode", "&&", "symbolic_operand", "(", "operands", "[", "<NUM_LIT>", "]", ",", "mode", ")", ")", "{", "tmp", "=", "alpha_legitimize_address_1", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "mode", ")", ";", "if", "(", "tmp", ")", "{", "if", "(", "tmp", "==", "operands", "[", "<NUM_LIT>", "]", ")", "return", "true", ";", "operands", "[", "<NUM_LIT>", "]", "=", "tmp", ";", "return", "false", ";", "}", "}", "if", "(", "!", "CONSTANT_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", "||", "input_operand", "(", "operands", "[", "<NUM_LIT>", "]", ",", "mode", ")", ")", "return", "false", ";", "if", "(", "CONST_INT_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", "||", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "CONST_VECTOR", ")", "{", "if", "(", "alpha_split_const_mov", "(", "mode", ",", "operands", ")", ")", "return", "true", ";", "}", "tmp", "=", "force_const_mem", "(", "mode", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "if", "(", "tmp", "==", "NULL_RTX", ")", "return", "false", ";", "if", "(", "reload_in_progress", ")", "{", "emit_move_insn", "(", "operands", "[", "<NUM_LIT>", "]", ",", "XEXP", "(", "tmp", ",", "<NUM_LIT>", ")", ")", ";", "operands", "[", "<NUM_LIT>", "]", "=", "replace_equiv_address", "(", "tmp", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "}", "else", "operands", "[", "<NUM_LIT>", "]", "=", "validize_mem", "(", "tmp", ")", ";", "return", "false", ";", "}" ]

[ "Expand", "a", "move", "instruction", ";", "return", "true", "if", "all", "work", "is", "done", ".", "We", "do", "n't", "handle", "non-bwx", "subword", "loads", "here", "." ]

[ ")", "&&", "<STR_LIT>", "Invalid number of operands!", "<STR_LIT>", ")", ";" ]

[ "assert", "(", "N", "==", "<NUM_LIT>", "&&", "isMemoryIndexed16", "(" ]

[ ">", ";" ]

[ "def", "arith_shift32", ":", "arith_shift", "<", "i32", ",", "<NUM_LIT>" ]