Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "<FIXS>", "OpSize16", ",", "TB", ";", "<FIXE>", "<FIXS>", "OpSize32", ",", "TB", ";", "<FIXE>" ]

[ "let", "mayLoad", "=", "<NUM_LIT>", ",", "mayStore", "=", "<NUM_LIT>", ",", "SchedRW", "=", "[", "WriteALULd", ",", "WriteRMW", "]", "in", "{", "def", "BTC16mi8", ":", "Ii8", "<NUM_LIT>", ",", "MRM7m", ",", "(", "outs", ")", ",", "(", "ins", "i16mem", ":", "$", "src1", ",", "i16i8imm", ":", "$", "src2", ")", ",", "<STR_LIT>", ",", "[", "]", ",", "IIC_BTX_MI", ">", ",", "<BUGS>", "OpSize", ",", "TB", ";", "<BUGE>", "def", "BTC32mi8", ":", "Ii8", "<NUM_LIT>", ",", "MRM7m", ",", "(", "outs", ")", ",", "(", "ins", "i32mem", ":", "$", "src1", ",", "i32i8imm", ":", "$", "src2", ")", ",", "<STR_LIT>", ",", "[", "]", ",", "IIC_BTX_MI", ">", ",", "<BUGS>", "OpSize16", ",", "TB", ";", "<BUGE>", "def", "BTC64mi8", ":", "RIi8", "<NUM_LIT>", ",", "MRM7m", ",", "(", "outs", ")", ",", "(", "ins", "i64mem", ":", "$", "src1", ",", "i64i8imm", ":", "$", "src2", ")", ",", "<STR_LIT>", ",", "[", "]", ",", "IIC_BTX_MI", ">", ",", "TB", ";", "}" ]

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

[ "def", "A2_vminh", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rtt32", ",", "DoubleRegs", ":", "$", "Rss32", ")", ",", "<STR_LIT>", ",", "tc_779080bf", ",", "TypeALU64", ">", ",", "Enc_ea23e4", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "unsigned", "Count", "=", "<NUM_LIT>", ";", "do", "{", "--", "MBBI", ";", "<FIXE>", "<FIXS>", "if", "(", "!", "MI", "->", "isDebugValue", "(", ")", ")", "++", "Count", ";", "<FIXE>" ]

[ "ModifiedRegs", ".", "reset", "(", ")", ";", "UsedRegs", ".", "reset", "(", ")", ";", "<BUGS>", "--", "MBBI", ";", "for", "(", "unsigned", "Count", "=", "<NUM_LIT>", ";", "MBBI", "!=", "B", "&&", "Count", "Limit", ";", "--", "MBBI", ")", "{", "<BUGE>", "MachineInstr", "*", "MI", "=", "MBBI", ";", "<BUGS>", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "continue", ";", "++", "Count", ";", "<BUGE>", "if", "(", "isMatchingUpdateInsn", "(", "I", ",", "MI", ",", "BaseReg", ",", "Offset", ")", ")" ]

[ "return", "(", "SignificantDstMask", "&", "SignificantBitsToBeInserted", ")", "==", "<NUM_LIT>", "&&", "(", "SignificantDstMask", "|", "SignificantBitsToBeInserted", ")", ".", "isAllOnesValue", "(", ")", ";" ]

[ "static", "bool", "isBitfieldDstMask", "(", "uint64_t", "DstMask", ",", "APInt", "BitsToBeInserted", ",", "unsigned", "NumberOfIgnoredHighBits", ",", "EVT", "VT", ")", "{", "assert", "(", "(", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "i64", ")", "&&", "<STR_LIT>", "i32 or i64 mask type expected!", "<STR_LIT>", ")", ";", "unsigned", "BitWidth", "=", "VT", ".", "getSizeInBits", "(", ")", "-", "NumberOfIgnoredHighBits", ";", "APInt", "SignificantDstMask", "=", "APInt", "(", "BitWidth", ",", "DstMask", ")", ";", "APInt", "SignificantBitsToBeInserted", "=", "BitsToBeInserted", ".", "zextOrTrunc", "(", "BitWidth", ")", ";" ]

[ ")", "{" ]

[ "MadeChange", "=", "true", ";", "}", "break", ";", "case", "AMDGPU", "::", "SI_EARLY_TERMINATE_SCC0", ":", "EarlyTermInstrs", ".", "push_back", "(", "&", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_RETURN_TO_EPILOG", ":", "EpilogInstrs", ".", "push_back", "(", "&", "MI", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}", "}", "if", "(", "!", "EarlyTermInstrs", ".", "empty", "(", ")", ")", "{", "MachineBasicBlock", "*", "EarlyExitBlock", "=", "MF", ".", "CreateMachineBasicBlock", "(", ")", ";", "DebugLoc", "DL", ";", "MF", ".", "insert", "(", "MF", ".", "end", "(", ")", ",", "EarlyExitBlock", ")", ";", "BuildMI", "(", "*", "EarlyExitBlock", ",", "EarlyExitBlock", "->", "end", "(", ")", ",", "DL", ",", "TII", "->", "get", "(", "MovOpc", ")", ",", "ExecReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "generateEndPgm", "(", "*", "EarlyExitBlock", ",", "EarlyExitBlock", "->", "end", "(", ")", ",", "DL", ",", "TII", ",", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AMDGPU_PS", ")", ";", "for", "(", "MachineInstr", "*", "Instr", ":", "EarlyTermInstrs", ")", "{", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "!=", "CallingConv", "::", "AMDGPU_GS", ")", "earlyTerm", "(", "*", "Instr", ",", "EarlyExitBlock", ")", ";", "Instr", "->", "eraseFromParent", "(", ")", ";", "}", "EarlyTermInstrs", ".", "clear", "(", ")", ";", "MadeChange", "=", "true", ";", "}", "if", "(", "!", "EpilogInstrs", ".", "empty", "(", ")" ]

[ "<FIXS>", "return", "<STR_LIT>", "<FIXE>", "<FIXS>", "}", "[", "(", "set", "(", "attr", "<STR_LIT>", ")", "(", "if_then_else", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", ")", ")", "]", ")", "<FIXE>" ]

[ "<STR_LIT>", "{", "if", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "=", "=", "REG", ")", "<BUGS>", "{", "CC_STATUS_INITreturn", "<STR_LIT>", "}", "<BUGE>", "if", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "=", "=", "MEM", ")", "operands", "[", "<NUM_LIT>", "]", "=", "adjust_address", "(", "operands", "[", "<NUM_LIT>", "]", ",", "QImode", ",", "<NUM_LIT>", ")", "return", "<STR_LIT>", "<BUGS>", "}", ")", "<BUGE>", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "if", "(", "REG_P", "(", "low_dest", ")", "&&", "reg_overlap_mentioned_p", "(", "low_dest", ",", "src", ")", ")", "{" ]

[ "else", "if", "(", "!", "TARGET_64BIT", "&&", "GET_MODE", "(", "dest", ")", "==", "DFmode", ")", "emit_insn", "(", "gen_move_doubleword_fprdf", "(", "dest", ",", "src", ")", ")", ";", "else", "if", "(", "!", "TARGET_64BIT", "&&", "GET_MODE", "(", "dest", ")", "==", "V2SFmode", ")", "emit_insn", "(", "gen_move_doubleword_fprv2sf", "(", "dest", ",", "src", ")", ")", ";", "else", "if", "(", "!", "TARGET_64BIT", "&&", "GET_MODE", "(", "dest", ")", "==", "V2SImode", ")", "emit_insn", "(", "gen_move_doubleword_fprv2si", "(", "dest", ",", "src", ")", ")", ";", "else", "if", "(", "!", "TARGET_64BIT", "&&", "GET_MODE", "(", "dest", ")", "==", "V4HImode", ")", "emit_insn", "(", "gen_move_doubleword_fprv4hi", "(", "dest", ",", "src", ")", ")", ";", "else", "if", "(", "!", "TARGET_64BIT", "&&", "GET_MODE", "(", "dest", ")", "==", "V8QImode", ")", "emit_insn", "(", "gen_move_doubleword_fprv8qi", "(", "dest", ",", "src", ")", ")", ";", "else", "if", "(", "TARGET_64BIT", "&&", "GET_MODE", "(", "dest", ")", "==", "TFmode", ")", "emit_insn", "(", "gen_move_doubleword_fprtf", "(", "dest", ",", "src", ")", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "REG_P", "(", "dest", ")", "&&", "REGNO", "(", "dest", ")", "==", "MD_REG_FIRST", ")", "{", "low_dest", "=", "mips_subword", "(", "dest", ",", "false", ")", ";", "mips_emit_move", "(", "low_dest", ",", "mips_subword", "(", "src", ",", "false", ")", ")", ";", "if", "(", "TARGET_64BIT", ")", "emit_insn", "(", "gen_mthidi_ti", "(", "dest", ",", "mips_subword", "(", "src", ",", "true", ")", ",", "low_dest", ")", ")", ";", "else", "emit_insn", "(", "gen_mthisi_di", "(", "dest", ",", "mips_subword", "(", "src", ",", "true", ")", ",", "low_dest", ")", ")", ";", "}", "else", "if", "(", "REG_P", "(", "src", ")", "&&", "REGNO", "(", "src", ")", "==", "MD_REG_FIRST", ")", "{", "mips_emit_move", "(", "mips_subword", "(", "dest", ",", "false", ")", ",", "mips_subword", "(", "src", ",", "false", ")", ")", ";", "if", "(", "TARGET_64BIT", ")", "emit_insn", "(", "gen_mfhidi_ti", "(", "mips_subword", "(", "dest", ",", "true", ")", ",", "src", ")", ")", ";", "else", "emit_insn", "(", "gen_mfhisi_di", "(", "mips_subword", "(", "dest", ",", "true", ")", ",", "src", ")", ")", ";", "}", "else", "{", "low_dest", "=", "mips_subword", "(", "dest", ",", "false", ")", ";" ]

[ "unsigned", "Shamt", "=", "CN", "->", "getZExtValue", "(", ")", ";" ]

