Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "]", ";" ]

[ "def", "L2_loadri_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", "=", "WordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "CS" ]

[ "<NUM_LIT>", ";" ]

[ "def", "C2_cmpgtup", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss32", ",", "DoubleRegs", ":", "$", "Rtt32", ")", ",", "<STR_LIT>", ",", "tc_85d5d03f", ",", "TypeALU64", ">", ",", "Enc_fcf7a7", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isCompare", "=" ]

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

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

[ "<FIXS>", "[", "(", "MipsSync", "imm", ":", "$", "stype", ")", "]", ",", "NoItinerary", ",", "FrmOther", ">", "<FIXE>", "<FIXS>", "bits", "<NUM_LIT>", ">", "stype", ";", "let", "Opcode", "=", "<NUM_LIT>", ";", "<FIXE>", "<FIXS>", "def", "LL", ":", "FMem", "<NUM_LIT>", ",", "(", "outs", "CPURegs", ":", "$", "rt", ")", ",", "(", "ins", "mem", ":", "$", "addr", ")", ",", "<STR_LIT>", ",", "[", "]", ",", "IILoad", ">", ";", "let", "mayStore", "=", "<NUM_LIT>", ",", "Constraints", "=", "<STR_LIT>", "indef", "SC", ":", "FMem", "<NUM_LIT>", ",", "(", "outs", "CPURegs", ":", "$", "dst", ")", ",", "(", "ins", "CPURegs", ":", "$", "rt", ",", "mem", ":", "$", "addr", ")", ",", "<STR_LIT>", ",", "[", "]", ",", "IIStore", ">", ";", "<FIXE>" ]

[ "let", "hasSideEffects", "=", "<NUM_LIT>", "indef", "SYNC", ":", "MipsInst", "(", "outs", ")", ",", "(", "ins", "i32imm", ":", "$", "stype", ")", ",", "<STR_LIT>", ",", "<BUGS>", "[", "(", "MipsSync", "imm", ":", "$", "stype", ")", "]", ",", "NoItinerary", ">", "<BUGE>", "{", "<BUGS>", "let", "opcode", "=", "<NUM_LIT>", ";", "<BUGE>", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "}", "let", "mayLoad", "=", "<NUM_LIT>", "in", "<BUGS>", "def", "LL", ":", "FI", "<NUM_LIT>", ",", "(", "outs", "CPURegs", ":", "$", "dst", ")", ",", "(", "ins", "mem", ":", "$", "addr", ")", ",", "<STR_LIT>", ",", "[", "]", ",", "IILoad", ">", ";", "let", "mayStore", "=", "<NUM_LIT>", ",", "Constraints", "=", "<STR_LIT>", "indef", "SC", ":", "FI", "<NUM_LIT>", ",", "(", "outs", "CPURegs", ":", "$", "dst", ")", ",", "(", "ins", "CPURegs", ":", "$", "src", ",", "mem", ":", "$", "addr", ")", ",", "<STR_LIT>", ",", "[", "]", ",", "IIStore", ">", ";", "<BUGE>", "def", "J", ":", "JumpFJ", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";" ]

[ "<STR_LIT>" ]

[ "UNSPEC_CMPGDU_LT_QB", ")", ")", "(", "set", "(", "reg", ":", "CCDSP", "CCDSP_CC_REGNUM", ")", "(", "unspec", ":", "CCDSP", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "reg", ":", "CCDSP", "CCDSP_CC_REGNUM", ")", "]", "UNSPEC_CMPGDU_LT_QB", ")", ")", "]", "<STR_LIT>" ]

[ "}" ]

[ "static", "int", "sh_mode_after", "(", "int", "entity", "ATTRIBUTE_UNUSED", ",", "int", "mode", ",", "rtx_insn", "*", "insn", ")", "{", "if", "(", "TARGET_HITACHI", "&&", "recog_memoized", "(", "insn", ")", ">=", "<NUM_LIT>", "&&", "get_attr_fp_set", "(", "insn", ")", "!=", "FP_SET_NONE", ")", "return", "(", "int", ")", "get_attr_fp_set", "(", "insn", ")", ";", "else", "return", "mode", ";" ]

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

[ "def", "VTX_READ_8_eg", ":", "VTX_READ_eg", "<", "<STR_LIT>", ",", "(", "outs", "R600_TReg32_X", ":", "$", "dst_gpr", ")", ">", "{", "let", "MEGA_FETCH_COUNT", "=", "<NUM_LIT>", ";", "let", "DST_SEL_X", "=", "<NUM_LIT>", ";", "let", "DST_SEL_Y", "=", "<NUM_LIT>", ";", "let", "DST_SEL_Z", "=", "<NUM_LIT>", ";", "let", "DST_SEL_W", "=", "<NUM_LIT>", ";" ]

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

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

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

[ "static", "void", "foldImmediates", "(", "MachineInstr", "&", "MI", ",", "const", "SIInstrInfo", "*", "TII", ",", "MachineRegisterInfo", "&", "MRI", ",", "bool", "TryToCommute", "=", "true", ")", "{", "if", "(", "!", "MRI", ".", "isSSA", "(", ")", ")", "return", ";", "assert", "(", "TII", "->", "isVOP1", "(", "MI", ")", "||", "TII", "->", "isVOP2", "(", "MI", ")", "||", "TII", "->", "isVOPC", "(", "MI", ")", ")", ";", "int", "Src0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", ".", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ";", "if", "(", "TII", "->", "isLiteralConstant", "(", "MI", ",", "Src0Idx", ")", ")", "return", ";", "MachineOperand", "&", "Src0", "=", "MI", ".", "getOperand", "(", "Src0Idx", ")", ";", "if", "(", "Src0", ".", "isReg", "(", ")", "&&", "MRI", ".", "hasOneUse", "(", "Src0", ".", "getReg", "(", ")", ")", ")", "{", "unsigned", "Reg", "=", "Src0", ".", "getReg", "(", ")", ";", "MachineInstr", "*", "Def", "=", "MRI", ".", "getUniqueVRegDef", "(", "Reg", ")", ";", "if", "(", "Def", "&&", "Def", "->", "isMoveImmediate", "(", ")", ")", "{", "MachineOperand", "&", "MovSrc", "=", "Def", "->" ]

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

[ "def", "F2_sfclass", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "u5_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_643b4717", ",", "TypeS_2op", ">", ",", "Enc_83ee64", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

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

[ "class", "VpuInst_MovIType", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "RegisterClass", "Rdst", ",", "Operand", "Isrc", ",", "string", "asmstr", ",", "Operand", "Pred", ">", ":", "VectorInstShort", "<", "opc", ",", "asmstr", ">", "{", "let", "OutOperandList", "=", "(", "outs", "Rdst", ":", "$", "dest", ")", ";", "let", "InOperandList", "=", "(", "ins", "TPCImm", "<", "Isrc", ">", ":", "$", "src", ",", "DataType", ":", "$", "optype", ",", "SwitchSet", ":", "$", "sw", ",", "Rdst", ":", "$", "income", ",", "Pred", ":", "$", "pred", ")", ";", "let", "Itinerary", "=", "IIC_VectorOp", ";", "let", "isReMaterializable", "=", "<NUM_LIT>", ";", "let", "isAsCheapAsAMove", "=", "<NUM_LIT>", ";" ]

[ "iops", ";" ]

[ "dag", "oops", ";", "dag" ]

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

[ "def", "v1i64_indexed", ":", "BaseSIMDIndexed", "<", "<NUM_LIT>", ",", "U", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "opc", ",", "FPR64Op", ",", "FPR32Op", ",", "V128", ",", "VectorIndexS", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "idx", ";" ]

[ "}" ]

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

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

[ "return", "&", "InstrInfo", "->" ]

[ ")" ]

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

[ "return", "DAG", ".", "getNode", "(", "ISD", "::", "XOR", ",", "dl", ",", "VT", ",", "Op0", ",", "Op1", ")", ";" ]

[ "assert", "(", "Op0", ".", "getValueType", "(", ")", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", "&&", "<STR_LIT>", "Unexpected type for boolean compare operation", "<STR_LIT>", ")", ";", "ISD", "::", "CondCode", "SetCCOpcode", "=", "cast", "<", "CondCodeSDNode", ">", "(", "CC", ")", "->", "get", "(", ")", ";", "SDValue", "NotOp0", "=", "DAG", ".", "getNode", "(", "ISD", "::", "XOR", ",", "dl", ",", "VT", ",", "Op0", ",", "DAG", ".", "getConstant", "(", "-", "<NUM_LIT>", ",", "dl", ",", "VT", ")", ")", ";", "SDValue", "NotOp1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "XOR", ",", "dl", ",", "VT", ",", "Op1", ",", "DAG", ".", "getConstant", "(", "-", "<NUM_LIT>", ",", "dl", ",", "VT", ")", ")", ";", "switch", "(", "SetCCOpcode", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected SETCC condition", "<STR_LIT>", ")", ";", "case", "ISD", "::", "SETNE", ":", "return", "DAG", ".", "getNode", "(", "ISD", "::", "XOR", ",", "dl", ",", "VT", ",", "DAG", ".", "getNode", "(", "ISD", "::", "XOR", ",", "dl", ",", "VT", ",", "Op0", ",", "Op1", ")", ",", "DAG", ".", "getConstant", "(", "-", "<NUM_LIT>", ",", "dl", ",", "VT", ")", ")", ";", "case", "ISD", "::", "SETEQ", ":" ]