[ "static", "SDValue", "PerformORCombine", "(", "SDNode", "*", "N", ",", "SelectionDAG", "&", "DAG", ",", "TargetLowering", "::", "DAGCombinerInfo", "&", "DCI", ",", "const", "MipsSubtarget", "*", "Subtarget", ")", "{", "if", "(", "DCI", ".", "isBeforeLegalizeOps", "(", ")", "||", "!", "Subtarget", "->", "hasMips32r2", "(", ")", ")", "return", "SDValue", "(", ")", ";", "SDValue", "And0", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "And1", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "uint64_t", "SMPos0", ",", "SMSize0", ",", "SMPos1", ",", "SMSize1", ";", "ConstantSDNode", "*", "CN", ";", "if", "(", "And0", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "AND", ")", "return", "SDValue", "(", ")", ";", "if", "(", "!", "(", "CN", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "And0", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "||", "!", "IsShiftedMask", "(", "~", "CN", "->", "getSExtValue", "(", ")", ",", "SMPos0", ",", "SMSize0", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "And1", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "AND", ")", "return", "SDValue", "(", ")", ";", "if", "(", "!", "(", "CN", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "And1", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "||", "!", "IsShiftedMask", "(", "CN", "->", "getZExtValue", "(", ")", ",", "SMPos1", ",", "SMSize1", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "SMPos0", "!=", "SMPos1", "||", "SMSize0", "!=", "SMSize1", ")", "return", "SDValue", "(", ")", ";", "SDValue", "Shl", "=", "And1", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Shl", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "SHL", ")", "return", "SDValue", "(", ")", ";", "if", "(", "!", "(", "CN", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Shl", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", ")", "return", "SDValue", "(", ")", ";" ]

[ "<STR_LIT>", ")" ]

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

[ "<NUM_LIT>", ";" ]

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

[ "}" ]

[ "static", "_", "_", "inline", "_", "_", "m64", "_", "mm_qmulmr_pi16", "(", "_", "_", "m64", "a", ",", "_", "_", "m64", "b", ")", "{", "return", "(", "_", "_", "m64", ")", "_", "_", "builtin_arm_wqmulmr", "(", "(", "_", "_", "v4hi", ")", "a", ",", "(", "_", "_", "v4hi", ")", "b", ")", ";" ]

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

[ "if", "(", "ExtraCode", ")", "{", "return", "true", ";", "}", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "assert", "(", "MO", ".", "isReg", "(", ")", "&&", "<STR_LIT>", "unexpected inline asm memory operand", "<STR_LIT>", ")", ";", "O", "<<", "Offset", "<<", "<STR_LIT>", "($", "<STR_LIT>", "<<", "Cpu0InstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", "<<", "<STR_LIT>", ")", "<STR_LIT>", ";" ]

[ ")" ]

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

[ "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "R", ";", "++", "i", ")", "pattern", "=", "ror", "(", "pattern", ",", "size", ")", ";" ]

[ "assert", "(", "len", ">=", "<NUM_LIT>", "&&", "<STR_LIT>", "undefined logical immediate encoding", "<STR_LIT>", ")", ";", "unsigned", "size", "=", "(", "<NUM_LIT>", "<<", "len", ")", ";", "unsigned", "R", "=", "immr", "&", "(", "size", "-", "<NUM_LIT>", ")", ";", "unsigned", "S", "=", "imms", "&", "(", "size", "-", "<NUM_LIT>", ")", ";", "assert", "(", "S", "!=", "size", "-", "<NUM_LIT>", "&&", "<STR_LIT>", "undefined logical immediate encoding", "<STR_LIT>", ")", ";", "uint64_t", "pattern", "=", "(", "<NUM_LIT>", "ULL", "<<", "(", "S", "+", "<NUM_LIT>", ")", ")", "-", "<NUM_LIT>", ";" ]

[ "$", "src0_modifiers", ",", "Src0RC", ":", "$", "src0", ",", "Src1Mod", ":", "$", "src1_modifiers", ",", "Src1RC", ":", "$", "src1", ",", "Src2Mod", ":", "$", "src2_modifiers", ",", "Src2RC", ":", "$", "src2", ",", "clampmod", ":", "$", "clamp", ",", "op_sel", ":", "$", "op_sel", ")", ",", "(", "ins", "Src0Mod", ":", "$", "src0_modifiers", ",", "Src0RC", ":", "$", "src0", ",", "Src1Mod", ":", "$", "src1_modifiers", ",", "Src1RC", ":", "$", "src1", ",", "Src2Mod", ":", "$", "src2_modifiers", ",", "Src2RC", ":", "$", "src2", ",", "op_sel", ":", "$", "op_sel", ")", ")", ")", ";" ]

[ "class", "getInsVOP3OpSel", "<", "RegisterOperand", "Src0RC", ",", "RegisterOperand", "Src1RC", ",", "RegisterOperand", "Src2RC", ",", "int", "NumSrcArgs", ",", "bit", "HasClamp", ",", "Operand", "Src0Mod", ",", "Operand", "Src1Mod", ",", "Operand", "Src2Mod", ">", "{", "dag", "ret", "=", "!", "if", "(", "!", "eq", "(", "NumSrcArgs", ",", "<NUM_LIT>", ")", ",", "!", "if", "(", "HasClamp", ",", "(", "ins", "Src0Mod", ":", "$", "src0_modifiers", ",", "Src0RC", ":", "$", "src0", ",", "Src1Mod", ":", "$", "src1_modifiers", ",", "Src1RC", ":", "$", "src1", ",", "clampmod", ":", "$", "clamp", ",", "op_sel", ":", "$", "op_sel", ")", ",", "(", "ins", "Src0Mod", ":", "$", "src0_modifiers", ",", "Src0RC", ":", "$", "src0", ",", "Src1Mod", ":", "$", "src1_modifiers", ",", "Src1RC", ":", "$", "src1", ",", "op_sel", ":", "$", "op_sel", ")", ")", ",", "!", "if", "(", "HasClamp", ",", "(", "ins", "Src0Mod", ":" ]

[ "str", ")", "{" ]

[ "static", "hashval_t", "hash", "(", "const", "char", "*" ]

[ "<STR_LIT>", ")" ]

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

[ "}" ]

[ "class", "Enc_c1d806", ":", "OpcodeHexagon", "{", "bits", "<", "<NUM_LIT>", ">", "Vu32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Vu32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Vv32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Vv32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Vd32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Vd32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Qe4", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Qe4", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "}" ]

[ "def", "KryoWrite_10cyc_XA_Y_noRSV_43ln", ":", "SchedWriteRes", "<", "[", "KryoUnitXA", ",", "KryoUnitY", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "SUnit", "*", "SU", "=", "nullptr", ";", "<FIXE>", "<FIXS>", "int", "SCost", "=", "<NUM_LIT>", ";", "<FIXE>", "<FIXS>", "SchedCandidate", "(", ")", "=", "default", ";", "<FIXE>" ]

[ "class", "ConvergingVLIWScheduler", ":", "public", "MachineSchedStrategy", "{", "struct", "SchedCandidate", "{", "<BUGS>", "SUnit", "*", "SU", ";", "<BUGE>", "RegPressureDelta", "RPDelta", ";", "<BUGS>", "int", "SCost", ";", "<BUGE>", "<BUGS>", "SchedCandidate", "(", ")", ":", "SU", "(", "nullptr", ")", ",", "SCost", "(", "<NUM_LIT>", ")", "{", "}", "<BUGE>", "}", ";", "enum", "CandResult", "{" ]

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

[ "def", "ICXWriteResGroup58", ":", "SchedWriteRes", "<", "[", "ICXPort23", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=", "<NUM_LIT>", ";" ]

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

[ "unsigned", "DivOpc", ";", "bool", "is64bit", "=", "(", "DestVT", "==", "MVT", "::", "i64", ")", ";", "switch", "(", "ISDOpcode", ")", "{", "default", ":", "return", "false", ";", "case", "ISD", "::", "SREM", ":", "DivOpc", "=", "is64bit", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "UREM", ":", "DivOpc", "=", "is64bit", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "}", "unsigned", "MSubOpc", "=", "is64bit", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "unsigned", "Src0Reg", "=", "getRegForValue", "(", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "Src0Reg", ")", "return", "false", ";", "bool", "Src0IsKill", "=", "hasTrivialKill", "(", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "unsigned", "Src1Reg", "=", "getRegForValue", "(", "I", "->", "getOperand", "(", "<NUM_LIT>" ]

[ "copy_rtx", "(", "operands", "[", "<NUM_LIT>", "]", ")", "," ]

[ "(", "set", "(", "reg", "FLAGS_REG", ")", "(", "compare", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>", "[", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", ")", "]", "{", "operands", "[", "<NUM_LIT>", "]", "=", "SET_DEST", "(", "PATTERN", "(", "peep2_next_insn", "(", "<NUM_LIT>", ")", ")", ")", "operands", "[", "<NUM_LIT>", "]", "=", "gen_rtx_fmt_ee", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ",", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "," ]

[ "_", "W", ",", "(", "_", "_", "mmask16", ")", "_", "_", "U", ")", ";" ]

[ "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_prorvd512_mask", "(", "(", "_", "_", "v16si", ")", "_", "_", "A", ",", "(", "_", "_", "v16si", ")", "_", "_", "B", ",", "(", "_", "_", "v16si", ")", "_" ]

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

[ "MachineBasicBlock", "*", "B", "=", "N", "->", "getBlock", "(", ")", ";", "std", "::", "vector", "<", "MachineInstr", "*", ">", "Instrs", ";", "for", "(", "auto", "I", "=", "B", "->", "rbegin", "(", ")", ",", "E", "=", "B", "->", "rend", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Instrs", ".", "push_back", "(", "&", "*", "I", ")", ";", "for", "(", "auto", "I", "=", "Instrs", ".", "begin", "(", ")", ",", "E", "=", "Instrs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineInstr", "*", "MI", "=", "*", "I", ";", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "TargetOpcode", "::", "LIFETIME_START", "||", "Opc", "==", "TargetOpcode", "::", "LIFETIME_END", ")", "continue", ";", "bool", "Store", "=", "false", ";", "if", "(", "MI", "->", "isInlineAsm", "(", ")", "||", "!", "MI", "->", "isSafeToMove", "(", "nullptr", ",", "Store", ")", ")", "continue", ";", "bool", "AllDead", "=", "true", ";", "SmallVector", "<", "unsigned", "," ]

[ "<FIXS>", "FRP", "(", "emit_move_insn", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "stack_pointer_rtx", ",", "-", "frame_size", ")", ")", ")", ";", "<FIXE>" ]

[ "if", "(", "frame_size", "!=", "<NUM_LIT>", ")", "{", "<BUGS>", "emit_move_insn", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "stack_pointer_rtx", ",", "-", "frame_size", ")", ")", ";", "<BUGE>", "}", "}", "else" ]

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

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

[ "<FIXS>", "(", "v2i32", "(", "ARMvorrImm", "DPR", ":", "$", "src", ",", "timm", ":", "$", "SIMM", ")", ")", ")", "]", ">", "{", "<FIXE>" ]

[ "IIC_VMOVImm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "DPR", ":", "$", "Vd", ",", "<BUGS>", "(", "v2i32", "(", "NEONvorrImm", "DPR", ":", "$", "src", ",", "timm", ":", "$", "SIMM", ")", ")", ")", "]", ">", "{", "<BUGE>", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "SIMM", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "}" ]

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

[ "if", "(", "!", "ArrayIndexTypeId", ")", "{", "auto", "TypeEntry", "=", "llvm", "::", "make_unique", "<", "BTFTypeInt", ">", "(", "dwarf", "::", "DW_ATE_unsigned", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<STR_LIT>", "__ARRAY_SIZE_TYPE__", "<STR_LIT>", ")", ";", "ArrayIndexTypeId", "=", "addType", "(", "std", "::", "move", "(", "TypeEntry", ")", ")", ";", "}", "visitTypeEntry", "(", "CTy", "->", "getBaseType", "(" ]

[ ")", "{" ]

[ "unsigned", "AMDGPUInliner", "::", "getInlineThreshold", "(", "CallBase", "&", "CB", ")", "const", "{", "int", "Thres", "=", "Params", ".", "DefaultThreshold", ";", "Function", "*", "Caller", "=", "CB", ".", "getCaller", "(", ")", ";", "Function", "*", "Callee", "=", "CB", ".", "getCalledFunction", "(", ")", ";", "bool", "InlineHint", "=", "Callee", "&&", "!", "Callee", "->", "isDeclaration", "(", ")", "&&", "Callee", "->", "hasFnAttribute", "(", "Attribute", "::", "InlineHint", ")", ";", "if", "(", "InlineHint", "&&", "Params", ".", "HintThreshold", "&&", "Params", ".", "HintThreshold", ">", "Thres", "&&", "!", "Caller", "->", "hasFnAttribute", "(", "Attribute", "::", "MinSize", ")", ")", "Thres", "=", "Params", ".", "HintThreshold", ".", "getValue", "(", ")", "*", "TTIWP", "->", "getTTI", "(", "*", "Callee", ")", ".", "getInliningThresholdMultiplier", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "Caller", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "if", "(", "!", "Callee", ")", "return", "(", "unsigned", ")", "Thres", ";", "uint64_t", "AllocaSize", "=", "<NUM_LIT>", ";", "SmallPtrSet", "<", "const", "AllocaInst", "*", ",", "<NUM_LIT>", ">", "AIVisited", ";", "for", "(", "Value", "*", "PtrArg", ":", "CB", ".", "args", "(", ")", ")", "{", "PointerType", "*", "Ty", "=", "dyn_cast", "<", "PointerType", ">", "(", "PtrArg", "->", "getType", "(", ")", ")", ";", "if", "(", "!", "Ty", "||", "(", "Ty", "->", "getAddressSpace", "(", ")", "!=", "AMDGPUAS", "::", "PRIVATE_ADDRESS", "&&", "Ty", "->", "getAddressSpace", "(", ")", "!=", "AMDGPUAS", "::", "FLAT_ADDRESS", ")", ")", "continue", ";", "PtrArg", "=", "GetUnderlyingObject", "(", "PtrArg", ",", "DL", ")", ";", "if", "(", "const", "AllocaInst", "*", "AI", "=", "dyn_cast", "<", "AllocaInst", ">", "(", "PtrArg", ")", ")", "{", "if", "(", "!", "AI", "->", "isStaticAlloca", "(", ")", "||", "!", "AIVisited", ".", "insert", "(", "AI", ")", ".", "second", ")", "continue", ";", "AllocaSize", "+=", "DL", ".", "getTypeAllocSize", "(", "AI", "->", "getAllocatedType", "(", ")", ")", ";", "if", "(", "AllocaSize", ">", "ArgAllocaCutoff" ]

[ "}" ]

[ "MCObjectWriter", "*", "WebAssemblyAsmBackend", "::", "createObjectWriter", "(", "raw_pwrite_stream", "&", "OS", ")", "const", "{", "return", "createWebAssemblyELFObjectWriter", "(", "OS", ",", "Is64Bit", ",", "<NUM_LIT>", ")", ";" ]

[ "SETLE", ">", ";" ]

[ "def", "vsetle_v8i16", ":", "vsetcc_type", "<", "v8i16", "," ]

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

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

[ "static", "int", "rs6000_emit_p9_fp_minmax", "(", "rtx", "dest", ",", "rtx", "op", ",", "rtx", "true_cond", ",", "rtx", "false_cond", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "op", ")", ";", "rtx", "op0", "=", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ";", "rtx", "op1", "=", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ";", "machine_mode", "compare_mode", "=", "GET_MODE", "(", "op0", ")", ";", "machine_mode", "result_mode", "=", "GET_MODE", "(", "dest", ")", ";", "bool", "max_p", "=", "false", ";", "if", "(", "result_mode", "!=", "compare_mode", ")", "return", "<NUM_LIT>", ";", "if", "(", "code", "==", "GE", "||", "code", "==", "GT", ")", "max_p", "=", "true", ";", "else", "if", "(", "code", "==", "LE", "||", "code", "==", "LT", ")", "max_p", "=", "false", ";", "else", "return", "<NUM_LIT>", ";", "if", "(", "rtx_equal_p", "(", "op0", ",", "true_cond", ")", "&&", "rtx_equal_p", "(", "op1", ",", "false_cond", ")", ")", ";", "else", "if", "(", "rtx_equal_p", "(", "op1", ",", "true_cond", ")", "&&", "rtx_equal_p", "(", "op0", ",", "false_cond", ")", ")", "max_p", "=", "!", "max_p", ";", "else", "return", "<NUM_LIT>", ";", "rs6000_emit_minmax", "(", "dest", ",", "max_p", "?", "SMAX", ":", "SMIN", ",", "op0", ",", "op1", ")", ";", "return", "<NUM_LIT>", ";", "}" ]

[ "ISA", "3.0", "(", "power9", ")", "minmax", "subcase", "to", "emit", "a", "XSMAXCDP", "or", "XSMINCDP", "instruction", "for", "SF/DF", "scalars", ".", "Move", "TRUE_COND", "to", "DEST", "if", "OP", "of", "the", "operands", "of", "the", "last", "comparison", "is", "nonzero/true", ",", "FALSE_COND", "if", "it", "is", "zero/false", ".", "Return", "0", "if", "the", "hardware", "has", "no", "such", "operation", "." ]

[ ":" ]

[ "static", "bool", "IsSchedBarrier", "(", "MachineInstr", "*", "MI", ")", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "Hexagon", "::", "BARRIER" ]

[ "DebugLoc", "DL", "=", "LD", "->", "getDebugLoc", "(", ")", ";" ]

[ "assert", "(", "(", "VT", "==", "MVT", "::", "i32", ")", "||", "(", "VT", "==", "MVT", "::", "i64", ")", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "i64", ")", "&&", "(", "ExtType", "==", "ISD", "::", "NON_EXTLOAD", ")", ")", "{", "SDValue", "LDL", "=", "CreateLoadLR", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DAG", ",", "LD", ",", "Chain", ",", "Undef", ",", "IsLittle", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "return", "CreateLoadLR", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DAG", ",", "LD", ",", "LDL", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "LDL", ",", "IsLittle", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "}", "SDValue", "LWL", "=", "CreateLoadLR", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DAG", ",", "LD", ",", "Chain", ",", "Undef", ",", "IsLittle", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "SDValue", "LWR", "=", "CreateLoadLR", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DAG", ",", "LD", ",", "LWL", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "LWL", ",", "IsLittle", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "i32", ")", "||", "(", "ExtType", "==", "ISD", "::", "SEXTLOAD", ")", "||", "(", "ExtType", "==", "ISD", "::", "EXTLOAD", ")", ")", "return", "LWR", ";", "assert", "(", "(", "VT", "==", "MVT", "::", "i64", ")", "&&", "(", "ExtType", "==", "ISD", "::", "ZEXTLOAD", ")", ")", ";" ]

[ "MI", ".", "setOpcode", "(", "NewOpcode", ")", ";" ]

[ "}", "if", "(", "NewOpcode", "==", "-", "<NUM_LIT>", ")", "return", "MCDisassembler", "::", "Success", ";", "}", "else", "{", "NewOpcode", "=", "AMDGPU", "::", "getMaskedMIMGOp", "(", "*", "MCII", ",", "MI", ".", "getOpcode", "(", ")", ",", "DstSize", ")", ";", "assert", "(", "NewOpcode", "!=", "-", "<NUM_LIT>", "&&", "<STR_LIT>", "could not find matching mimg channel instruction", "<STR_LIT>", ")", ";", "}", "auto", "RCID", "=", "MCII", "->", "get", "(", "NewOpcode", ")", ".", "OpInfo", "[", "VDataIdx", "]", ".", "RegClass", ";", "unsigned", "Vdata0", "=", "MI", ".", "getOperand", "(", "VDataIdx", ")", ".", "getReg", "(", ")", ";", "unsigned", "VdataSub0", "=", "MRI", ".", "getSubReg", "(", "Vdata0", ",", "AMDGPU", "::", "sub0", ")", ";", "Vdata0", "=", "(", "VdataSub0", "!=", "<NUM_LIT>", ")", "?", "VdataSub0", ":", "Vdata0", ";", "auto", "NewVdata", "=", "MRI", ".", "getMatchingSuperReg", "(", "Vdata0", ",", "AMDGPU", "::", "sub0", ",", "&", "MRI", ".", "getRegClass", "(", "RCID", ")", ")", ";", "if", "(", "NewVdata", "==", "AMDGPU", "::", "NoRegister", ")", "{", "return", "MCDisassembler", "::", "Success", ";", "}" ]

[ "return", "gen_rtx_SET", "(", "store", "?", "mem", ":", "reg", ",", "store", "?", "reg", ":", "mem", ")", ";" ]

[ "if", "(", "offset", ")", "addr", "=", "plus_constant", "(", "Pmode", ",", "frame_reg", ",", "offset", ")", ";", "mem", "=", "gen_frame_mem", "(", "GET_MODE", "(", "reg", ")", ",", "offset", "?", "addr", ":", "frame_reg", ")", ";" ]

[ "let", "DecoderMethod", "=", "rrDecoderMethod", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "let", "isCommutable", "=", "Commutable", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";" ]

[ ";" ]

[ "llvm", "::", "dbgs", "(", ")", "<<", "<STR_LIT>", "unsupported usage in BPFPreserveStaticOffsetPass:\\n", "<STR_LIT>", ";", "llvm", "::", "dbgs", "(", ")", "<<", "<STR_LIT>", " Insn: ", "<STR_LIT>", "<<", "*", "Insn", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "llvm", "::", "dbgs", "(", ")", "<<", "<STR_LIT>", " User: ", "<STR_LIT>", "<<", "*", "U", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "}", ")" ]

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

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

[ "}" ]

[ "def", "SKLWriteResGroup54", ":", "SchedWriteRes", "<", "[", "SKLPort0156", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=", "<NUM_LIT>", ";", "let", "ResourceCycles", "=", "[", "<NUM_LIT>", "]", ";" ]

[ "]", ")" ]

[ "(", "V2SI", "<STR_LIT>", ")", "(", "V4SI", "<STR_LIT>", ")", "(", "DI", "<STR_LIT>", ")", "(", "V2DI", "<STR_LIT>", ")", "(", "V2SF", "<STR_LIT>", ")", "(", "V4SF", "<STR_LIT>", ")", "(", "V2DF", "<STR_LIT>", ")" ]

[ "return", "(", "unsigned", ")", "Imm", ".", "Val", ";" ]

[ "unsigned", "getVSReg", "(", ")", "const", "{", "assert", "(", "isVSRegNumber", "(", ")", "&&", "<STR_LIT>", "Invalid access!", "<STR_LIT>", ")", ";" ]

[ "bool", "RV16KAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "Res", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "Res", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "instruction use requires an option to be enabled", "<STR_LIT>", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "unrecognized instruction mnemonic", "<STR_LIT>", ")", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "<NUM_LIT>", "U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "ErrorLoc", ",", "<STR_LIT>", "too few operands for instruction", "<STR_LIT>", ")", ";", "ErrorLoc", "=", "(", "(", "RV16KOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "<STR_LIT>", "invalid operand for instruction", "<STR_LIT>", ")", ";", "}", "}", "RV16KOperand", "&", "Operand", "=", "(", "RV16KOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ";", "if", "(", "!", "Operand", ".", "isImm", "(", ")", ")", "return", "Error", "(", "Operand", ".", "getStartLoc", "(", ")", ",", "<STR_LIT>", "invalid operand for instruction", "<STR_LIT>", ")", ";", "switch", "(", "Res", ")", "{", "case", "Match_InvalidSImm4", ":", "return", "generateImmOutOfRangeError", "(", "Operands", ",", "ErrorInfo", ",", "-", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", ",", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ")", ";", "case", "Match_InvalidSImm8Lsb0", ":", "return", "generateImmOutOfRangeError", "(", "Operands", ",", "ErrorInfo", ",", "-", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", ",", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ",", "<STR_LIT>", "immediate must be a multiple of 2 bytes in the range", "<STR_LIT>", ")", ";", "case", "Match_InvalidUImm9Lsb0", ":", "return", "generateImmOutOfRangeError", "(", "Operands", ",", "ErrorInfo", ",", "<NUM_LIT>", ",", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ",", "<STR_LIT>", "immediate must be a multiple of 2 bytes in the range", "<STR_LIT>", ")", ";", "case", "Match_InvalidSImm16", ":", "return", "generateImmOutOfRangeError", "(", "Operands", ",", "ErrorInfo", ",", "-", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", ",", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ")", ";", "case", "Match_InvalidSImm16Lsb0", ":", "return", "generateImmOutOfRangeError", "(", "Operands", ",", "ErrorInfo", ",", "-", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", ",", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ",", "<STR_LIT>", "immediate must be a multiple of 2 bytes in the range", "<STR_LIT>", ")", ";", "}", "llvm_unreachable", "(", "<STR_LIT>", "Unknown match type detected!", "<STR_LIT>", ")", ";", "}" ]

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

[ "if", "(", "GET_CODE", "(", "pat", ")", "!=", "SET", "||", "GET_CODE", "(", "dep_pat", ")", "!=", "SET", ")", "return", "cost", ";" ]

[ "static", "int", "supersparc_adjust_cost", "(", "rtx_insn", "*", "insn", ",", "rtx", "link", ",", "rtx_insn", "*", "dep_insn", ",", "int", "cost", ")", "{", "enum", "attr_type", "insn_type", ";", "if", "(", "recog_memoized", "(", "insn", ")", "<", "<NUM_LIT>", ")", "return", "cost", ";", "insn_type", "=", "get_attr_type", "(", "insn", ")", ";", "if", "(", "REG_NOTE_KIND", "(", "link", ")", "==", "<NUM_LIT>", ")", "{", "if", "(", "insn_type", "==", "TYPE_LOAD", "||", "insn_type", "==", "TYPE_FPLOAD", ")", "return", "cost", "+", "<NUM_LIT>", ";", "if", "(", "insn_type", "==", "TYPE_STORE", "||", "insn_type", "==", "TYPE_FPSTORE", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "rtx", "dep_pat", "=", "PATTERN", "(", "dep_insn", ")", ";" ]

[ "elt", ")", ",", "GET_MODE_INNER", "(", "GET_MODE", "(", "x", ")", ")", ")", ")", ";" ]

[ "rtx", "elt", ";", "return", "(", "const_vec_duplicate_p", "(", "x", ",", "&", "elt", ")", "&&", "CONST_INT_P", "(", "elt", ")", "&&", "aarch64_bitmask_imm", "(", "INTVAL", "(" ]

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

[ "(", "unspec", ":", "V4SI", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_XXSPLTIW", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ ")", ";" ]

[ "ISD", "::", "ArgFlagsTy", "Flags", "=", "Outs", "[", "i", "]", ".", "Flags", ";", "bool", "ArgAlign", "=", "isHvxVectorType", "(", "VA", ".", "getValVT", "(", ")", ")", ";", "NeedsArgAlign", "|=", "ArgAlign", ";", "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", "(", "ArgAlign", ")", "LargestAlignSeen", "=", "std", "::", "max", "(", "LargestAlignSeen", ",", "VA", ".", "getLocVT", "(", ")", ".", "getStoreSizeInBits", "(", ")", ">>", "<NUM_LIT>", ")", ";", "if", "(", "Flags", ".", "isByVal", "(", ")", ")", "{", "MemOpChains", ".", "push_back", "(", "CreateCopyOfByValArgument", "(", "Arg", ",", "MemAddr", ",", "Chain", ",", "Flags", ",", "DAG", ",", "dl", ")", ")", ";", "}", "else", "{", "MachinePointerInfo", "LocPI", "=", "MachinePointerInfo", "::", "getStack", "(", "DAG", ".", "getMachineFunction", "(", ")", ",", "LocMemOffset", ")", ";", "SDValue", "S", "=", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "Arg", ",", "MemAddr", ",", "LocPI", ")", ";", "MemOpChains", ".", "push_back", "(", "S", ")", ";", "}", "continue", ";", "}", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "VA", ".", "getLocReg", "(", ")", ",", "Arg", ")", ")", ";", "}", "if", "(", "NeedsArgAlign", "&&", "Subtarget", ".", "hasV60TOps", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Function needs byte stack align due to call args\\n", "<STR_LIT>", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFrameInfo", "(", ")", ";", "bool", "UseHVXDbl", "=", "Subtarget", ".", "useHVXDblOps", "(", ")", ";", "assert", "(", "Subtarget", ".", "useHVXOps", "(", ")", ")", ";", "const", "unsigned", "ObjAlign", "=", "UseHVXDbl", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "LargestAlignSeen", "=", "std", "::", "max", "(", "LargestAlignSeen", ",", "ObjAlign", ")", ";", "MFI", ".", "ensureMaxAlignment", "(", "LargestAlignSeen", ")", ";", "}", "if", "(", "!", "MemOpChains", ".", "empty", "(", ")", ")", "Chain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "dl", ",", "MVT", "::", "Other", ",", "MemOpChains", ")", ";", "if", "(", "!", "IsTailCall", ")", "{", "SDValue", "C", "=", "DAG", ".", "getConstant", "(", "NumBytes", ",", "dl", ",", "PtrVT", ",", "true", ")", ";", "Chain", "=", "DAG", ".", "getCALLSEQ_START", "(", "Chain", ",", "C", ",", "dl", ")", ";", "}", "SDValue", "Glue", ";", "if", "(", "!", "IsTailCall", ")", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "RegsToPass", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "RegsToPass", "[", "i", "]", ".", "first", ",", "RegsToPass", "[", "i", "]", ".", "second", ",", "Glue", ")", ";", "Glue", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>" ]

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

[ "field", "bits", "<", "<NUM_LIT>", ">", "SoftFail", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "R1", ";", "bits", "<", "<NUM_LIT>", ">", "R3", ";", "bits", "<", "<NUM_LIT>", ">", "RI2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "R1", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "R3", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "RI2", ";" ]

[ "GPReg", "=", "ABI", ".", "GetGlobalPtr", "(", ")", ";" ]

[ "setAvailableFeatures", "(", "ComputeAvailableFeatures", "(", "getSTI", "(", ")", ".", "getFeatureBits", "(", ")", ")", ")", ";", "AssemblerOptions", ".", "push_back", "(", "std", "::", "make_unique", "<", "MipsAssemblerOptions", ">", "(", "getSTI", "(", ")", ".", "getFeatureBits", "(", ")", ")", ")", ";", "AssemblerOptions", ".", "push_back", "(", "std", "::", "make_unique", "<", "MipsAssemblerOptions", ">", "(", "getSTI", "(", ")", ".", "getFeatureBits", "(", ")", ")", ")", ";", "getTargetStreamer", "(", ")", ".", "updateABIInfo", "(", "*", "this", ")", ";", "if", "(", "!", "isABI_O32", "(", ")", "&&", "!", "useOddSPReg", "(", ")", "!=", "<NUM_LIT>", ")", "report_fatal_error", "(", "<STR_LIT>", "-mno-odd-spreg requires the O32 ABI", "<STR_LIT>", ")", ";", "CurrentFn", "=", "nullptr", ";", "IsPicEnabled", "=", "getContext", "(", ")", ".", "getObjectFileInfo", "(", ")", "->", "isPositionIndependent", "(", ")", ";", "IsCpRestoreSet", "=", "false", ";", "CpRestoreOffset", "=", "-", "<NUM_LIT>", ";" ]

[ ";" ]

[ "Op", "->", "Token", ".", "Data", "=", "Str", ".", "data", "(", ")", ";", "Op", "->", "Token", ".", "Length", "=", "Str", ".", "size", "(", ")", ";", "return", "Op" ]

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

[ "if", "(", "!", "TARGET_64BIT", ")", "return", "UINTVAL", "(", "op", ")", "<", "=", "HOST_WIDE_INT_UC" ]

[ "<STR_LIT>", ")" ]

[ "(", "define_automaton" ]

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

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

[ "label", "||", "!", "simplejump_p", "(", "end", "->", "fallthrough", ")", "||", "fallthrough", "!=", "next_real_insn", "(", "JUMP_LABEL_AS_INSN", "(", "end", "->", "fallthrough", ")", ")", ")", "return", "false", ";" ]

[ "rtx_insn", "*", "fallthrough", ";", "if", "(", "loop", "->", "begin", "==", "<NUM_LIT>", "||", "loop", "->", "end", "==", "<NUM_LIT>", "||", "loop", "->", "begin", "->", "next", "!=", "<NUM_LIT>", ")", "return", "false", ";", "if", "(", "prev_real_insn", "(", "as_a", "<", "rtx_insn", "*", ">", "(", "loop", "->", "end", "->", "label", ")", ")", "!=", "loop", "->", "begin", "->", "insn", ")", "return", "false", ";", "if", "(", "get_attr_length", "(", "loop", "->", "end", "->", "insn", ")", "!=", "<NUM_LIT>", ")", "return", "false", ";", "fallthrough", "=", "loop", "->", "end", "->", "fallthrough", ";", "for", "(", "end", "=", "loop", "->", "end", "->", "next", ";", "end", "!=", "<NUM_LIT>", ";", "end", "=", "end", "->", "next", ")", "if", "(", "end", "->", "label", "!=", "loop", "->", "end", "->" ]

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

[ "(", "const_int", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<BUGS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "reg", ":", "CCX_NOOV", "<NUM_LIT>", ")" ]

[ "}" ]

[ "FunctionPass", "*", "llvm", "::", "createX86FixupLEAs", "(", ")", "{", "return", "new", "FixupLEAPass", "(", ")", ";" ]

[ "<FIXS>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<FIXE>", "<FIXS>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<FIXE>" ]

[ "let", "NumMicroOps", "=", "<NUM_LIT>", ";", "let", "ResourceCycles", "=", "[", "<NUM_LIT>", "]", ";", "}", "<BUGS>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGE>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGS>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGE>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";" ]

[ "<FIXS>", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "ARM", "::", "t2MSR_M", ")", "{", "unsigned", "Mask", "=", "fieldFromInstruction", "(", "Val", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "if", "(", "!", "(", "FeatureBits", "&", "ARM", "::", "HasV7Ops", ")", ")", "{", "if", "(", "Mask", "!=", "<NUM_LIT>", ")", "S", "=", "MCDisassembler", "::", "SoftFail", ";", "}", "else", "{", "if", "(", "Mask", "==", "<NUM_LIT>", "||", "(", "Mask", "!=", "<NUM_LIT>", "&&", "ValLow", ">", "<NUM_LIT>", ")", "||", "(", "!", "(", "FeatureBits", "&", "ARM", "::", "FeatureDSPThumb2", ")", "&&", "(", "Mask", "&", "<NUM_LIT>", ")", ")", ")", "S", "=", "MCDisassembler", "::", "SoftFail", ";", "}", "<FIXE>" ]

[ "return", "MCDisassembler", "::", "Fail", ";", "}", "<BUGS>", "if", "(", "(", "FeatureBits", "&", "ARM", "::", "HasV7Ops", ")", "&&", "Inst", ".", "getOpcode", "(", ")", "==", "ARM", "::", "t2MSR_M", ")", "{", "unsigned", "Mask", "=", "(", "Val", ">>", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ";", "if", "(", "Mask", "==", "<NUM_LIT>", "||", "(", "Mask", "!=", "<NUM_LIT>", "&&", "ValLow", ">", "<NUM_LIT>", ")", "||", "(", "!", "(", "FeatureBits", "&", "ARM", "::", "FeatureDSPThumb2", ")", "&&", "Mask", "==", "<NUM_LIT>", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "<BUGE>", "}", "}", "else", "{" ]

[ "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumElems", ";", "++", "i", ")", "ShuffleVec", "[", "i", "*", "SizeRatio", "]", "=", "i", ";" ]

[ "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "NumLoads", ";", "++", "i", ")", "{", "SDValue", "ScalarLoad", "=", "DAG", ".", "getLoad", "(", "SclrLoadTy", ",", "dl", ",", "Ld", "->", "getChain", "(", ")", ",", "Ptr", ",", "Ld", "->", "getPointerInfo", "(", ")", ",", "Ld", "->", "isVolatile", "(", ")", ",", "Ld", "->", "isNonTemporal", "(", ")", ",", "Ld", "->", "isInvariant", "(", ")", ",", "Ld", "->", "getAlignment", "(", ")", ")", ";", "Chains", ".", "push_back", "(", "ScalarLoad", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "i", "==", "<NUM_LIT>", ")", "Res", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "dl", ",", "LoadUnitVecVT", ",", "ScalarLoad", ")", ";", "else", "Res", "=", "DAG", ".", "getNode", "(", "ISD", "::", "INSERT_VECTOR_ELT", ",", "dl", ",", "LoadUnitVecVT", ",", "Res", ",", "ScalarLoad", ",", "DAG", ".", "getIntPtrConstant", "(", "i", ")", ")", ";", "Ptr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "Ptr", ".", "getValueType", "(", ")", ",", "Ptr", ",", "Increment", ")", ";", "}", "SDValue", "TF", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "dl", ",", "MVT", "::", "Other", ",", "Chains", ")", ";", "SDValue", "SlicedVec", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "WideVecVT", ",", "Res", ")", ";", "unsigned", "SizeRatio", "=", "RegSz", "/", "MemSz", ";", "if", "(", "Ext", "==", "ISD", "::", "SEXTLOAD", ")", "{", "if", "(", "Subtarget", "->", "hasSSE41", "(", ")", ")", "{", "SDValue", "Sext", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "RegVT", ",", "SlicedVec", ")", ";", "return", "DCI", ".", "CombineTo", "(", "N", ",", "Sext", ",", "TF", ",", "true", ")", ";", "}", "if", "(", "!", "TLI", ".", "isOperationLegalOrCustom", "(", "ISD", "::", "SRA", ",", "RegVT", ")", ")", "return", "SDValue", "(", ")", ";", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "ShuffleVec", "(", "NumElems", "*", "SizeRatio", ",", "-", "<NUM_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumElems", ";", "++", "i", ")", "ShuffleVec", "[", "i", "*", "SizeRatio", "+", "SizeRatio", "-", "<NUM_LIT>", "]", "=", "i", ";", "SDValue", "Shuff", "=", "DAG", ".", "getVectorShuffle", "(", "WideVecVT", ",", "dl", ",", "SlicedVec", ",", "DAG", ".", "getUNDEF", "(", "WideVecVT", ")", ",", "&", "ShuffleVec", "[", "<NUM_LIT>", "]", ")", ";", "Shuff", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "RegVT", ",", "Shuff", ")", ";", "unsigned", "Amt", "=", "RegVT", ".", "getVectorElementType", "(", ")", ".", "getSizeInBits", "(", ")", "-", "MemVT", ".", "getVectorElementType", "(", ")", ".", "getSizeInBits", "(", ")", ";", "Shuff", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRA", ",", "dl", ",", "RegVT", ",", "Shuff", ",", "DAG", ".", "getConstant", "(", "Amt", ",", "RegVT", ")", ")", ";", "return", "DCI", ".", "CombineTo", "(", "N", ",", "Shuff", ",", "TF", ",", "true", ")", ";", "}", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "ShuffleVec", "(", "NumElems", "*", "SizeRatio", ",", "-", "<NUM_LIT>", ")", ";" ]

[ ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{" ]

[ "ScheduleHazardRecognizer", "*", "HexagonInstrInfo", "::", "CreateTargetPostRAHazardRecognizer", "(", "const", "InstrItineraryData", "*", "II" ]

[ "}" ]

[ "const", "VETargetLowering", "*", "getTLI", "(", ")", "const", "{", "return", "TLI", ";" ]

[ ")", ";" ]

[ "SDValue", "N1", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Subtarget", ".", "hasSSE41", "(", ")", "&&", "DAG", ".", "ComputeNumSignBits", "(", "N0", ")", ">", "<NUM_LIT>", "&&", "DAG", ".", "ComputeNumSignBits", "(", "N1", ")", ">", "<NUM_LIT>", ")", "{", "auto", "PMULDQBuilder", "=", "[", "]", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "DL", ",", "ArrayRef", "<", "SDValue", ">", "Ops", ")", "{", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "Ops", "[", "<NUM_LIT>", "]", ".", "getValueType", "(", ")", ",", "Ops", ")", ";", "}", ";", "return", "SplitOpsAndApply", "(", "DAG", ",", "Subtarget", ",", "DL", ",", "VT", ",", "{", "N0", ",", "N1", "}", ",", "PMULDQBuilder", ",", "false", ")", ";", "}", "APInt", "Mask", "=", "APInt", "::", "getHighBitsSet", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "if", "(", "DAG", ".", "MaskedValueIsZero", "(", "N0", ",", "Mask", ")", "&&", "DAG", ".", "MaskedValueIsZero", "(", "N1", ",", "Mask", ")", ")", "{", "auto", "PMULUDQBuilder", "=", "[", "]", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "DL", ",", "ArrayRef", "<", "SDValue", ">", "Ops", ")", "{", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "Ops", "[", "<NUM_LIT>", "]", ".", "getValueType", "(", ")", ",", "Ops", ")", ";", "}", ";", "return", "SplitOpsAndApply", "(", "DAG", ",", "Subtarget", ",", "DL", ",", "VT", ",", "{", "N0", ",", "N1", "}", ",", "PMULUDQBuilder", ",", "false", ")", ";", "}", "return", "SDValue", "(" ]

[ "Sink", ";" ]

[ "const", "BasicBlock", "*", "LLVM_BB", "=", "BB", "->", "getBasicBlock", "(", ")", ";", "MachineFunction", "::", "iterator", "It", "=", "std", "::", "next", "(", "MachineFunction", "::", "iterator", "(", "BB", ")", ")", ";", "MachineFunction", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "FBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "TBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "Sink", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "F", "->", "insert", "(", "It", ",", "FBB", ")", ";", "F", "->", "insert", "(", "It", ",", "TBB", ")", ";", "F", "->", "insert", "(", "It", ",", "Sink", ")", ";", "Sink", "->", "splice", "(", "Sink", "->", "begin", "(", ")", ",", "BB", ",", "std", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "BB", "->", "end", "(", ")", ")", ";", "Sink", "->", "transferSuccessorsAndUpdatePHIs", "(", "BB", ")", ";", "BB", "->", "addSuccessor", "(", "FBB", ")", ";", "BB", "->", "addSuccessor", "(", "TBB", ")", ";", "FBB", "->", "addSuccessor", "(", "Sink", ")", ";", "TBB", "->", "addSuccessor", "(", "Sink", ")", ";", "BuildMI", "(", "BB", ",", "DL", ",", "TII", "->", "get", "(", "BranchOp", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "unsigned", "RD1", "=", "RegInfo", ".", "createVirtualRegister", "(", "RC", ")", ";", "BuildMI", "(", "*", "FBB", ",", "FBB", "->", "end", "(", ")", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "ADDiu", ")", ",", "RD1", ")", ".", "addReg", "(", "Mips", "::", "ZERO", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "*", "FBB", ",", "FBB", "->", "end", "(", ")", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "B", ")", ")", ".", "addMBB", "(", "Sink", ")", ";", "unsigned", "RD2", "=", "RegInfo", ".", "createVirtualRegister", "(", "RC", ")", ";", "BuildMI", "(", "*", "TBB", ",", "TBB", "->", "end", "(", ")", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "ADDiu", ")", ",", "RD2", ")", ".", "addReg", "(", "Mips", "::", "ZERO", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "*", "Sink", ",", "Sink", "->", "begin", "(", ")", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "PHI", ")", ",", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "RD1", ")", ".", "addMBB", "(", "FBB", ")", ".", "addReg", "(", "RD2", ")", ".", "addMBB", "(", "TBB", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "return" ]

[ "else", "NewMask", "=", "getUnpack", "(", "MVT", "::", "v256i1", ",", "RawMask", ",", "Part", ",", "NewAVL", ")", ";" ]

[ "else", "NewAVL", "=", "RawAVL", ";", "NewAVL", "=", "getNode", "(", "ISD", "::", "SRL", ",", "MVT", "::", "i32", ",", "{", "NewAVL", ",", "OneV", "}", ")", ";", "NewAVL", "=", "annotateLegalAVL", "(", "NewAVL", ")", ";", "SDValue", "NewMask", ";", "if", "(", "!", "RawMask", ")", "NewMask", "=", "getConstantMask", "(", "Packing", "::", "Normal", ",", "true", ")", ";" ]

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

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

[ "<", "[", "HasNEON", ",", "HasFullFP16", "]", ">", ";" ]

[ "def", "VABDhd", ":", "N3VDInt", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "N3RegFrm", ",", "IIC_VBIND", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "v4f16", ",", "v4f16", ",", "int_arm_neon_vabds", ",", "<NUM_LIT>", ">", ",", "Requires" ]

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

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

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V1TF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "float_extend", ":", "V1TF", "(", "vec_select", ":", "V1DF", "(", "match_operand", ":", "V2DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ ")" ]

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