[ "gcc_assert", "(", "GET_MODE", "(", "*", "op", ")", "==", "V2DImode", ")", ";" ]

[ "emit_insn_before", "(", "gen_move_insn", "(", "tmp", ",", "*", "op", ")", ",", "insn", ")", ";", "*", "op", "=", "gen_rtx_SUBREG", "(", "V2DImode", ",", "tmp", ",", "<NUM_LIT>", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "<STR_LIT>", " Preloading operand for insn %d into r%d\\n", "<STR_LIT>", ",", "INSN_UID", "(", "insn", ")", ",", "REGNO", "(", "tmp", ")", ")", ";", "}", "else", "if", "(", "REG_P", "(", "*", "op", ")", ")", "{", "df_ref", "ref", ";", "FOR_EACH_INSN_USE", "(", "ref", ",", "insn", ")", "if", "(", "DF_REF_REGNO", "(", "ref", ")", "==", "REGNO", "(", "*", "op", ")", ")", "{", "gcc_assert", "(", "!", "DF_REF_CHAIN", "(", "ref", ")", ")", ";", "break", ";", "}", "*", "op", "=", "gen_rtx_SUBREG", "(", "V2DImode", ",", "*", "op", ",", "<NUM_LIT>", ")", ";", "}", "else", "{", "gcc_assert", "(", "SUBREG_P", "(", "*", "op", ")", ")", ";" ]

[ "return", "false", ";" ]

[ "bool", "X86FastISel", "::", "X86SelectFPTrunc", "(", "const", "Instruction", "*", "I", ")", "{", "if", "(", "Subtarget", "->", "hasSSE2", "(", ")", "&&", "I", "->", "getType", "(", ")", "->", "isFloatTy", "(", ")", "&&", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", "->", "getType", "(", ")", "->", "isDoubleTy", "(", ")", ")", "{", "bool", "HasAVX512", "=", "Subtarget", "->", "hasAVX512", "(", ")", ";", "unsigned", "Opc", "=", "HasAVX512", "?", "X86", "::", "VCVTSD2SSZrr", ":", "Subtarget", "->", "hasAVX", "(", ")", "?", "X86", "::", "VCVTSD2SSrr", ":", "X86", "::", "CVTSD2SSrr", ";", "return", "X86SelectFPExtOrFPTrunc", "(", "I", ",", "Opc", ",", "TLI", ".", "getRegClassFor", "(", "MVT", "::", "f32", ")", ")", ";", "}" ]

[ "<NUM_LIT>", ";" ]

[ "else", "if", "(", "isa", "<", "ConstantExpr", ">", "(", "Obj", ")", ")", "return", "false", ";", "Addr", ".", "Base", ".", "Reg", "=", "getRegForValue", "(", "Obj", ")", ";", "return", "Addr", ".", "Base", ".", "Reg", "!=" ]

[ "<FIXS>", "rtx_insn", "*", "insn", ";", "<FIXE>" ]

[ "static", "const", "char", "*", "get_some_local_dynamic_name", "(", "void", ")", "{", "<BUGS>", "rtx", "insn", ";", "<BUGE>", "if", "(", "cfun", "->", "machine", "->", "some_ld_name", ")", "return", "cfun", "->", "machine", "->", "some_ld_name", ";" ]

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

[ "extern", "_", "_", "inline", "_", "_", "m256", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_maskz_div_ps", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m256", "_", "_", "A", ",", "_", "_", "m256", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m256", ")", "_", "_", "builtin_ia32_divps256_mask", "(", "(", "_", "_", "v8sf", ")", "_", "_", "A", ",", "(", "_", "_", "v8sf", ")", "_", "_", "B", ",", "(", "_", "_", "v8sf", ")", "_", "mm256_setzero_ps", "(", ")", ",", "(", "_", "_" ]

[ "return", "DAG", ".", "getStore", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "dl", ",", "Addr", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "MachinePointerInfo", "(", ")", ")", ";" ]

[ "XCoreFunctionInfo", "*", "XFI", "=", "MF", ".", "getInfo", "<", "XCoreFunctionInfo", ">", "(", ")", ";", "SDValue", "Addr", "=", "DAG", ".", "getFrameIndex", "(", "XFI", "->", "getVarArgsFrameIndex", "(", ")", ",", "MVT", "::", "i32", ")", ";" ]

[ "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "xor", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]" ]

[ "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "ashiftrt", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "minus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")" ]

[ "}" ]

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

[ ")", ";" ]

[ "memset", "(", "&", "UsedRegs", ",", "<NUM_LIT>", ",", "sizeof", "(", "UsedRegs", ")", ")", ";", "memset", "(", "&", "DefinedRegs", ",", "<NUM_LIT>", ",", "sizeof", "(", "DefinedRegs", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "ST", ".", "getGeneration", "(", ")", "<=", "AMDGPUSubtarget", "::", "SEA_ISLANDS", ")", "{", "if", "(", "TII", "->", "isSMRD", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "VCCZCorrupt", "=", "true", ";", "}", "else", "if", "(", "!", "hasOutstandingLGKM", "(", ")", "&&", "I", "->", "modifiesRegister", "(", "AMDGPU", "::", "VCC", ",", "TRI", ")", ")", "{", "VCCZCorrupt", "=", "false", ";", "}", "if", "(", "readsVCCZ", "(", "I", "->", "getOpcode", "(", ")", ")", "&&", "VCCZCorrupt", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Inserting vccz bug work-around before: ", "<STR_LIT>", "<<", "*", "I", "<<", "'", "\\n", "'", ")", ";", "insertWait", "(", "MBB", ",", "I", ",", "LastIssued", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "I", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOV_B64", ")", ",", "AMDGPU", "::", "VCC", ")", ".", "addReg", "(", "AMDGPU", "::", "VCC", ")", ";", "}", "}", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "S_BARRIER", ")", "Changes", "|=", "insertWait", "(", "MBB", ",", "I", ",", "LastIssued", ")", ";", "else", "Changes", "|=", "insertWait", "(", "MBB", ",", "I", ",", "handleOperands", "(", "*", "I", ")", ")", ";", "pushInstruction", "(", "MBB", ",", "I" ]

[ "}" ]

[ "AU", ".", "addPreserved", "<", "LiveIntervals", ">", "(", ")", ";", "AU", ".", "addPreservedID", "(", "LiveVariablesID", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";" ]

[ ")" ]

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

[ "const", "char", "*", "msp430_propagate_region_opt", "(", "int", "argc", ",", "const", "char", "*", "*", "argv", ")", "{", "if", "(", "strcmp", "(", "argv", "[", "<NUM_LIT>", "]", ",", "<STR_LIT>", "lower", "<STR_LIT>", ")", "!=", "<NUM_LIT>", ")", "return", "argv", "[", "<NUM_LIT>", "]", ";", "else", "if", "(", "(", "argc", "==", "<NUM_LIT>", ")", "&&", "(", "strcmp", "(", "argv", "[", "<NUM_LIT>", "]", ",", "<STR_LIT>", "-muse-lower-region-prefix", "<STR_LIT>", ")", "==", "<NUM_LIT>", ")", ")", "return", "argv", "[", "<NUM_LIT>", "]", ";", "return", "<STR_LIT>", "none", "<STR_LIT>", ";", "}" ]

[ "Spec", "function", ".", "Propagate", "-m", "{", "code", ",", "data", "}", "-region=", "to", "the", "linker", ",", "unless", "the", "lower", "region", "has", "been", "specified", "without", "-muse-lower-region-prefix", "also", "being", "used", "." ]

[ ")", ")" ]

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

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

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

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

[ "dag", "OutOperandList", "=", "(", "outs", "ROWD", ":", "$", "wd", ")", ";", "dag", "InOperandList", "=", "(", "ins", "ROWD", ":", "$", "wd_in", ",", "ROWS", ":", "$", "ws", ",", "GPR32Opnd", ":", "$", "rt", ")", ";", "string", "AsmString", "=", "!", "strconcat", "(", "instr_asm", "," ]

[ "}", ",", "<STR_LIT>", ">", "{" ]

[ "def", "VLD3LNd32", ":", "VLD3LN", "<", "<NUM_LIT>", ",", "{", "?", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>" ]

[ "Value", "*", "ARMTargetLowering", "::", "getSDagStackGuard", "(", "const", "Module", "&", "M", ")", "const", "{", "if", "(", "Subtarget", "->", "getTargetTriple", "(", ")", ".", "isWindowsMSVCEnvironment", "(", ")", ")", "return", "M", ".", "getGlobalVariable", "(", "<STR_LIT>", "__security_cookie", "<STR_LIT>", ")", ";", "return", "TargetLowering", "::", "getSDagStackGuard", "(", "M", ")", ";", "}" ]

[ "Return", "the", "variable", "that", "'s", "previously", "inserted", "by", "insertSSPDeclarations", ",", "if", "any", ",", "otherwise", "return", "nullptr", "." ]

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "P", ".", "HasSrc1Mods", ",", "src1_modifiers", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "src0_modifiers", ";", "bits", "<", "<NUM_LIT>", ">", "src0", ";", "bits", "<", "<NUM_LIT>", ">", "src1_modifiers", ";", "bits", "<", "<NUM_LIT>", ">", "src1", ";", "bits", "<", "<NUM_LIT>", ">", "src2_modifiers", ";", "bits", "<", "<NUM_LIT>", ">", "src2", ";", "bits", "<", "<NUM_LIT>", ">", "clamp", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "vdst", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "P", ".", "HasSrc0Mods", ",", "src0_modifiers", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "P", ".", "HasSrc1Mods", ",", "src1_modifiers", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "P", ".", "HasSrc2Mods", ",", "src2_modifiers", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "!", "and", "(", "P", ".", "HasSrc0", ",", "P", ".", "HasOpSel", ")", ",", "src0_modifiers", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "!", "and", "(", "P", ".", "HasSrc1", ",", "P", ".", "HasOpSel", ")", ",", "src1_modifiers", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "!", "and", "(", "P", ".", "HasSrc2", ",", "P", ".", "HasOpSel", ")", ",", "src2_modifiers", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "!", "and", "(", "P", ".", "HasSrc2", ",", "P", ".", "HasOpSel", ")", ",", "src2_modifiers", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "P", ".", "HasClamp", ",", "clamp", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "!", "if", "(", "P", ".", "HasSrc0", ",", "src0", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "!", "if", "(", "P", ".", "HasSrc1", ",", "src1", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "!", "if", "(", "P", ".", "HasSrc2", ",", "src2", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "!", "and", "(", "P", ".", "HasSrc0", ",", "P", ".", "HasOpSel", ")", ",", "src0_modifiers", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "!", "and", "(", "P", ".", "HasSrc1", ",", "P", ".", "HasOpSel", ")", ",", "src1_modifiers", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "P", ".", "HasSrc0Mods", ",", "src0_modifiers", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ";" ]

[ "MBB", ".", "erase", "(", "II", ")", ";" ]

[ "Register", "DestReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "assert", "(", "MI", ".", "definesRegister", "(", "DestReg", ")", "&&", "<STR_LIT>", "RESTORE_ACC does not define its destination", "<STR_LIT>", ")", ";", "bool", "IsPrimed", "=", "PPC", "::", "ACCRCRegClass", ".", "contains", "(", "DestReg", ")", ";", "Register", "Reg", "=", "PPC", "::", "VSRp0", "+", "(", "DestReg", "-", "(", "IsPrimed", "?", "PPC", "::", "ACC0", ":", "PPC", "::", "UACC0", ")", ")", "*", "<NUM_LIT>", ";", "bool", "IsLittleEndian", "=", "Subtarget", ".", "isLittleEndian", "(", ")", ";", "emitAccSpillRestoreInfo", "(", "MBB", ",", "IsPrimed", ",", "true", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "LXVP", ")", ",", "Reg", ")", ",", "FrameIndex", ",", "IsLittleEndian", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "LXVP", ")", ",", "Reg", "+", "<NUM_LIT>", ")", ",", "FrameIndex", ",", "IsLittleEndian", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "if", "(", "IsPrimed", ")", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "XXMTACC", ")", ",", "DestReg", ")", ".", "addReg", "(", "DestReg", ")", ";" ]