[ "aarch64_vget_lane_any", "(", "_", "_", "c", ",", "_", "_", "lane", ")", ")", ")", ";" ]

[ "vmlsq_lane_f32", "(", "float32x4_t", "_", "_", "a", ",", "float32x4_t", "_", "_", "b", ",", "float32x2_t", "_", "_", "c", ",", "const", "int", "_", "_", "lane", ")", "{", "return", "(", "_", "_", "a", "-", "(", "_", "_", "b", "*", "_", "_" ]

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

[ "let", "InOperandList", "=", "(", "ins", "Rsrc1", ":", "$", "op1", ",", "Rsrc2", ":", "$", "op2", ",", "DataType", ":", "$", "optype", ",", "SwitchSet", ":", "$", "sw", ",", "RhazRsOp", ":", "$", "rhaz", ",", "Rdst", ":", "$", "income", ",", "Pred", ":", "$", "pred", ")", ";", "let", "Pattern", "=", "pattern", ";", "let", "Itinerary", "=", "IIC_VectorOp", ";", "bits", "<", "<NUM_LIT>", ">", "dest", ";", "bits", "<", "<NUM_LIT>", ">", "op1", ";", "bits", "<", "<NUM_LIT>", ">", "op2", ";", "bits", "<", "<NUM_LIT>", ">", "optype", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "rhaz", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "op1", ";", "let", "SrcB", "=", "op2", ";", "let", "OperandType", "=", "optype", ";", "let", "Switches", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sw", ";", "let", "Switches", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "VectorPred", "=", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Pred", ")", ",", "<STR_LIT>", ")", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";" ]

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

[ "def", "C4_cmpneqi", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "s32_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_56f114f4", ",", "TypeALU32_2op", ">", ",", "Enc_bd0b33", ",", "ImmRegRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<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", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign" ]

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

[ "}" ]

[ "bool", "MSP430FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ")", ";", "return", "true", ";" ]

[ "a", ",", "vec_ushort8", "b", ",", "vec_uint4", "c", ")", "{" ]

[ "static", "_", "_", "inline", "vec_uint4", "spu_mhhadd", "(", "vec_ushort8" ]

[ "operands", "[", "<NUM_LIT>", "]", ",", "TFmode", ",", "<NUM_LIT>", ")" ]

[ "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", "{", "operands", "[", "<NUM_LIT>", "]", "=", "simplify_gen_subreg", "(", "DFmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "FPRX2mode", ",", "<NUM_LIT>", ")", "operands", "[", "<NUM_LIT>", "]", "=", "simplify_gen_subreg", "(", "DFmode", "," ]

[ ";" ]

[ "static", "MCCodeGenInfo", "*", "creatervexMCCodeGenInfo", "(", "StringRef", "TT", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ")", "{", "MCCodeGenInfo", "*", "X", "=", "new", "MCCodeGenInfo", "(", ")", ";", "X", "->", "InitMCCodeGenInfo", "(", "RM", ",", "CM", ",", "OL", ")", ";", "return", "X" ]

[ "}" ]

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

[ "int", "loongarch_const_insns", "(", "rtx", "x", ")", "{", "enum", "loongarch_symbol_type", "symbol_type", ";", "rtx", "offset", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST_INT", ":", "return", "loongarch_integer_cost", "(", "INTVAL", "(", "x", ")", ")", ";", "case", "CONST_VECTOR", ":", "case", "CONST_DOUBLE", ":", "return", "x", "==", "CONST0_RTX", "(", "GET_MODE", "(", "x", ")", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "case", "CONST", ":", "if", "(", "loongarch_symbolic_constant_p", "(", "x", ",", "&", "symbol_type", ")", ")", "return", "loongarch_symbol_insns", "(", "symbol_type", ",", "MAX_MACHINE_MODE", ")", ";", "split_const", "(", "x", ",", "&", "x", ",", "&", "offset", ")", ";", "if", "(", "offset", "!=", "<NUM_LIT>", ")", "{", "int", "n", "=", "loongarch_const_insns", "(", "x", ")", ";", "if", "(", "n", "!=", "<NUM_LIT>", ")", "{", "if", "(", "IMM12_INT", "(", "offset", ")", ")", "return", "n", "+", "<NUM_LIT>", ";", "else", "if", "(", "!", "targetm", ".", "cannot_force_const_mem", "(", "GET_MODE", "(", "x", ")", ",", "x", ")", ")", "return", "n", "+", "<NUM_LIT>", "+", "loongarch_integer_cost", "(", "INTVAL", "(", "offset", ")", ")", ";", "}", "}", "return", "<NUM_LIT>", ";", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "return", "loongarch_symbol_insns", "(", "loongarch_classify_symbol", "(", "x", ")", ",", "MAX_MACHINE_MODE", ")", ";", "default", ":", "return", "<NUM_LIT>", ";", "}", "}" ]

[ "Return", "the", "number", "of", "instructions", "needed", "to", "load", "constant", "X", ",", "Return", "0", "if", "X", "is", "n't", "a", "valid", "constant", "." ]

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

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

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

[ "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_broadcasti32x4_512", "(", "(", "_", "_", "v4si", ")", "_", "_", "A", ",", "(", "_", "_", "v16si" ]

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

[ "if", "(", "arm_current_function_pac_enabled_p", "(", ")", ")", "cfun", "->", "machine", "->", "pacspval_needed", "=", "<NUM_LIT>", ";", "}", "else", "{", "if", "(", "cfun", "->", "machine", "->", "uses_anonymous_args", ")", "{", "insn", "=", "emit_multi_reg_push", "(", "(", "<NUM_LIT>", ">>", "(", "args_to_push", "/", "<NUM_LIT>", ")", ")", "&", "<NUM_LIT>", ",", "(", "<NUM_LIT>", ">>", "(", "args_to_push", "/", "<NUM_LIT>", ")", ")", "&", "<NUM_LIT>", ")", ";", "emit_set_insn", "(", "gen_rtx_REG", "(", "SImode", ",", "<NUM_LIT>", ")", ",", "ip_rtx", ")", ";", "saved_pretend_args", "=", "<NUM_LIT>", ";", "}", "else", "{", "rtx", "addr", ",", "dwarf", ";", "if", "(", "args_to_push", "==", "<NUM_LIT>", ")", "addr", "=", "gen_rtx_PRE_DEC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ";", "else", "addr", "=", "gen_rtx_PRE_MODIFY", "(", "Pmode", ",", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "args_to_push", ")", ")", ";", "insn", "=", "emit_set_insn", "(", "gen_frame_mem", "(", "SImode", ",", "addr", ")", ",", "ip_rtx", ")", ";", "dwarf", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "args_to_push", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "dwarf", ")", ";", "}", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "fp_offset", "=", "args_to_push", ";", "args_to_push", "=", "<NUM_LIT>", ";", "if", "(", "arm_current_function_pac_enabled_p", "(", ")", ")", "cfun", "->", "machine", "->", "pacspval_needed", "=", "<NUM_LIT>", ";", "}", "}", "if", "(", "arm_current_function_pac_enabled_p", "(", ")", ")", "{", "if", "(", "aarch_bti_enabled", "(", ")", "&&", "!", "clobber_ip", ")", "insn", "=", "emit_insn", "(", "gen_pacbti_nop", "(", ")", ")", ";", "else", "insn", "=", "emit_insn", "(", "gen_pac_nop", "(", ")", ")", ";", "rtx", "dwarf", "=", "gen_rtx_SET", "(", "ip_rtx", ",", "gen_rtx_REG", "(", "SImode", ",", "RA_AUTH_CODE", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_REGISTER", ",", "dwarf", ")", ";", "}", "if", "(", "TARGET_APCS_FRAME", "&&", "frame_pointer_needed", "&&", "TARGET_ARM", ")", "{", "if", "(", "IS_INTERRUPT", "(", "func_type", ")", ")", "{", "emit_multi_reg_push", "(", "<NUM_LIT>", "<<", "IP_REGNUM", ",", "<NUM_LIT>", "<<", "IP_REGNUM", ")", ";", "}", "insn", "=", "emit_set_insn", "(", "ip_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "fp_offset", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "}", "if", "(", "TARGET_HAVE_FPCXT_CMSE", "&&", "IS_CMSE_ENTRY", "(", "func_type", ")", ")", "{", "saved_regs", "+=", "<NUM_LIT>", ";", "insn", "=", "emit_insn", "(", "gen_push_fpsysreg_insn", "(", "stack_pointer_rtx", ",", "GEN_INT", "(", "FPCXTNS_ENUM", ")", ")", ")", ";", "rtx", "dwarf", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "<NUM_LIT>", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "dwarf", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "}", "if", "(", "args_to_push", ")", "{", "if", "(", "cfun", "->", "machine", "->", "uses_anonymous_args", ")", "insn", "=", "emit_multi_reg_push", "(", "(", "<NUM_LIT>", ">>", "(", "args_to_push", "/", "<NUM_LIT>", ")", ")", "&", "<NUM_LIT>", ",", "(", "<NUM_LIT>", ">>", "(", "args_to_push", "/", "<NUM_LIT>", ")", ")", "&", "<NUM_LIT>", ")", ";", "else", "insn", "=", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "args_to_push", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "}", "if", "(", "(", "func_type", "==", "ARM_FT_ISR", "||", "func_type", "==", "ARM_FT_FIQ", ")", "&&", "(", "live_regs_mask", "&", "(", "<NUM_LIT>", "<<", "LR_REGNUM", ")", ")", "!=", "<NUM_LIT>", "&&", "!", "(", "frame_pointer_needed", "&&", "TARGET_APCS_FRAME", ")", "&&", "TARGET_ARM", ")", "{", "rtx", "lr", "=", "gen_rtx_REG", "(", "SImode", ",", "LR_REGNUM", ")", ";", "emit_set_insn", "(", "lr", ",", "plus_constant", "(", "SImode", ",", "lr", ",", "-", "<NUM_LIT>", ")", ")", ";", "}", "if", "(", "live_regs_mask", ")", "{", "unsigned", "long", "dwarf_regs_mask", "=", "live_regs_mask", ";", "saved_regs", "+=", "bit_count", "(", "live_regs_mask", ")", "*", "<NUM_LIT>", ";", "if", "(", "optimize_size", "&&", "!", "frame_pointer_needed", "&&", "saved_regs", "==", "offsets", "->", "saved_regs", "-", "offsets", "->", "saved_args", ")", "{", "int", "n", ";", "int", "frame", ";", "n", "=", "<NUM_LIT>", ";", "while", "(", "n", "<", "<NUM_LIT>", "&&", "(", "live_regs_mask", "&", "(", "<NUM_LIT>", "<<", "n", ")", ")", "==", "<NUM_LIT>", ")", "n", "++", ";", "frame", "=", "offsets", "->", "outgoing_args", "-", "(", "offsets", "->", "saved_args", "+", "saved_regs", ")", ";", "if", "(", "frame", "&&", "n", "*", "<NUM_LIT>", ">=", "frame", ")", "{", "n", "=", "frame" ]

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

[ "<FIXS>", "avr_have_dimode", "=", "false", ";", "<FIXE>" ]

[ "if", "(", "AVR_TINY", ")", "<BUGS>", "avr_have_dimode", "=", "false", ";", "<BUGE>", "}" ]

[ ")", ",", "Op", ".", "getValueType", "(", ")", ")", ";" ]

[ "auto", "*", "CImm", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", "->", "getOperand", "(", "ImmOp", ")", ")", ";", "if", "(", "(", "IsSigned", "&&", "!", "isInt", "<", "N", ">", "(", "CImm", "->", "getSExtValue", "(", ")", ")", ")", "||", "(", "!", "IsSigned", "&&", "!", "isUInt", "<", "N", ">", "(", "CImm", "->", "getZExtValue", "(", ")", ")", ")", ")", "{", "DAG", ".", "getContext", "(", ")", "->", "emitError", "(", "Op", "->", "getOperationName", "(", "<NUM_LIT>", ")", "+", "<STR_LIT>", ": argument out of range.", "<STR_LIT>", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "UNDEF", ",", "SDLoc", "(", "Op" ]

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

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

[ "<STR_LIT>", ";" ]

[ "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", "Defs", "=", "[", "PC", "]", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=" ]

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

[ "void", "LLVMInitializeOR1KTargetInfo", "(", ")", "{", "RegisterTarget", "<", "Triple", "::", "or", "<NUM_LIT>", "k", ">", "X", "(", "TheOR1KTarget", "," ]

[ "}" ]

[ "else", "{", "alt", "=", "tree_cons", "(", "NULL", ",", "build_int_cst", "(", "NULL", ",", "<NUM_LIT>", ")", ",", "NULL", ")", ";", "alt", "=", "tree_cons", "(", "get_identifier", "(", "<STR_LIT>", "regparm", "<STR_LIT>", ")", ",", "alt", ",", "NULL", ")", ";" ]

[ ")", "]" ]

[ "(", "cond", "[", "(", "symbol_ref", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>" ]

[ "}" ]

[ "bool", "SIMCCodeEmitter", "::", "isSrcOperand", "(", "const", "MCInstrDesc", "&", "Desc", ",", "unsigned", "OpNo", ")", "const", "{", "if", "(", "OpNo", "==", "<NUM_LIT>", "&&", "(", "Desc", ".", "TSFlags", "&", "(", "<STR_LIT>", "::", "<STR_LIT>", "|", "<STR_LIT>", "::", "<STR_LIT>", "|", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ")", "return", "true", ";", "unsigned", "RegClass", "=", "Desc", ".", "OpInfo", "[", "OpNo", "]", ".", "RegClass", ";", "return", "(", "AMDGPU", "::", "SSrc_32RegClassID", "==", "RegClass", ")", "||", "(", "AMDGPU", "::", "SSrc_64RegClassID", "==", "RegClass", ")", "||", "(", "AMDGPU", "::", "VSrc_32RegClassID", "==", "RegClass", ")", "||", "(", "AMDGPU", "::", "VSrc_64RegClassID", "==", "RegClass", ")", ";" ]

[ ")", ";" ]

[ "MachineBasicBlock", "*", "SystemZTargetLowering", "::", "emitAtomicLoadMinMax", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "MBB", ",", "unsigned", "CompareOpcode", ",", "unsigned", "KeepOldMask", ",", "unsigned", "BitSize", ")", "const", "{", "const", "SystemZInstrInfo", "*", "TII", "=", "TM", ".", "getInstrInfo", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", "->", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "IsSubWord", "=", "(", "BitSize", "<", "<NUM_LIT>", ")", ";", "unsigned", "Dest", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "MachineOperand", "Base", "=", "earlyUseOperand", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "int64_t", "Disp", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "unsigned", "Src2", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "BitShift", "=", "(", "IsSubWord", "?", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ":", "<NUM_LIT>", ")", ";", "unsigned", "NegBitShift", "=", "(", "IsSubWord", "?", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ":", "<NUM_LIT>", ")", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "IsSubWord", ")", "BitSize", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "(", "BitSize", "<=", "<NUM_LIT>", "?", "&", "<STR_LIT>", "::", "<STR_LIT>", ":", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "unsigned", "LOpcode", "=", "BitSize", "<=", "<NUM_LIT>", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "unsigned", "CSOpcode", "=", "BitSize", "<=", "<NUM_LIT>", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "LOpcode", "=", "TII", "->", "getOpcodeForOffset", "(", "LOpcode", ",", "Disp", ")", ";", "CSOpcode", "=", "TII", "->", "getOpcodeForOffset", "(", "CSOpcode", ",", "Disp", ")", ";", "assert", "(", "LOpcode", "&&", "CSOpcode", "&&", "<STR_LIT>", "Displacement out of range", "<STR_LIT>", ")", ";", "unsigned", "OrigVal", "=", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ";", "unsigned", "OldVal", "=", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ";", "unsigned", "NewVal", "=", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ";", "unsigned", "RotatedOldVal", "=", "(", "IsSubWord", "?", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ":", "OldVal", ")", ";", "unsigned", "RotatedAltVal", "=", "(", "IsSubWord", "?", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ":", "Src2", ")", ";", "unsigned", "RotatedNewVal", "=", "(", "IsSubWord", "?", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ":", "NewVal", ")", ";", "MachineBasicBlock", "*", "StartMBB", "=", "MBB", ";", "MachineBasicBlock", "*", "DoneMBB", "=", "splitBlockAfter", "(", "MI", ",", "MBB", ")", ";", "MachineBasicBlock", "*", "LoopMBB", "=", "emitBlockAfter", "(", "StartMBB", ")", ";", "MachineBasicBlock", "*", "UseAltMBB", "=", "emitBlockAfter", "(", "LoopMBB", ")", ";", "MachineBasicBlock", "*", "UpdateMBB", "=", "emitBlockAfter", "(", "UseAltMBB", ")", ";", "MBB", "=", "StartMBB", ";", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "LOpcode", ")", ",", "OrigVal", ")", ".", "addOperand", "(", "Base", ")", ".", "addImm", "(", "Disp", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ";", "MBB", "->", "addSuccessor", "(", "LoopMBB", ")", ";", "MBB", "=", "LoopMBB", ";", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "OldVal", ")", ".", "addReg", "(", "OrigVal", ")", ".", "addMBB", "(", "StartMBB", ")", ".", "addReg", "(", "Dest", ")", ".", "addMBB", "(", "UpdateMBB", ")", ";", "if", "(", "IsSubWord", ")", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "RotatedOldVal", ")", ".", "addReg", "(", "OldVal", ")", ".", "addReg", "(", "BitShift", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "CompareOpcode", ")", ")", ".", "addReg", "(", "RotatedOldVal", ")", ".", "addReg", "(", "Src2", ")", ";", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "KeepOldMask", ")", ".", "addMBB", "(", "UpdateMBB", ")", ";", "MBB", "->", "addSuccessor", "(", "UpdateMBB", ")", ";", "MBB", "->", "addSuccessor", "(", "UseAltMBB", ")", ";", "MBB", "=", "UseAltMBB", ";", "if", "(", "IsSubWord", ")", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "RotatedAltVal", ")", ".", "addReg", "(", "RotatedOldVal", ")", ".", "addReg", "(", "Src2", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", "+", "BitSize", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "MBB", "->", "addSuccessor", "(", "UpdateMBB", ")", ";", "MBB", "=", "UpdateMBB", ";", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "RotatedNewVal", ")", ".", "addReg", "(", "RotatedOldVal", ")", ".", "addMBB", "(", "LoopMBB", ")", ".", "addReg", "(", "RotatedAltVal", ")", ".", "addMBB", "(", "UseAltMBB", ")", ";", "if", "(", "IsSubWord", ")", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "NewVal", ")", ".", "addReg", "(", "RotatedNewVal", ")", ".", "addReg", "(", "NegBitShift", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "CSOpcode", ")", ",", "Dest", ")", ".", "addReg", "(", "OldVal", ")", ".", "addReg", "(", "NewVal", ")", ".", "addOperand", "(", "Base", ")", ".", "addImm", "(", "Disp", ")", ";", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addMBB", "(", "LoopMBB", ")", ";", "MBB", "->", "addSuccessor", "(", "LoopMBB" ]

[ "}" ]

[ "inline", "static", "uint64_t", "mimm2Val", "(", "uint64_t", "Val", ")", "{", "if", "(", "Val", "==", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";", "if", "(", "(", "Val", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "return", "(", "uint64_t", ")", "(", "(", "INT64_C", "(", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ")", ">>", "(", "Val", "&", "<NUM_LIT>", ")", ")", ";", "return", "(", "(", "uint64_t", ")", "INT64_C", "(", "-", "<NUM_LIT>", ")", ">>", "(", "Val", "&", "<NUM_LIT>", ")", ")", ";" ]

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

[ "class", "BaseOneOperandData", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "RegisterClass", "regtype", ",", "string", "asm", ",", "SDPatternOperator", "node", ">", ":", "I", "<", "(", "outs", "regtype", ":", "$", "Rd", ")", ",", "(", "ins", "regtype", ":", "$", "Rn", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "regtype", ":", "$", "Rd", ",", "(", "node", "regtype", ":", "$", "Rn", ")", ")", "]", ">", ",", "Sched", "<", "[", "WriteI", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";" ]

[ "<NUM_LIT>", ";" ]

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

[ "<FIXS>", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "Register", "SpillReg", ",", "int", "FI", ")", "{", "<FIXE>" ]

[ "const", "SIMachineFunctionInfo", "&", "FuncInfo", ",", "LivePhysRegs", "&", "LiveRegs", ",", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "<BUGS>", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "SpillReg", ",", "int", "FI", ")", "{", "<BUGE>", "unsigned", "Opc", "=", "ST", ".", "enableFlatScratch", "(", ")", "?", "AMDGPU", "::", "SCRATCH_LOAD_DWORD_SADDR", ":", "AMDGPU", "::", "BUFFER_LOAD_DWORD_OFFSET", ";" ]

[ "void", "MSP430InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIdx", ")", ")", ";", "if", "(", "RC", "==", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "llvm_unreachable", "(", "<STR_LIT>", "Cannot store this register to stack slot!", "<STR_LIT>", ")", ";", "}" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "else", "{" ]

[ "bool", "ARMInstructionSelector", "::", "selectGlobal", "(", "MachineInstrBuilder", "&", "MIB", ",", "MachineRegisterInfo", "&", "MRI", ")", "const", "{", "if", "(", "(", "STI", ".", "isROPI", "(", ")", "||", "STI", ".", "isRWPI", "(", ")", ")", "&&", "!", "STI", ".", "isTargetELF", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "ROPI and RWPI only supported for ELF\\n", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "auto", "GV", "=", "MIB", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getGlobal", "(", ")", ";", "if", "(", "GV", "->", "isThreadLocal", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "TLS variables not supported yet\\n", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "auto", "&", "MBB", "=", "*", "MIB", "->", "getParent", "(", ")", ";", "auto", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "bool", "UseMovt", "=", "STI", ".", "useMovt", "(", "MF", ")", ";", "unsigned", "Size", "=", "TM", ".", "getPointerSize", "(", "<NUM_LIT>", ")", ";", "unsigned", "Alignment", "=", "<NUM_LIT>", ";", "auto", "addOpsForConstantPoolLoad", "=", "[", "&", "MF", ",", "Alignment", ",", "Size", "]", "(", "MachineInstrBuilder", "&", "MIB", ",", "const", "GlobalValue", "*", "GV", ",", "bool", "IsSBREL", ")", "{", "assert", "(", "MIB", "->", "getOpcode", "(", ")", "==", "ARM", "::", "LDRi12", "&&", "<STR_LIT>", "Unsupported instruction", "<STR_LIT>", ")", ";", "auto", "ConstPool", "=", "MF", ".", "getConstantPool", "(", ")", ";", "auto", "CPIndex", "=", "IsSBREL", "?", "ConstPool", "->", "getConstantPoolIndex", "(", "ARMConstantPoolConstant", "::", "Create", "(", "GV", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "Alignment", ")", ":", "ConstPool", "->", "getConstantPoolIndex", "(", "GV", ",", "Alignment", ")", ";", "MIB", ".", "addConstantPoolIndex", "(", "CPIndex", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getConstantPool", "(", "MF", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "Size", ",", "Alignment", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "add", "(", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "}", ";", "if", "(", "TM", ".", "isPositionIndependent", "(", ")", ")", "{", "bool", "Indirect", "=", "STI", ".", "isGVIndirectSymbol", "(", "GV", ")", ";", "unsigned", "Opc", "=", "UseMovt", "&&", "!", "STI", ".", "isTargetELF", "(", ")", "?", "(", "Indirect", "?", "ARM", "::", "MOV_ga_pcrel_ldr", ":", "ARM", "::", "MOV_ga_pcrel", ")", ":", "(", "Indirect", "?", "ARM", "::", "LDRLIT_ga_pcrel_ldr", ":", "ARM", "::", "LDRLIT_ga_pcrel", ")", ";", "MIB", "->", "setDesc", "(", "TII", ".", "get", "(", "Opc", ")", ")", ";", "int", "TargetFlags", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "STI", ".", "isTargetDarwin", "(", ")", ")", "TargetFlags", "|=", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "STI", ".", "isGVInGOT", "(", "GV", ")", ")", "TargetFlags", "|=", "<STR_LIT>", "::", "<STR_LIT>", ";", "MIB", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setTargetFlags", "(", "TargetFlags", ")", ";", "if", "(", "Indirect", ")", "MIB", ".", "addMemOperand", "(", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getGOT", "(", "MF", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "TM", ".", "getProgramPointerSize", "(", ")", ",", "Alignment", ")", ")", ";", "return", "constrainSelectedInstRegOperands", "(", "*", "MIB", ",", "TII", ",", "TRI", ",", "RBI", ")", ";", "}", "bool", "isReadOnly", "=", "STI", ".", "getTargetLowering", "(", ")", "->", "isReadOnly", "(", "GV", ")", ";", "if", "(", "STI", ".", "isROPI", "(", ")", "&&", "isReadOnly", ")", "{", "unsigned", "Opc", "=", "UseMovt", "?", "ARM", "::", "MOV_ga_pcrel", ":", "ARM", "::", "LDRLIT_ga_pcrel", ";", "MIB", "->", "setDesc", "(", "TII", ".", "get", "(", "Opc", ")", ")", ";", "return", "constrainSelectedInstRegOperands", "(", "*", "MIB", ",", "TII", ",", "TRI", ",", "RBI", ")", ";", "}", "if", "(", "STI", ".", "isRWPI", "(", ")", "&&", "!", "isReadOnly", ")", "{", "auto", "Offset", "=", "MRI", ".", "createVirtualRegister", "(", "&", "ARM", "::", "GPRRegClass", ")", ";", "MachineInstrBuilder", "OffsetMIB", ";", "if", "(", "UseMovt", ")", "{", "OffsetMIB", "=", "BuildMI", "(", "MBB", ",", "*", "MIB", ",", "MIB", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "ARM", "::", "MOVi32imm", ")", ",", "Offset", ")", ";", "OffsetMIB", ".", "addGlobalAddress", "(", "GV", ",", "<NUM_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}" ]