[ "funname", ")", ")", "{" ]

[ "if", "(", "darwin_emit_branch_islands", "&&", "TARGET_32BIT", ")", "make_island", "=", "true", ";", "else", "{", "func", "=", "rs6000_longcall_ref", "(", "func_desc", ",", "NULL_RTX", ")", ";", "cookie_val", "&=", "~", "CALL_LONG", ";", "}", "}", "if", "(", "GET_CODE", "(", "func", ")", "!=", "SYMBOL_REF", ")", "{", "func", "=", "force_reg", "(", "Pmode", ",", "func", ")", ";", "func_addr", "=", "gen_rtx_REG", "(", "Pmode", ",", "CTR_REGNO", ")", ";", "emit_move_insn", "(", "func_addr", ",", "func", ")", ";", "}", "else", "func_addr", "=", "func", ";", "call", "[", "<NUM_LIT>", "]", "=", "gen_rtx_CALL", "(", "VOIDmode", ",", "gen_rtx_MEM", "(", "SImode", ",", "func_addr", ")", ",", "tlsarg", ")", ";", "if", "(", "value", "!=", "NULL_RTX", ")", "call", "[", "<NUM_LIT>", "]", "=", "gen_rtx_SET", "(", "value", ",", "call", "[", "<NUM_LIT>", "]", ")", ";", "call", "[", "<NUM_LIT>", "]", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "GEN_INT", "(", "cookie_val", ")", ")", ";", "if", "(", "sibcall", ")", "call", "[", "<NUM_LIT>", "]", "=", "simple_return_rtx", ";", "else", "call", "[", "<NUM_LIT>", "]", "=", "gen_hard_reg_clobber", "(", "Pmode", ",", "LR_REGNO", ")", ";", "insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec_v", "(", "<NUM_LIT>", ",", "call", ")", ")", ";", "insn", "=", "emit_call_insn", "(", "insn", ")", ";", "if", "(", "make_island", ")", "{", "tree", "funname", "=", "get_identifier", "(", "XSTR", "(", "func_desc", ",", "<NUM_LIT>", ")", ")", ";", "if", "(", "no_previous_def", "(" ]

[ "SDValue", "XCoreTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "XCoreFunctionInfo", "*", "XFI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getInfo", "<", "XCoreFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFrameInfo", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "if", "(", "!", "isVarArg", ")", "CCInfo", ".", "AllocateStack", "(", "XFI", "->", "getReturnStackOffset", "(", ")", ",", "Align", "(", "<NUM_LIT>", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_XCore", ")", ";", "SDValue", "Glue", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "RetOps", "(", "<NUM_LIT>", ",", "Chain", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "MemOpChains", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "continue", ";", "assert", "(", "VA", ".", "isMemLoc", "(", ")", ")", ";", "if", "(", "isVarArg", ")", "{", "report_fatal_error", "(", "<STR_LIT>", "Can't return value from vararg function in memory", "<STR_LIT>", ")", ";", "}", "int", "Offset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "unsigned", "ObjSize", "=", "VA", ".", "getLocVT", "(", ")", ".", "getSizeInBits", "(", ")", "/", "<NUM_LIT>", ";", "int", "FI", "=", "MFI", ".", "CreateFixedObject", "(", "ObjSize", ",", "Offset", ",", "false", ")", ";", "SDValue", "FIN", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "MVT", "::", "i32", ")", ";", "MemOpChains", ".", "push_back", "(", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "OutVals", "[", "i", "]", ",", "FIN", ",", "MachinePointerInfo", "::", "getFixedStack", "(", "DAG", ".", "getMachineFunction", "(", ")", ",", "FI", ")", ")", ")", ";", "}", "if", "(", "!", "MemOpChains", ".", "empty", "(", ")", ")", "Chain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "dl", ",", "MVT", "::", "Other", ",", "MemOpChains", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "if", "(", "!", "VA", ".", "isRegLoc", "(", ")", ")", "continue", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Glue", ")", ";", "Glue", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "<NUM_LIT>", "]", "=", "Chain", ";", "if", "(", "Glue", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Glue", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "<FIXS>", "addrMode", "=", "BaseLongOffset", ",", "AddedComplexity", "=", "<NUM_LIT>", "in", "<FIXE>" ]

[ "}", "let", "isExtended", "=", "<NUM_LIT>", ",", "opExtendable", "=", "<NUM_LIT>", ",", "opExtentBits", "=", "<NUM_LIT>", ",", "InputType", "=", "<STR_LIT>", ",", "<BUGS>", "addrMode", "=", "BaseLongOffset", ",", "AddedComplexity", "=", "<NUM_LIT>", "in", "<BUGE>", "class", "T_StoreAbsReg", "string", "mnemonic", ",", "string", "CextOp", ",", "RegisterClass", "RC", ",", "bits", "<NUM_LIT>", ">", "MajOp", ",", "MemAccessSize", "AccessSz", ",", "bit", "isHalf", "=", "<NUM_LIT>", ">", ":", "STInst", "(", "outs", ")", "," ]

[ "<FIXS>", "D15", "]", ">", "{", "<FIXE>", "<FIXS>", "<FIXE>" ]

[ "D10", ",", "D11", ",", "D12", ",", "D13", ",", "D14", ",", "<BUGS>", "D15", "]", ">", "{", "<BUGE>", "let", "SubRegClasses", "=", "[", "(", "FGR32", "sub_fpeven", ",", "sub_fpodd", ")", "]", ";", "<BUGS>", "let", "MethodProtos", "=", "[", "{", "iterator", "allocation_order_end", "(", "const", "MachineFunction", "&", "MF", ")", "const", ";", "}", "]", ";", "let", "MethodBodies", "=", "[", "{", "AFGR64Class", ":", ":", "iteratorAFGR64Class", ":", ":", "allocation_order_end", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "end", "(", ")", "-", "<NUM_LIT>", ";", "}", "}", "]", ";", "<BUGE>", "}" ]

[ "Ret", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "MVT", "::", "i32", ",", "Ret", ",", "ShiftAmt", ")", ";" ]

[ "LoadSDNode", "*", "Load", "=", "cast", "<", "LoadSDNode", ">", "(", "Op", ")", ";", "ISD", "::", "LoadExtType", "ExtType", "=", "Load", "->", "getExtensionType", "(", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "EVT", "MemVT", "=", "Load", "->", "getMemoryVT", "(", ")", ";", "if", "(", "ExtType", "!=", "ISD", "::", "NON_EXTLOAD", "&&", "!", "VT", ".", "isVector", "(", ")", "&&", "VT", ".", "getSizeInBits", "(", ")", ">", "<NUM_LIT>", ")", "{", "SDValue", "ExtLoad32", "=", "DAG", ".", "getExtLoad", "(", "ExtType", ",", "DL", ",", "MVT", "::", "i32", ",", "Load", "->", "getChain", "(", ")", ",", "Load", "->", "getBasePtr", "(", ")", ",", "MemVT", ",", "Load", "->", "getMemOperand", "(", ")", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "DAG", ".", "getNode", "(", "ISD", "::", "getExtForLoadExtType", "(", "ExtType", ")", ",", "DL", ",", "VT", ",", "ExtLoad32", ")", ",", "ExtLoad32", ".", "getValue", "(", "<NUM_LIT>", ")", "}", ";", "return", "DAG", ".", "getMergeValues", "(", "Ops", ",", "DL", ")", ";", "}", "if", "(", "ExtType", "==", "ISD", "::", "NON_EXTLOAD", "&&", "VT", ".", "getSizeInBits", "(", ")", "<", "<NUM_LIT>", ")", "{", "assert", "(", "VT", "==", "MVT", "::", "i1", "&&", "<STR_LIT>", "Only i1 non-extloads expected", "<STR_LIT>", ")", ";", "SDValue", "Chain", "=", "Load", "->", "getChain", "(", ")", ";", "SDValue", "BasePtr", "=", "Load", "->", "getBasePtr", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "Load", "->", "getMemOperand", "(", ")", ";", "SDValue", "NewLD", "=", "DAG", ".", "getExtLoad", "(", "ISD", "::", "EXTLOAD", ",", "DL", ",", "MVT", "::", "i32", ",", "Chain", ",", "BasePtr", ",", "MVT", "::", "i8", ",", "MMO", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "VT", ",", "NewLD", ")", ",", "NewLD", ".", "getValue", "(", "<NUM_LIT>", ")", "}", ";", "return", "DAG", ".", "getMergeValues", "(", "Ops", ",", "DL", ")", ";", "}", "if", "(", "Load", "->", "getAddressSpace", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "isa", "<", "GlobalVariable", ">", "(", "GetUnderlyingObject", "(", "Load", "->", "getMemOperand", "(", ")", "->", "getValue", "(", ")", ")", ")", ")", "{", "SDValue", "Ptr", "=", "DAG", ".", "getZExtOrTrunc", "(", "Load", "->", "getBasePtr", "(", ")", ",", "DL", ",", "getPointerTy", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "Ptr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "MVT", "::", "i32", ",", "Ptr", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "Op", "->", "getVTList", "(", ")", ",", "Load", "->", "getChain", "(", ")", ",", "Ptr", ",", "DAG", ".", "getTargetConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "}", "if", "(", "Load", "->", "getAddressSpace", "(", ")", "!=", "<STR_LIT>", "::", "<STR_LIT>", "||", "ExtType", "==", "ISD", "::", "NON_EXTLOAD", "||", "Load", "->", "getMemoryVT", "(", ")", ".", "bitsGE", "(", "MVT", "::", "i32", ")", ")", "return", "SDValue", "(", ")", ";", "SDValue", "Ptr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "MVT", "::", "i32", ",", "Load", "->", "getBasePtr", "(", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "Ret", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "Op", ".", "getValueType", "(", ")", ",", "Load", "->", "getChain", "(", ")", ",", "Ptr", ",", "DAG", ".", "getTargetConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "ByteIdx", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "MVT", "::", "i32", ",", "Load", "->", "getBasePtr", "(", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "ShiftAmt", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "DL", ",", "MVT", "::", "i32", ",", "ByteIdx", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";" ]

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

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

[ "<FIXS>", "warning", "(", "OPT_Wattributes", ",", "<STR_LIT>", "%qE attribute ignored without %<-mcmse%> ", "<STR_LIT>", "<STR_LIT>", "option.", "<STR_LIT>", ",", "name", ")", ";", "<FIXE>" ]

[ "if", "(", "!", "use_cmse", ")", "{", "*", "no_add_attrs", "=", "true", ";", "<BUGS>", "warning", "(", "OPT_Wattributes", ",", "<STR_LIT>", "%qE attribute ignored without -mcmse option.", "<STR_LIT>", ",", "name", ")", ";", "<BUGE>", "return", "NULL_TREE", ";", "}" ]

[ "}" ]

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

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "LC1", ",", "SA1", "]", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";" ]

[ ")", ")" ]

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

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";" ]

[ "unsigned", "AArch64FastISel", "::", "fastMaterializeAlloca", "(", "const", "AllocaInst", "*", "AI", ")", "{", "assert", "(", "TLI", ".", "getValueType", "(", "AI", "->", "getType", "(", ")", ",", "true", ")", "==", "MVT", "::", "i64", "&&", "<STR_LIT>", "Alloca should always return a pointer.", "<STR_LIT>", ")", ";", "if", "(", "!", "FuncInfo", ".", "StaticAllocaMap", ".", "count", "(", "AI", ")", ")", "return", "<NUM_LIT>", ";", "DenseMap", "<", "const", "AllocaInst", "*", ",", "int", ">", "::", "iterator", "SI", "=", "FuncInfo", ".", "StaticAllocaMap", ".", "find", "(", "AI", ")", ";", "if", "(", "SI", "!=", "FuncInfo", ".", "StaticAllocaMap", ".", "end", "(", ")", ")", "{", "unsigned", "ResultReg", "=", "createResultReg", "(", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "ResultReg", ")", ".", "addFrameIndex", "(", "SI", "->", "second", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "return", "ResultReg", ";", "}", "return", "<NUM_LIT>", ";", "}" ]

[ "Emit", "an", "alloca", "address", "in", "a", "register", "using", "target-specific", "logic", "." ]

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

[ "bool", "hasGotol", "(" ]

[ "X86", "::", "AddrScaleAmt", ")", ";" ]

[ "int", "MemOpStart", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", "MCID", ".", "TSFlags", ")", ";", "if", "(", "MemOpStart", "==", "-", "<NUM_LIT>", ")", "return", "None", ";", "MemOpStart", "+=", "<STR_LIT>", "::", "<STR_LIT>", "(", "MCID", ")", ";", "const", "MCOperand", "&", "SegReg", "=", "Inst", ".", "getOperand", "(", "MemOpStart", "+", "X86", "::", "AddrSegmentReg", ")", ";", "const", "MCOperand", "&", "BaseReg", "=", "Inst", ".", "getOperand", "(", "MemOpStart", "+", "X86", "::", "AddrBaseReg", ")", ";", "const", "MCOperand", "&", "IndexReg", "=", "Inst", ".", "getOperand", "(", "MemOpStart", "+", "X86", "::", "AddrIndexReg", ")", ";", "const", "MCOperand", "&", "ScaleAmt", "=", "Inst", ".", "getOperand", "(", "MemOpStart", "+" ]

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

[ "def", "_8H", ":", "NeonI_LDVList", "<", "<NUM_LIT>", ",", "opcode", ",", "<NUM_LIT>", ",", "!", "cast", "<", "RegisterOperand", ">", "(", "List", "#", "<STR_LIT>" ]

[ "<FIXS>", "void", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "char", ">", "Data", ",", "<FIXE>" ]

[ "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "override", ";", "<BUGS>", "void", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "MutableArrayRef", "char", ">", "Data", ",", "<BUGE>", "uint64_t", "Value", ",", "bool", "IsPCRel", ",", "MCContext", "&", "Ctx", ")", "const", "override", ";", "bool", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ")", "const", "override", "{", "return", "false", ";" ]

[ "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "WordAccess", ";", "let", "mayLoad", "=" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_cvtusepi64_epi16", "(", "_", "_", "m256i", "_", "_", "A", ")", "{", "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_pmovusqw256_mask", "(", "(", "_", "_", "v4di", ")", "_", "_", "A", ",", "(", "_", "_", "v8hi", ")", "_", "mm_undefined_si128", "(", ")", ",", "(", "_", "_", "mmask8", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "nohash_imm", ":", "$", "lane", ")", ",", "itin", ",", "<STR_LIT>", ">", ";" ]

[ "class", "VSTQLNPseudo", "<", "InstrItinClass", "itin", ">", ":", "PseudoNLdSt", "<", "(", "outs", ")", ",", "(", "ins", "addrmode6", ":", "$", "addr", ",", "QPR", ":", "$", "src", "," ]

[ "MadeChange", "=", "true", ";" ]

[ "unsigned", "UserOffset", "=", "getUserOffset", "(", "U", ")", ";", "unsigned", "MaxOffs", "=", "(", "(", "<NUM_LIT>", "<<", "Bits", ")", "-", "<NUM_LIT>", ")", "*", "Scale", ";", "if", "(", "!", "U", ".", "KnownAlignment", ")", "MaxOffs", "-=", "<NUM_LIT>", ";", "if", "(", "isCPEntryInRange", "(", "U", ".", "MI", ",", "UserOffset", ",", "U", ".", "CPEMI", ",", "MaxOffs", ",", "false", ",", "true", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Shrink: ", "<STR_LIT>", "<<", "*", "U", ".", "MI", ")", ";", "U", ".", "MI", "->", "setDesc", "(", "TII", "->", "get", "(", "NewOpc", ")", ")", ";", "MachineBasicBlock", "*", "MBB", "=", "U", ".", "MI", "->", "getParent", "(", ")", ";", "BBInfo", "[", "MBB", "->", "getNumber", "(", ")", "]", ".", "Size", "-=", "<NUM_LIT>", ";", "adjustBBOffsetsAfter", "(", "MBB", ")", ";", "++", "NumT2CPShrunk", ";" ]

[ "gen_int_relational", "(", "code", ",", "NULL_RTX", ",", "op0", ",", "op1", ",", "destination", ")", ";" ]

[ "void", "lm32_expand_conditional_branch", "(", "rtx", "operands", "[", "]", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ";", "rtx", "op0", "=", "operands", "[", "<NUM_LIT>", "]", ";", "rtx", "op1", "=", "operands", "[", "<NUM_LIT>", "]", ";", "rtx", "destination", "=", "operands", "[", "<NUM_LIT>", "]", ";" ]

[ "operands", "[", "<NUM_LIT>", "]", "=", "operand_subword", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "TImode", ")" ]

[ "operands", "[", "<NUM_LIT>", "]", "=", "operand_subword", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "TImode", ")", "operands", "[", "<NUM_LIT>", "]", "=", "operand_subword", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "TImode", ")" ]

[ "_", "a", "[", "<NUM_LIT>", "]", ")", "}", ";" ]

[ "return", "(", "int64x1_t", ")", "{", "vcvtd_s64_f64", "(", "_" ]

[ "_", "_", "v4si", ")", "_", "_", "A", ")", ";" ]

[ "return", "(", "_", "_", "m256d", ")", "_", "_", "builtin_ia32_cvtdq2pd256", "(", "(" ]

[ "VCTPs", ".", "push_back", "(", "MI", ")", ";" ]

[ "if", "(", "!", "Prev", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isIdenticalTo", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", "||", "!", "RDA", ".", "hasSameReachingDef", "(", "Prev", ",", "MI", ",", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ".", "asMCReg", "(", ")", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "ARM Loops: Found VCTP with a different reaching ", "<STR_LIT>", "<STR_LIT>", "definition from the main VCTP", "<STR_LIT>", ")", ";", "return", "false", ";", "}" ]

[ "BranchCode", "=", "X86", "::", "COND_E_AND_NP", ";" ]

[ "continue", ";", "}", "X86", "::", "CondCode", "BranchCode", "=", "X86", "::", "getCondFromBranch", "(", "*", "I", ")", ";", "if", "(", "BranchCode", "==", "X86", "::", "COND_INVALID", ")", "return", "true", ";", "if", "(", "I", "->", "findRegisterUseOperand", "(", "X86", "::", "EFLAGS", ")", "->", "isUndef", "(", ")", ")", "return", "true", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "MachineBasicBlock", "*", "TargetBB", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "if", "(", "AllowModify", "&&", "UnCondBrIter", "!=", "MBB", ".", "end", "(", ")", "&&", "MBB", ".", "isLayoutSuccessor", "(", "TargetBB", ")", ")", "{", "BranchCode", "=", "GetOppositeBranchCondition", "(", "BranchCode", ")", ";", "MachineBasicBlock", "::", "iterator", "OldInst", "=", "I", ";", "BuildMI", "(", "MBB", ",", "UnCondBrIter", ",", "MBB", ".", "findDebugLoc", "(", "I", ")", ",", "get", "(", "X86", "::", "JCC_1", ")", ")", ".", "addMBB", "(", "UnCondBrIter", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ")", ".", "addImm", "(", "BranchCode", ")", ";", "BuildMI", "(", "MBB", ",", "UnCondBrIter", ",", "MBB", ".", "findDebugLoc", "(", "I", ")", ",", "get", "(", "X86", "::", "JMP_1", ")", ")", ".", "addMBB", "(", "TargetBB", ")", ";", "OldInst", "->", "eraseFromParent", "(", ")", ";", "UnCondBrIter", "->", "eraseFromParent", "(", ")", ";", "UnCondBrIter", "=", "MBB", ".", "end", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "continue", ";", "}", "FBB", "=", "TBB", ";", "TBB", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "BranchCode", ")", ")", ";", "CondBranches", ".", "push_back", "(", "&", "*", "I", ")", ";", "continue", ";", "}", "assert", "(", "Cond", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", ";", "assert", "(", "TBB", ")", ";", "X86", "::", "CondCode", "OldBranchCode", "=", "(", "X86", "::", "CondCode", ")", "Cond", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ";", "auto", "NewTBB", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "if", "(", "OldBranchCode", "==", "BranchCode", "&&", "TBB", "==", "NewTBB", ")", "continue", ";", "if", "(", "TBB", "==", "NewTBB", "&&", "(", "(", "OldBranchCode", "==", "X86", "::", "COND_P", "&&", "BranchCode", "==", "X86", "::", "COND_NE", ")", "||", "(", "OldBranchCode", "==", "X86", "::", "COND_NE", "&&", "BranchCode", "==", "X86", "::", "COND_P", ")", ")", ")", "{", "BranchCode", "=", "X86", "::", "COND_NE_OR_P", ";", "}", "else", "if", "(", "(", "OldBranchCode", "==", "X86", "::", "COND_NP", "&&", "BranchCode", "==", "X86", "::", "COND_NE", ")", "||", "(", "OldBranchCode", "==", "X86", "::", "COND_E", "&&", "BranchCode", "==", "X86", "::", "COND_P", ")", ")", "{", "if", "(", "NewTBB", "!=", "(", "FBB", "?", "FBB", ":", "getFallThroughMBB", "(", "&", "MBB", ",", "TBB", ")", ")", ")", "return", "true", ";" ]

[ "SDValue", "expand", "(", "SDValue", "V", ")", "{", "SDLoc", "DL", "(", "V", ")", ";", "EVT", "VT", "=", "V", ".", "getValueType", "(", ")", ";", "unsigned", "VectWidth", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "if", "(", "V", ".", "getOpcode", "(", ")", "==", "ISD", "::", "BUILD_VECTOR", ")", "{", "if", "(", "isSplat", "(", "V", ")", ")", "return", "V", ";", "if", "(", "!", "isBuildVectorWithUndefs", "(", "V", ")", ")", "return", "SDValue", "(", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Args", ";", "Args", ".", "append", "(", "VectWidth", ",", "V", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_VECTOR", ",", "DL", ",", "VT", ",", "Args", ")", ";", "}", "if", "(", "isBinaryVectorOperation", "(", "V", ")", ")", "{", "SDValue", "Op1", "=", "V", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Op2", "=", "V", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "NewOp1", "=", "expand", "(", "Op1", ")", ";", "if", "(", "!", "NewOp1", ")", "return", "SDValue", "(", ")", ";", "SDValue", "NewOp2", "=", "expand", "(", "Op2", ")", ";", "if", "(", "!", "NewOp2", ")", "return", "SDValue", "(", ")", ";", "return", "DAG", ".", "getNode", "(", "V", ".", "getOpcode", "(", ")", ",", "DL", ",", "VT", ",", "NewOp1", ",", "NewOp2", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}" ]

[ "expand", "-", "Expand", "a", "record", "into", "a", "set", "of", "elements", "if", "possible", "." ]

[ "rawaddr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "op2", ",", "op1", ")", ";" ]

[ "machine_mode", "tmode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "mode", ";", "machine_mode", "smode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "mode", ";", "machine_mode", "mode1", "=", "Pmode", ";", "machine_mode", "mode2", "=", "Pmode", ";", "if", "(", "arg0", "==", "error_mark_node", "||", "arg1", "==", "error_mark_node", "||", "arg2", "==", "error_mark_node", ")", "return", "const0_rtx", ";", "op2", "=", "copy_to_mode_reg", "(", "mode2", ",", "op2", ")", ";", "if", "(", "icode", "==", "CODE_FOR_altivec_stvx_v2df", "||", "icode", "==", "CODE_FOR_altivec_stvx_v2di", "||", "icode", "==", "CODE_FOR_altivec_stvx_v4sf", "||", "icode", "==", "CODE_FOR_altivec_stvx_v4si", "||", "icode", "==", "CODE_FOR_altivec_stvx_v8hi", "||", "icode", "==", "CODE_FOR_altivec_stvx_v16qi", ")", "{", "if", "(", "op1", "==", "const0_rtx", ")", "rawaddr", "=", "op2", ";", "else", "{", "op1", "=", "copy_to_mode_reg", "(", "mode1", ",", "op1", ")", ";" ]

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

[ "void", "truncateToken", "(", "unsigned", "NewLen", ")", "{", "assert", "(", "Kind", "==", "OpKind", "::", "Token", "&&", "<STR_LIT>", "Invalid access!", "<STR_LIT>", ")", ";", "assert", "(", "Token", ".", "Length", ">=" ]

[ "let", "opExtentAlign", "=", "<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", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]

[ "return", "emitSelectPseudo", "(", "MI", ",", "BB", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";" ]

[ "llvm_unreachable", "(", "<STR_LIT>", "Unexpected instr type to insert", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":" ]

[ "a", ";" ]

[ "vcreate_u32", "(", "uint64_t", "_", "_", "a", ")", "{", "return", "(", "uint32x2_t", ")", "_", "_" ]

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

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

[ "}" ]

[ "def", "Xrrr", ":", "BaseMulAccum", "<", "isSub", ",", "<NUM_LIT>", ",", "GPR64", ",", "GPR64", ",", "asm", ",", "[", "]", ">", ",", "Sched", "<", "[", "WriteIM64", ",", "ReadIM", ",", "ReadIM", ",", "ReadIMA", "]", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

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

[ "const", "SmallVectorImpl", "<", "Register", ">", "&", "getMustSaveCRs" ]

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

[ "def", "L2_loadrub_pci", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ",", "IntRegs", ":", "$", "Rx32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rx32in", ",", "s4_0Imm", ":", "$", "Ii", ",", "ModRegs", ":", "$", "Mu2", ")", ",", "<STR_LIT>", ",", "tc_e93a3d71", ",", "TypeLD", ">", ",", "Enc_e0a47a", "{", "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", "=", "ByteAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";" ]

[ "<STR_LIT>" ]

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

[ "<FIXS>", "defm", ":", "SBWriteResPair", "WriteBlend", ",", "[", "SBPort15", "]", ",", "<NUM_LIT>", ",", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ">", ";", "<FIXE>" ]

[ "defm", ":", "SBWriteResPair", "WritePMULLD", ",", "[", "SBPort0", "]", ",", "<NUM_LIT>", ",", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ">", ";", "defm", ":", "SBWriteResPair", "WriteShuffle", ",", "[", "SBPort5", "]", ",", "<NUM_LIT>", ">", ";", "defm", ":", "SBWriteResPair", "WriteVarShuffle", ",", "[", "SBPort15", "]", ",", "<NUM_LIT>", ">", ";", "<BUGS>", "defm", ":", "SBWriteResPair", "WriteBlend", ",", "[", "SBPort15", "]", ",", "<NUM_LIT>", ">", ";", "<BUGE>", "defm", ":", "SBWriteResPair", "WriteVarBlend", ",", "[", "SBPort15", "]", ",", "<NUM_LIT>", ",", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ">", ";", "defm", ":", "SBWriteResPair", "WriteMPSAD", ",", "[", "SBPort0", ",", "SBPort15", "]", ",", "<NUM_LIT>", ",", "[", "<NUM_LIT>", ",", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ">", ";", "defm", ":", "SBWriteResPair", "WritePSADBW", ",", "[", "SBPort0", "]", ",", "<NUM_LIT>", ">", ";" ]

[ "static", "int", "mips_arg_partial_bytes", "(", "cumulative_args_t", "cum", ",", "const", "function_arg_info", "&", "arg", ")", "{", "struct", "mips_arg_info", "info", ";", "mips_get_arg_info", "(", "&", "info", ",", "get_cumulative_args", "(", "cum", ")", ",", "arg", ".", "mode", ",", "arg", ".", "type", ",", "arg", ".", "named", ")", ";", "return", "info", ".", "stack_words", ">", "<NUM_LIT>", "?", "info", ".", "reg_words", "*", "UNITS_PER_WORD", ":", "<NUM_LIT>", ";", "}" ]

[ "Implement", "TARGET_ARG_PARTIAL_BYTES", "." ]

[ "<FIXS>", "printAddress", "(", "&", "MAI", ",", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", ",", "<FIXE>", "<FIXS>", "printAddress", "(", "&", "MAI", ",", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", ",", "<FIXE>" ]

[ "void", "SystemZInstPrinter", "::", "printBDAddrOperand", "(", "const", "MCInst", "*", "MI", ",", "int", "OpNum", ",", "raw_ostream", "&", "O", ")", "{", "<BUGS>", "printAddress", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", ",", "<BUGE>", "MI", "->", "getOperand", "(", "OpNum", "+", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ",", "<NUM_LIT>", ",", "O", ")", ";", "}", "void", "SystemZInstPrinter", "::", "printBDXAddrOperand", "(", "const", "MCInst", "*", "MI", ",", "int", "OpNum", ",", "raw_ostream", "&", "O", ")", "{", "<BUGS>", "printAddress", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", ",", "<BUGE>", "MI", "->", "getOperand", "(", "OpNum", "+", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ",", "MI", "->", "getOperand", "(", "OpNum", "+", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "O", ")", ";", "}" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V2SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "V2SF", "[", "(", "match_operand", ":", "V2SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V2SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "CCV2", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]" ]

[ "<FIXS>", "if", "(", "!", "hasFP", "(", "MF", ")", ")", "Offset", "+=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "<FIXE>" ]

[ "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", "+", "MI", ".", "getOperand", "(", "i", "+", "<NUM_LIT>", ")", ".", "getImmedValue", "(", ")", "+", "<NUM_LIT>", ";", "<BUGS>", "if", "(", "!", "hasFP", "(", "MF", ")", "&&", "hasSPAdjust", "(", "MF", ")", ")", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "Offset", "+=", "MFI", "->", "getStackSize", "(", ")", ";", "}", "<BUGE>", "MI", ".", "SetMachineOperandConst", "(", "i", "+", "<NUM_LIT>", ",", "MachineOperand", "::", "MO_SignExtendedImmed", ",", "Offset", ")", ";", "}" ]

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

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

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

[ "class", "BNZ_H_ENC", ":", "MSA_CBRANCH_FMT", "<", "<NUM_LIT>", "," ]

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

[ "(", "define_cpu_unit" ]

[ "<NUM_LIT>", ";" ]

[ "let", "Defs", "=", "[", "LC1", ",", "PC", "]", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isPseudo", "=" ]

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

[ "static", "void", "X86InitSpecialRegSizes", "(", "DCRegisterSema", "::", "RegSizeTy", "&", "RegSizes", ")", "{", "RegSizes", "[", "X86", "::", "IP", "]", "=", "<NUM_LIT>", ";", "RegSizes", "[", "X86", "::", "EIP", "]" ]

[ "AlignOffset", ";" ]

[ "const", "bool", "HasFP", "=", "hasFP", "(", "MF", ")", ";", "const", "X86Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "const", "X86TargetLowering", "&", "TLI", "=", "*", "STI", ".", "getTargetLowering", "(", ")", ";", "const", "unsigned", "MovMIOpc", "=", "Is64Bit", "?", "X86", "::", "MOV64mi32", ":", "X86", "::", "MOV32mi", ";", "const", "uint64_t", "StackProbeSize", "=", "TLI", ".", "getStackProbeSize", "(", "MF", ")", ";", "uint64_t", "CurrentOffset", "=", "<NUM_LIT>", ";", "assert", "(", "AlignOffset", "<", "StackProbeSize", ")", ";", "if", "(", "StackProbeSize", "<", "Offset", "+", "AlignOffset", ")", "{", "uint64_t", "StackAdjustment", "=", "StackProbeSize", "-", "AlignOffset", ";", "BuildStackAdjustment", "(", "MBB", ",", "MBBI", ",", "DL", ",", "-", "StackAdjustment", ",", "false", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "if", "(", "!", "HasFP", "&&", "NeedsDwarfCFI", ")", "{", "BuildCFI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "MCCFIInstruction", "::", "createAdjustCfaOffset", "(", "nullptr", ",", "StackAdjustment", ")", ")", ";", "}", "addRegOffset", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MovMIOpc", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ",", "StackPtr", ",", "false", ",", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "NumFrameExtraProbe", "++", ";", "CurrentOffset", "=", "StackProbeSize", "-" ]

[ "CCRRegClass", ";" ]

[ "break", ";", "}", "case", "'", "Q", "'", ":", "if", "(", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR32_ABCDRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i16", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR16_ABCDRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i1", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR8_ABCD_LRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR64_ABCDRegClass", ")", ";", "break", ";", "case", "'", "r", "'", ":", "case", "'", "l", "'", ":", "if", "(", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i1", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR8RegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i16", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR16RegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "f32", "||", "!", "Subtarget", "->", "is64Bit", "(", ")", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR32RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR64RegClass", ")", ";", "case", "'", "R", "'", ":", "if", "(", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i1", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR8_NOREXRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i16", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR16_NOREXRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i32", "||", "!", "Subtarget", "->", "is64Bit", "(", ")", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR32_NOREXRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR64_NOREXRegClass", ")", ";", "case", "'", "f", "'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", "&&", "!", "isScalarFPTypeInSSEReg", "(", "VT", ")", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "RFP32RegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f64", "&&", "!", "isScalarFPTypeInSSEReg", "(", "VT", ")", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "RFP64RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "RFP80RegClass", ")", ";", "case", "'", "y", "'", ":", "if", "(", "!", "Subtarget", "->", "hasMMX", "(", ")", ")", "break", ";", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "VR64RegClass", ")", ";", "case", "'", "Y", "'", ":", "if", "(", "!", "Subtarget", "->", "hasSSE2", "(", ")", ")", "break", ";", "case", "'", "x", "'", ":", "if", "(", "!", "Subtarget", "->", "hasSSE1", "(", ")", ")", "break", ";", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "break", ";", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "i32", ":", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "FR32RegClass", ")", ";", "case", "MVT", "::", "f64", ":", "case", "MVT", "::", "i64", ":", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "FR64RegClass", ")", ";", "case", "MVT", "::", "v16i8", ":", "case", "MVT", "::", "v8i16", ":", "case", "MVT", "::", "v4i32", ":", "case", "MVT", "::", "v2i64", ":", "case", "MVT", "::", "v4f32", ":", "case", "MVT", "::", "v2f64", ":", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "VR128RegClass", ")", ";", "case", "MVT", "::", "v32i8", ":", "case", "MVT", "::", "v16i16", ":", "case", "MVT", "::", "v8i32", ":", "case", "MVT", "::", "v4i64", ":", "case", "MVT", "::", "v8f32", ":", "case", "MVT", "::", "v4f64", ":", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "VR256RegClass", ")", ";", "case", "MVT", "::", "v8f64", ":", "case", "MVT", "::", "v16f32", ":", "case", "MVT", "::", "v16i32", ":", "case", "MVT", "::", "v8i64", ":", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "VR512RegClass", ")", ";", "}", "break", ";", "}", "}", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "Res", ";", "Res", "=", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "if", "(", "!", "Res", ".", "second", ")", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "<NUM_LIT>", "&&", "Constraint", "[", "<NUM_LIT>", "]", "==", "'", "{", "'", "&&", "tolower", "(", "Constraint", "[", "<NUM_LIT>", "]", ")", "==", "'", "s", "'", "&&", "tolower", "(", "Constraint", "[", "<NUM_LIT>", "]", ")", "==", "'", "t", "'", "&&", "Constraint", "[", "<NUM_LIT>", "]", "==", "'", "(", "'", "&&", "(", "Constraint", "[", "<NUM_LIT>", "]", ">=", "'", "<NUM_LIT>", "'", "&&", "Constraint", "[", "<NUM_LIT>", "]", "<=", "'", "<NUM_LIT>", "'", ")", "&&", "Constraint", "[", "<NUM_LIT>", "]", "==", "'", ")", "'", "&&", "Constraint", "[", "<NUM_LIT>", "]", "==", "'", "}", "'", ")", "{", "Res", ".", "first", "=", "X86", "::", "FP0", "+", "Constraint", "[", "<NUM_LIT>", "]", "-", "'", "<NUM_LIT>", "'", ";", "Res", ".", "second", "=", "&", "X86", "::", "RFP80RegClass", ";", "return", "Res", ";", "}", "if", "(", "StringRef", "(", "<STR_LIT>", "{st}", "<STR_LIT>", ")", ".", "equals_lower", "(", "Constraint", ")", ")", "{", "Res", ".", "first", "=", "X86", "::", "FP0", ";", "Res", ".", "second", "=", "&", "X86", "::", "RFP80RegClass", ";", "return", "Res", ";", "}", "if", "(", "StringRef", "(", "<STR_LIT>", "{flags}", "<STR_LIT>", ")", ".", "equals_lower", "(", "Constraint", ")", ")", "{", "Res", ".", "first", "=", "X86", "::", "EFLAGS", ";", "Res", ".", "second", "=", "&", "X86", "::" ]

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

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

[ "<STR_LIT>", ")" ]

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

[ "<FIXS>", "public", ":", "<FIXE>", "<FIXS>", "SIFixSGPRCopies", "(", ")", ":", "MachineFunctionPass", "(", "ID", ")", "{", "}", "<FIXE>" ]

[ "namespace", "{", "class", "SIFixSGPRCopies", ":", "public", "MachineFunctionPass", "{", "<BUGS>", "private", ":", "<BUGE>", "static", "char", "ID", ";", "<BUGS>", "public", ":", "SIFixSGPRCopies", "(", "TargetMachine", "&", "tm", ")", ":", "MachineFunctionPass", "(", "ID", ")", "{", "}", "<BUGE>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", ";" ]

[ "}" ]

[ "VT", "=", "ST", "->", "getMemoryVT", "(", ")", ";", "if", "(", "ST", "->", "getValue", "(", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "i64", "&&", "ST", "->", "isTruncatingStore", "(", ")", ")", "return", "false", ";", "}", "else", "{", "return", "false", ";", "}", "bool", "IsInc", "=", "false", ";", "bool", "isLegal", "=", "getIndexedAddressParts", "(", "Op", ",", "VT", ",", "Base", ",", "Offset", ",", "IsInc", ",", "DAG", ")", ";", "if", "(", "isLegal", ")", "{", "auto", "&", "HII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "int32_t", "OffsetVal", "=", "cast", "<", "ConstantSDNode", ">", "(", "Offset", ".", "getNode", "(", ")", ")", "->", "getSExtValue", "(", ")", ";", "if", "(", "HII", ".", "isValidAutoIncImm", "(", "VT", ",", "OffsetVal", ")", ")", "{", "AM", "=", "IsInc", "?", "ISD", "::", "POST_INC", ":", "ISD", "::", "POST_DEC", ";", "return", "true", ";", "}", "}", "return", "false", ";" ]

[ "Rd", ";" ]

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

[ "}" ]

[ "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ExternalSymbol", ":", "return", "LowerExternalSymbol", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "LowerSIGN_EXTEND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "unimplemented operand", "<STR_LIT>", ")", ";" ]

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

[ "MVT", "ScalarVT", "=", "VT", ".", "getScalarType", "(", ")", ";", "SDValue", "Mask", "=", "N", "->", "getMask", "(", ")", ";", "SDLoc", "dl", "(", "Op", ")", ";", "assert", "(", "(", "!", "N", "->", "isExpandingLoad", "(", ")", "||", "Subtarget", ".", "hasAVX512", "(", ")", ")", "&&", "<STR_LIT>", "Expanding masked load is supported on AVX-512 target only!", "<STR_LIT>", ")", ";", "assert", "(", "(", "!", "N", "->", "isExpandingLoad", "(", ")", "||", "ScalarVT", ".", "getSizeInBits", "(", ")", ">=", "<NUM_LIT>", ")", "&&", "<STR_LIT>", "Expanding masked load is supported for 32 and 64-bit types only!", "<STR_LIT>", ")", ";", "assert", "(", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "!", "Subtarget", ".", "hasVLX", "(", ")", "&&", "!", "VT", ".", "is512BitVector", "(", ")", "&&", "<STR_LIT>", "Cannot lower masked load op.", "<STR_LIT>", ")", ";", "assert", "(", "(", "ScalarVT", ".", "getSizeInBits", "(", ")", ">=", "<NUM_LIT>", "||", "(", "Subtarget", ".", "hasBWI", "(", ")", "&&", "(", "ScalarVT", "==", "MVT", "::", "i8", "||", "ScalarVT", "==", "MVT", "::", "i16", ")", ")", ")", "&&", "<STR_LIT>", "Unsupported masked load op.", "<STR_LIT>", ")", ";", "unsigned", "NumEltsInWideVec", "=", "<NUM_LIT>", "/", "VT", ".", "getScalarSizeInBits", "(", ")", ";", "MVT", "WideDataVT", "=", "MVT", "::", "getVectorVT", "(", "ScalarVT", ",", "NumEltsInWideVec", ")", ";", "SDValue", "Src0", "=", "N", "->" ]

[ "<NUM_LIT>", ")" ]

[ "rtx", "dest", "=", "operands", "[", "<NUM_LIT>", "]", "rtx", "src", "=", "operands", "[", "<NUM_LIT>", "]", "rtx", "tmp_hi", "=", "simplify_gen_subreg", "(", "DFmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "IFmode", ",", "<NUM_LIT>", ")", "rtx", "tmp_lo", "=", "simplify_gen_subreg", "(", "DFmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "IFmode", "," ]

[ "}" ]

[ "struct", "stat", "st", ";", "if", "(", "stat", "(", "name", ",", "&", "st", ")", "<", "<NUM_LIT>", "||", "S_ISDIR", "(", "st", ".", "st_mode", ")", ")", "return", "-", "<NUM_LIT>", ";" ]

[ "case", "Intrinsic", "::", "mips_ctcmsa", ":", "{" ]

[ "Result", "=", "CurDAG", "->", "getMachineNode", "(", "Mips", "::", "BuildPairF64_64", ",", "DL", ",", "MVT", "::", "f64", ",", "Zero", ",", "Zero", ")", ";", "}", "else", "{", "SDValue", "Zero", "=", "CurDAG", "->", "getCopyFromReg", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "DL", ",", "Mips", "::", "ZERO", ",", "MVT", "::", "i32", ")", ";", "Result", "=", "CurDAG", "->", "getMachineNode", "(", "Mips", "::", "BuildPairF64", ",", "DL", ",", "MVT", "::", "f64", ",", "Zero", ",", "Zero", ")", ";", "}", "return", "std", "::", "make_pair", "(", "true", ",", "Result", ")", ";", "}", "break", ";", "}", "case", "ISD", "::", "Constant", ":", "{", "const", "ConstantSDNode", "*", "CN", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Node", ")", ";", "unsigned", "Size", "=", "CN", "->", "getValueSizeInBits", "(", "<NUM_LIT>", ")", ";", "if", "(", "Size", "==", "<NUM_LIT>", ")", "break", ";", "MipsAnalyzeImmediate", "AnalyzeImm", ";", "int64_t", "Imm", "=", "CN", "->", "getSExtValue", "(", ")", ";", "const", "MipsAnalyzeImmediate", "::", "InstSeq", "&", "Seq", "=", "AnalyzeImm", ".", "Analyze", "(", "Imm", ",", "Size", ",", "false", ")", ";", "MipsAnalyzeImmediate", "::", "InstSeq", "::", "const_iterator", "Inst", "=", "Seq", ".", "begin", "(", ")", ";", "SDLoc", "DL", "(", "CN", ")", ";", "SDNode", "*", "RegOpnd", ";", "SDValue", "ImmOpnd", "=", "CurDAG", "->", "getTargetConstant", "(", "SignExtend64", "<", "<NUM_LIT>", ">", "(", "Inst", "->", "ImmOpnd", ")", ",", "DL", ",", "MVT", "::", "i64", ")", ";", "if", "(", "Inst", "->", "Opc", "==", "Mips", "::", "LUi64", ")", "RegOpnd", "=", "CurDAG", "->", "getMachineNode", "(", "Inst", "->", "Opc", ",", "DL", ",", "MVT", "::", "i64", ",", "ImmOpnd", ")", ";", "else", "RegOpnd", "=", "CurDAG", "->", "getMachineNode", "(", "Inst", "->", "Opc", ",", "DL", ",", "MVT", "::", "i64", ",", "CurDAG", "->", "getRegister", "(", "Mips", "::", "ZERO_64", ",", "MVT", "::", "i64", ")", ",", "ImmOpnd", ")", ";", "for", "(", "++", "Inst", ";", "Inst", "!=", "Seq", ".", "end", "(", ")", ";", "++", "Inst", ")", "{", "ImmOpnd", "=", "CurDAG", "->", "getTargetConstant", "(", "SignExtend64", "<", "<NUM_LIT>", ">", "(", "Inst", "->", "ImmOpnd", ")", ",", "DL", ",", "MVT", "::", "i64", ")", ";", "RegOpnd", "=", "CurDAG", "->", "getMachineNode", "(", "Inst", "->", "Opc", ",", "DL", ",", "MVT", "::", "i64", ",", "SDValue", "(", "RegOpnd", ",", "<NUM_LIT>", ")", ",", "ImmOpnd", ")", ";", "}", "return", "std", "::", "make_pair", "(", "true", ",", "RegOpnd", ")", ";", "}", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "{", "switch", "(", "cast", "<", "ConstantSDNode", ">", "(", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Intrinsic", "::", "mips_cfcmsa", ":", "{", "SDValue", "ChainIn", "=", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "RegIdx", "=", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Reg", "=", "CurDAG", "->", "getCopyFromReg", "(", "ChainIn", ",", "DL", ",", "getMSACtrlReg", "(", "RegIdx", ")", ",", "MVT", "::", "i32", ")", ";", "return", "std", "::", "make_pair", "(", "true", ",", "Reg", ".", "getNode", "(", ")", ")", ";", "}", "}", "break", ";", "}", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "{", "switch", "(", "cast", "<", "ConstantSDNode", ">", "(", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Intrinsic", "::", "mips_move_v", ":", "return", "std", "::", "make_pair", "(", "true", ",", "CurDAG", "->", "getMachineNode", "(", "Mips", "::", "MOVE_V", ",", "DL", ",", "Node", "->", "getValueType", "(", "<NUM_LIT>", ")", ",", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", ";", "}", "break", ";", "}", "case", "ISD", "::", "INTRINSIC_VOID", ":", "{", "switch", "(", "cast", "<", "ConstantSDNode", ">", "(", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ")", "{", "default", ":", "break", ";" ]

[ "unsigned", "AArch64InstrInfo", "::", "getLoadStoreImmIdx", "(", "unsigned", "Opc", ")", "{", "switch", "(", "Opc", ")", "{", "default", ":", "return", "<NUM_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<NUM_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<NUM_LIT>", ";", "}", "}" ]

[ "Returns", "the", "index", "for", "the", "immediate", "for", "a", "given", "instruction", "." ]

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

[ "reg_iterator", "localVarRegEnd", "(" ]

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

[ "return", "_", "_", "builtin_mve_vqsubq_n_sv4si", "(", "_", "_" ]

[ ")", ";" ]

[ "static", "void", "rs6000_elf_asm_out_destructor", "(", "rtx", "symbol", ",", "int", "priority", ")", "{", "const", "char", "*", "section", "=", "<STR_LIT>", ".dtors", "<STR_LIT>", ";", "char", "buf", "[", "<NUM_LIT>", "]", ";", "if", "(", "priority", "!=", "DEFAULT_INIT_PRIORITY", ")", "{", "sprintf", "(", "buf", ",", "<STR_LIT>", ".dtors.%.5u", "<STR_LIT>", ",", "MAX_INIT_PRIORITY", "-", "priority", ")", ";", "section", "=", "buf", ";", "}", "switch_to_section", "(", "get_section", "(", "section", ",", "SECTION_WRITE", ",", "NULL", ")", ")", ";", "assemble_align", "(", "POINTER_SIZE" ]

[ "void", "SITargetLowering", "::", "AdjustInstrPostInstrSelection", "(", "MachineInstr", "*", "MI", ",", "SDNode", "*", "Node", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "getTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ")", ";", "if", "(", "TII", "->", "isMIMG", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "{", "unsigned", "VReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "Writemask", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "unsigned", "BitsSet", "=", "<NUM_LIT>", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "++", "i", ")", "BitsSet", "+=", "Writemask", "&", "(", "<NUM_LIT>", "<<", "i", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "const", "TargetRegisterClass", "*", "RC", ";", "switch", "(", "BitsSet", ")", "{", "default", ":", "return", ";", "case", "<NUM_LIT>", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_32RegClass", ";", "break", ";", "case", "<NUM_LIT>", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_64RegClass", ";", "break", ";", "case", "<NUM_LIT>", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_96RegClass", ";", "break", ";", "}", "unsigned", "NewOpcode", "=", "TII", "->", "getMaskedMIMGOp", "(", "MI", "->", "getOpcode", "(", ")", ",", "BitsSet", ")", ";", "MI", "->", "setDesc", "(", "TII", "->", "get", "(", "NewOpcode", ")", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "setRegClass", "(", "VReg", ",", "RC", ")", ";", "return", ";", "}", "int", "NoRetAtomicOp", "=", "AMDGPU", "::", "getAtomicNoRetOp", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "if", "(", "NoRetAtomicOp", "!=", "-", "<NUM_LIT>", ")", "{", "if", "(", "!", "Node", "->", "hasAnyUseOfValue", "(", "<NUM_LIT>", ")", ")", "{", "MI", "->", "setDesc", "(", "TII", "->", "get", "(", "NoRetAtomicOp", ")", ")", ";", "MI", "->", "RemoveOperand", "(", "<NUM_LIT>", ")", ";", "}", "return", ";", "}", "}" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'hasPostISelHook", "'", "flag", "." ]