Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

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

[ "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";" ]

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

[ "(", "match_operand", ":", "V4SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<BUGS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V4SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "+=", "<STR_LIT>", "-a:0:32-S32", "<STR_LIT>", ";" ]

[ "static", "std", "::", "string", "computeDataLayout", "(", "const", "Triple", "&", "TT", ")", "{", "std", "::", "string", "Ret", "=", "<STR_LIT>", "e", "<STR_LIT>", ";", "Ret", "+=", "DataLayout", "::", "getManglingComponent", "(", "TT", ")", ";", "if", "(", "(", "TT", ".", "isArch64Bit", "(", ")", "&&", "(", "TT", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "GNUX32", "||", "TT", ".", "isOSNaCl", "(", ")", ")", ")", "||", "!", "TT", ".", "isArch64Bit", "(", ")", ")", "Ret", "+=", "<STR_LIT>", "-p:32:32", "<STR_LIT>", ";", "if", "(", "TT", ".", "isArch64Bit", "(", ")", "||", "TT", ".", "isOSWindows", "(", ")", "||", "TT", ".", "isOSNaCl", "(", ")", ")", "Ret", "+=", "<STR_LIT>", "-i64:64", "<STR_LIT>", ";", "else", "if", "(", "TT", ".", "isOSIAMCU", "(", ")", ")", "Ret", "+=", "<STR_LIT>", "-i64:32-f64:32", "<STR_LIT>", ";", "else", "Ret", "+=", "<STR_LIT>", "-f64:32:64", "<STR_LIT>", ";", "if", "(", "TT", ".", "isOSNaCl", "(", ")", "||", "TT", ".", "isOSIAMCU", "(", ")", ")", ";", "else", "if", "(", "TT", ".", "isArch64Bit", "(", ")", "||", "TT", ".", "isOSDarwin", "(", ")", ")", "Ret", "+=", "<STR_LIT>", "-f80:128", "<STR_LIT>", ";", "else", "Ret", "+=", "<STR_LIT>", "-f80:32", "<STR_LIT>", ";", "if", "(", "TT", ".", "isOSIAMCU", "(", ")", ")", "Ret", "+=", "<STR_LIT>", "-f128:32", "<STR_LIT>", ";", "if", "(", "TT", ".", "isArch64Bit", "(", ")", ")", "Ret", "+=", "<STR_LIT>", "-n8:16:32:64", "<STR_LIT>", ";", "else", "Ret", "+=", "<STR_LIT>", "-n8:16:32", "<STR_LIT>", ";", "if", "(", "(", "!", "TT", ".", "isArch64Bit", "(", ")", "&&", "TT", ".", "isOSWindows", "(", ")", ")", "||", "TT", ".", "isOSIAMCU", "(", ")", ")", "Ret" ]

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

[ "extern", "_", "_", "inline", "_", "_", "mmask8", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "kadd_mask8", "(", "_", "_", "mmask8", "_", "_", "A", ",", "_", "_", "mmask8", "_", "_", "B", ")", "{", "return", "(", "_", "_", "mmask8", ")", "_", "_", "builtin_ia32_kaddqi", "(", "(", "_", "_", "mmask8", ")", "_", "_", "A", ",", "(", "_", "_" ]

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

[ "vtst_s16", "(", "int16x4_t", "_", "_", "a", ",", "int16x4_t", "_", "_", "b", ")", "{", "return", "(", "uint16x4_t", ")", "(", "(", "_", "_", "a", "&", "_", "_", "b", ")" ]

[ "IES_ERROR", ";" ]

[ "return", "State", "==" ]

[ "(", "_", "_", "m128i", "_", "_", "X", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_cvtepu8_epi64" ]

[ ")", ";" ]

[ "static", "SDValue", "lower128BitVectorShuffle", "(", "SDValue", "Op", ",", "SDValue", "V1", ",", "SDValue", "V2", ",", "MVT", "VT", ",", "const", "X86Subtarget", "*", "Subtarget", ",", "SelectionDAG", "&", "DAG", ")", "{", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "case", "MVT", "::", "v2i64", ":", "return", "lowerV2I64VectorShuffle", "(", "Op", ",", "V1", ",", "V2", ",", "Subtarget", ",", "DAG", ")", ";", "case", "MVT", "::", "v2f64", ":", "return", "lowerV2F64VectorShuffle", "(", "Op", ",", "V1", ",", "V2", ",", "Subtarget", ",", "DAG", ")", ";", "case", "MVT", "::", "v4i32", ":", "return", "lowerV4I32VectorShuffle", "(", "Op", ",", "V1", ",", "V2", ",", "Subtarget", ",", "DAG", ")", ";", "case", "MVT", "::", "v4f32", ":", "return", "lowerV4F32VectorShuffle", "(", "Op", ",", "V1", ",", "V2", ",", "Subtarget", ",", "DAG", ")", ";", "case", "MVT", "::", "v8i16", ":", "return", "lowerV8I16VectorShuffle", "(", "Op", ",", "V1", ",", "V2", ",", "Subtarget", ",", "DAG", ")", ";", "case", "MVT", "::", "v16i8", ":", "return", "lowerV16I8VectorShuffle", "(", "Op", ",", "V1", ",", "V2", ",", "Subtarget", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unimplemented!", "<STR_LIT>" ]

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

[ "class", "BaseTestBranch", "<", "RegisterClass", "regtype", ",", "Operand", "immtype", ",", "bit", "op", ",", "string", "asm", ",", "SDNode", "node", ">", ":", "I", "<", "(", "outs", ")", ",", "(", "ins", "regtype", ":", "$", "Rt", ",", "immtype", ":", "$", "bit_off", ",", "am_tbrcond", ":", "$", "target", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "node", "regtype", ":", "$", "Rt", ",", "immtype", ":", "$", "bit_off", ",", "bb", ":", "$", "target", ")", "]", ">", ",", "Sched", "<", "[", "WriteBr", "]", ">", "{", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "Rt", ";", "bits", "<", "<NUM_LIT>", ">", "bit_off", ";", "bits", "<", "<NUM_LIT>", ">", "target", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "op", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "bit_off", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "target", ";", "let", "Inst", "{", "<NUM_LIT>", "-" ]

[ "<FIXS>", "class", "SM_Probe_Pseudo", "string", "opName", ",", "string", "variant", ",", "RegisterClass", "baseClass", ",", "dag", "offsets", ",", "string", "asmOffsets", ",", "bit", "hasOffset", ",", "bit", "hasSOffset", ">", ":", "SM_Pseudo", "opName", ",", "(", "outs", ")", ",", "!", "con", "(", "(", "ins", "i8imm", ":", "$", "sdata", ",", "baseClass", ":", "$", "sbase", ")", ",", "offsets", ")", ",", "<STR_LIT>", "#", "asmOffsets", ">", "{", "<FIXE>", "<FIXS>", "let", "has_offset", "=", "hasOffset", ";", "let", "has_soffset", "=", "hasSOffset", ";", "let", "PseudoInstr", "=", "opName", "#", "variant", ";", "<FIXE>" ]

[ "bits", "<NUM_LIT>", ">", "cpol", ";", "}", "<BUGS>", "class", "SM_Probe_Pseudo", "string", "opName", ",", "dag", "ins", ",", "bit", "isImm", ">", ":", "SM_Pseudo", "opName", ",", "(", "outs", ")", ",", "ins", ",", "<STR_LIT>", "#", "!", "if", "(", "isImm", ",", "<STR_LIT>", ",", "<STR_LIT>", ")", ">", "{", "<BUGE>", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "mayStore", "=", "<NUM_LIT>", ";", "let", "has_glc", "=", "<NUM_LIT>", ";", "let", "LGKM_CNT", "=", "<NUM_LIT>", ";", "let", "ScalarStore", "=", "<NUM_LIT>", ";", "let", "hasSideEffects", "=", "<NUM_LIT>", ";", "<BUGS>", "let", "has_offset", "=", "isImm", ";", "let", "has_soffset", "=", "!", "not", "(", "isImm", ")", ";", "let", "PseudoInstr", "=", "opName", "#", "!", "if", "(", "isImm", ",", "<STR_LIT>", ",", "<STR_LIT>", ")", ";", "<BUGE>", "}", "class", "SM_Load_Pseudo", "string", "opName", ",", "dag", "outs", ",", "dag", "ins", ",", "string", "asmOps", ",", "list", "dag", ">", "pattern", "=", "[", "]", ">" ]

[ ")", ";" ]

[ "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "setPreservesAll", "(", ")", ";", "AU", ".", "addRequired", "<", "VirtRegMap", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "LiveIntervals", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU" ]

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

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

[ "MCOperand", "&", "Operand", ",", "unsigned", "RelaxTo", ",", "bool", "BankRelax", ")", "{" ]

[ "return", "visitRelaxableOperand", "(", "Inst", ",", "STI", ",", "[", "]", "(", "const" ]

[ "return", "SHADOW_SET_INTSTACK", ";" ]

[ "args", "=", "TREE_VALUE", "(", "attr", ")", ";", "if", "(", "args", "==", "NULL", ")", "return", "SHADOW_SET_YES", ";" ]

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

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

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

[ "(", "mem", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mem", ":", "SI", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mem", ":", "SI", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mem", ":", "SI", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mem", ":", "SI", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mem", ":", "SI", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mem", ":", "SI", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(" ]

[ "unsigned", "MipsSEInstrInfo", "::", "getOppositeBranchOpc", "(", "unsigned", "Opc", ")", "const", "{", "switch", "(", "Opc", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Illegal opcode!", "<STR_LIT>", ")", ";", "case", "Mips", "::", "BEQ", ":", "return", "Mips", "::", "BNE", ";", "case", "Mips", "::", "BEQ_MM", ":", "return", "Mips", "::", "BNE_MM", ";", "case", "Mips", "::", "BNE", ":", "return", "Mips", "::", "BEQ", ";", "case", "Mips", "::", "BNE_MM", ":", "return", "Mips", "::", "BEQ_MM", ";", "case", "Mips", "::", "BGTZ", ":", "return", "Mips", "::", "BLEZ", ";", "case", "Mips", "::", "BGEZ", ":", "return", "Mips", "::", "BLTZ", ";", "case", "Mips", "::", "BLTZ", ":", "return", "Mips", "::", "BGEZ", ";", "case", "Mips", "::", "BLEZ", ":", "return", "Mips", "::", "BGTZ", ";", "case", "Mips", "::", "BGTZ_MM", ":", "return", "Mips", "::", "BLEZ_MM", ";", "case", "Mips", "::", "BGEZ_MM", ":", "return", "Mips", "::", "BLTZ_MM", ";", "case", "Mips", "::", "BLTZ_MM", ":", "return", "Mips", "::", "BGEZ_MM", ";", "case", "Mips", "::", "BLEZ_MM", ":", "return", "Mips", "::", "BGTZ_MM", ";", "case", "Mips", "::", "BEQ64", ":", "return", "Mips", "::", "BNE64", ";", "case", "Mips", "::", "BNE64", ":", "return", "Mips", "::", "BEQ64", ";", "case", "Mips", "::", "BGTZ64", ":", "return", "Mips", "::", "BLEZ64", ";", "case", "Mips", "::", "BGEZ64", ":", "return", "Mips", "::", "BLTZ64", ";", "case", "Mips", "::", "BLTZ64", ":", "return", "Mips", "::", "BGEZ64", ";", "case", "Mips", "::", "BLEZ64", ":", "return", "Mips", "::", "BGTZ64", ";", "case", "Mips", "::", "BC1T", ":", "return", "Mips", "::", "BC1F", ";", "case", "Mips", "::", "BC1F", ":", "return", "Mips", "::", "BC1T", ";", "case", "Mips", "::", "BC1T_MM", ":", "return", "Mips", "::", "BC1F_MM", ";", "case", "Mips", "::", "BC1F_MM", ":", "return", "Mips", "::", "BC1T_MM", ";", "case", "Mips", "::", "BEQZ16_MM", ":", "return", "Mips", "::", "BNEZ16_MM", ";", "case", "Mips", "::", "BNEZ16_MM", ":", "return", "Mips", "::", "BEQZ16_MM", ";", "case", "Mips", "::", "BEQZC_MM", ":", "return", "Mips", "::", "BNEZC_MM", ";", "case", "Mips", "::", "BNEZC_MM", ":", "return", "Mips", "::", "BEQZC_MM", ";", "case", "Mips", "::", "BEQZC", ":", "return", "Mips", "::", "BNEZC", ";", "case", "Mips", "::", "BNEZC", ":", "return", "Mips", "::", "BEQZC", ";", "case", "Mips", "::", "BLEZC", ":", "return", "Mips", "::", "BGTZC", ";", "case", "Mips", "::", "BGEZC", ":", "return", "Mips", "::", "BLTZC", ";", "case", "Mips", "::", "BGEC", ":", "return", "Mips", "::", "BLTC", ";", "case", "Mips", "::", "BGTZC", ":", "return", "Mips", "::", "BLEZC", ";", "case", "Mips", "::", "BLTZC", ":", "return", "Mips", "::", "BGEZC", ";", "case", "Mips", "::", "BLTC", ":", "return", "Mips", "::", "BGEC", ";", "case", "Mips", "::", "BGEUC", ":", "return", "Mips", "::", "BLTUC", ";", "case", "Mips", "::", "BLTUC", ":", "return", "Mips", "::", "BGEUC", ";", "case", "Mips", "::", "BEQC", ":", "return", "Mips", "::", "BNEC", ";", "case", "Mips", "::", "BNEC", ":", "return", "Mips", "::", "BEQC", ";", "case", "Mips", "::", "BC1EQZ", ":", "return", "Mips", "::", "BC1NEZ", ";", "case", "Mips", "::", "BC1NEZ", ":", "return", "Mips", "::", "BC1EQZ", ";", "case", "Mips", "::", "BEQZC_MMR6", ":", "return", "Mips", "::", "BNEZC_MMR6", ";", "case", "Mips", "::", "BNEZC_MMR6", ":", "return", "Mips", "::", "BEQZC_MMR6", ";", "case", "Mips", "::", "BLEZC_MMR6", ":", "return", "Mips", "::", "BGTZC_MMR6", ";", "case", "Mips", "::", "BGEZC_MMR6", ":", "return", "Mips", "::", "BLTZC_MMR6", ";", "case", "Mips", "::", "BGEC_MMR6", ":", "return", "Mips", "::", "BLTC_MMR6", ";", "case", "Mips", "::", "BGTZC_MMR6", ":", "return", "Mips", "::", "BLEZC_MMR6", ";", "case", "Mips", "::", "BLTZC_MMR6", ":", "return", "Mips", "::", "BGEZC_MMR6", ";", "case", "Mips", "::", "BLTC_MMR6", ":", "return", "Mips", "::", "BGEC_MMR6", ";", "case", "Mips", "::", "BGEUC_MMR6", ":", "return", "Mips", "::", "BLTUC_MMR6", ";", "case", "Mips", "::", "BLTUC_MMR6", ":", "return", "Mips", "::", "BGEUC_MMR6", ";", "case", "Mips", "::", "BEQC_MMR6", ":", "return", "Mips", "::", "BNEC_MMR6", ";", "case", "Mips", "::", "BNEC_MMR6", ":", "return", "Mips", "::", "BEQC_MMR6", ";", "case", "Mips", "::", "BC1EQZC_MMR6", ":", "return", "Mips", "::", "BC1NEZC_MMR6", ";", "case", "Mips", "::", "BC1NEZC_MMR6", ":", "return", "Mips", "::", "BC1EQZC_MMR6", ";", "case", "Mips", "::", "BEQZC64", ":", "return", "Mips", "::", "BNEZC64", ";", "case", "Mips", "::", "BNEZC64", ":", "return", "Mips", "::", "BEQZC64", ";", "case", "Mips", "::", "BEQC64", ":", "return", "Mips", "::", "BNEC64", ";", "case", "Mips", "::", "BNEC64", ":", "return", "Mips", "::", "BEQC64", ";", "case", "Mips", "::", "BGEC64", ":", "return", "Mips", "::", "BLTC64", ";", "case", "Mips", "::", "BGEUC64", ":", "return", "Mips", "::", "BLTUC64", ";", "case", "Mips", "::", "BLTC64", ":", "return", "Mips", "::", "BGEC64", ";", "case", "Mips", "::", "BLTUC64", ":", "return", "Mips", "::", "BGEUC64", ";", "case", "Mips", "::", "BGTZC64", ":", "return", "Mips", "::", "BLEZC64", ";", "case", "Mips", "::", "BGEZC64", ":", "return", "Mips", "::", "BLTZC64", ";", "case", "Mips", "::", "BLTZC64", ":", "return", "Mips", "::", "BGEZC64", ";", "case", "Mips", "::", "BLEZC64", ":", "return", "Mips", "::", "BGTZC64", ";", "case", "Mips", "::", "BBIT0", ":", "return", "Mips", "::", "BBIT1", ";", "case", "Mips", "::", "BBIT1", ":", "return", "Mips", "::", "BBIT0", ";", "case", "Mips", "::", "BBIT032", ":", "return", "Mips", "::", "BBIT132", ";", "case", "Mips", "::", "BBIT132", ":", "return", "Mips", "::", "BBIT032", ";", "case", "Mips", "::", "BZ_B", ":", "return", "Mips", "::", "BNZ_B", ";", "case", "Mips", "::", "BZ_H", ":", "return", "Mips", "::", "BNZ_H", ";", "case", "Mips", "::", "BZ_W", ":", "return", "Mips", "::", "BNZ_W", ";", "case", "Mips", "::", "BZ_D", ":", "return", "Mips", "::", "BNZ_D", ";", "case", "Mips", "::", "BZ_V", ":", "return", "Mips", "::", "BNZ_V", ";", "case", "Mips", "::", "BNZ_B", ":", "return", "Mips", "::", "BZ_B", ";", "case", "Mips", "::", "BNZ_H", ":", "return", "Mips", "::", "BZ_H", ";", "case", "Mips", "::", "BNZ_W", ":", "return", "Mips", "::", "BZ_W", ";", "case", "Mips", "::", "BNZ_D", ":", "return", "Mips", "::", "BZ_D", ";", "case", "Mips", "::", "BNZ_V", ":", "return", "Mips", "::", "BZ_V", ";", "}", "}" ]

[ "getOppositeBranchOpc", "-", "Return", "the", "inverse", "of", "the", "specified", "opcode", ",", "e.g", "." ]

[ ")", ";" ]

[ "if", "(", "!", "Subtarget", "->", "isMisaligned128StoreSlow", "(", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ".", "hasMinSize", "(", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "<", "<NUM_LIT>", "||", "VT", "==", "MVT", "::", "v2i64", ")", "return", "SDValue", "(", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "!=", "<NUM_LIT>", "||", "S", "->", "getAlignment", "(", ")", ">=", "<NUM_LIT>", "||", "S", "->", "getAlignment", "(", ")", "<=", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "if", "(", "SDValue", "ReplacedSplat", "=", "replaceSplatVectorStore", "(", "DAG", ",", "*", "S", ")", ")", "return", "ReplacedSplat", ";", "SDLoc", "DL", "(", "S", ")", ";", "EVT", "HalfVT", "=", "VT", ".", "getHalfNumVectorElementsVT", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "unsigned", "NumElts", "=", "HalfVT", ".", "getVectorNumElements", "(", ")", ";", "SDValue", "SubVector0", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "DL", ",", "HalfVT", ",", "StVal", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i64", ")", ")", ";", "SDValue", "SubVector1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "DL", ",", "HalfVT", ",", "StVal", ",", "DAG", ".", "getConstant", "(", "NumElts", ",", "DL", ",", "MVT", "::", "i64", ")", ")", ";", "SDValue", "BasePtr", "=", "S", "->", "getBasePtr", "(" ]

[ "return", "CurDAG", "-", ">", "getTargetConstant", "(", "(", "(", "N", "-", ">", "getZExtValue", "(", ")", "+", "<NUM_LIT>", ")", ">", ">", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ",", "SDLoc", "(", "N", ")", ",", "N", "-", ">", "getValueType", "(", "<NUM_LIT>", ")", ")", ";" ]

[ "def", "LO10Sext", ":", "SDNodeXForm", "<", "imm", ",", "[", "{", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "SignExtend64", "<", "<NUM_LIT>", ">", "(", "N", "-", ">", "getZExtValue", "(", ")", ")", ",", "SDLoc", "(", "N", ")", ",", "N", "-", ">", "getValueType", "(", "<NUM_LIT>", ")", ")", ";", "}", "]", ">", ";", "def", "HI6", ":", "SDNodeXForm", "<", "imm", ",", "[", "{" ]

[ "static", "tree", "rs6000_mangle_decl_assembler_name", "(", "tree", "decl", ",", "tree", "id", ")", "{", "if", "(", "TARGET_FLOAT128_TYPE", "&&", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", "&&", "DECL_IS_UNDECLARED_BUILTIN", "(", "decl", ")", "&&", "DECL_BUILT_IN_CLASS", "(", "decl", ")", "==", "BUILT_IN_NORMAL", ")", "{", "built_in_function", "id", "=", "DECL_FUNCTION_CODE", "(", "decl", ")", ";", "const", "char", "*", "new", "name", "=", "NULL", ";", "if", "(", "id", "==", "complex_multiply_builtin_code", "(", "KCmode", ")", ")", "new", "name", "=", "<STR_LIT>", "__mulkc3", "<STR_LIT>", ";", "else", "if", "(", "id", "==", "complex_multiply_builtin_code", "(", "ICmode", ")", ")", "new", "name", "=", "<STR_LIT>", "__multc3", "<STR_LIT>", ";", "else", "if", "(", "id", "==", "complex_multiply_builtin_code", "(", "TCmode", ")", ")", "new", "name", "=", "(", "TARGET_IEEEQUAD", ")", "?", "<STR_LIT>", "__mulkc3", "<STR_LIT>", ":", "<STR_LIT>", "__multc3", "<STR_LIT>", ";", "else", "if", "(", "id", "==", "complex_divide_builtin_code", "(", "KCmode", ")", ")", "new", "name", "=", "<STR_LIT>", "__divkc3", "<STR_LIT>", ";", "else", "if", "(", "id", "==", "complex_divide_builtin_code", "(", "ICmode", ")", ")", "new", "name", "=", "<STR_LIT>", "__divtc3", "<STR_LIT>", ";", "else", "if", "(", "id", "==", "complex_divide_builtin_code", "(", "TCmode", ")", ")", "new", "name", "=", "(", "TARGET_IEEEQUAD", ")", "?", "<STR_LIT>", "__divkc3", "<STR_LIT>", ":", "<STR_LIT>", "__divtc3", "<STR_LIT>", ";", "if", "(", "new", "name", ")", "{", "if", "(", "TARGET_DEBUG_BUILTIN", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "Map complex mul/div => %s\\n", "<STR_LIT>", ",", "new", "name", ")", ";", "return", "get_identifier", "(", "new", "name", ")", ";", "}", "}", "if", "(", "TARGET_FLOAT128_TYPE", "&&", "TARGET_IEEEQUAD", "&&", "TARGET_LONG_DOUBLE_128", "&&", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", "&&", "DECL_IS_UNDECLARED_BUILTIN", "(", "decl", ")", "&&", "DECL_BUILT_IN_CLASS", "(", "decl", ")", "==", "BUILT_IN_NORMAL", ")", "{", "size_t", "len", "=", "IDENTIFIER_LENGTH", "(", "id", ")", ";", "const", "char", "*", "name", "=", "IDENTIFIER_POINTER", "(", "id", ")", ";", "char", "*", "new", "name", "=", "NULL", ";", "switch", "(", "DECL_FUNCTION_CODE", "(", "decl", ")", ")", "{", "case", "BUILT_IN_DREML", ":", "new", "name", "=", "xstrdup", "(", "<STR_LIT>", "__remainderieee128", "<STR_LIT>", ")", ";", "break", ";", "case", "BUILT_IN_GAMMAL", ":", "new", "name", "=", "xstrdup", "(", "<STR_LIT>", "__lgammaieee128", "<STR_LIT>", ")", ";", "break", ";", "case", "BUILT_IN_GAMMAL_R", ":", "case", "BUILT_IN_LGAMMAL_R", ":", "new", "name", "=", "xstrdup", "(", "<STR_LIT>", "__lgammaieee128_r", "<STR_LIT>", ")", ";", "break", ";", "case", "BUILT_IN_NEXTTOWARD", ":", "new", "name", "=", "xstrdup", "(", "<STR_LIT>", "__nexttoward_to_ieee128", "<STR_LIT>", ")", ";", "break", ";", "case", "BUILT_IN_NEXTTOWARDF", ":", "new", "name", "=", "xstrdup", "(", "<STR_LIT>", "__nexttowardf_to_ieee128", "<STR_LIT>", ")", ";", "break", ";", "case", "BUILT_IN_NEXTTOWARDL", ":", "new", "name", "=", "xstrdup", "(", "<STR_LIT>", "__nexttowardieee128", "<STR_LIT>", ")", ";", "break", ";", "case", "BUILT_IN_POW10L", ":", "new", "name", "=", "xstrdup", "(", "<STR_LIT>", "__exp10ieee128", "<STR_LIT>", ")", ";", "break", ";", "case", "BUILT_IN_SCALBL", ":", "new", "name", "=", "xstrdup", "(", "<STR_LIT>", "__scalbieee128", "<STR_LIT>", ")", ";", "break", ";", "case", "BUILT_IN_SIGNIFICANDL", ":", "new", "name", "=", "xstrdup", "(", "<STR_LIT>", "__significandieee128", "<STR_LIT>", ")", ";", "break", ";", "case", "BUILT_IN_SINCOSL", ":", "new", "name", "=", "xstrdup", "(", "<STR_LIT>", "__sincosieee128", "<STR_LIT>", ")", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "!", "new", "name", ")", "{", "size_t", "printf_len", "=", "strlen", "(", "<STR_LIT>", "printf", "<STR_LIT>", ")", ";", "size_t", "scanf_len", "=", "strlen", "(", "<STR_LIT>", "scanf", "<STR_LIT>", ")", ";", "size_t", "printf_chk_len", "=", "strlen", "(", "<STR_LIT>", "printf_chk", "<STR_LIT>", ")", ";", "if", "(", "len", ">=", "printf_len", "&&", "strcmp", "(", "name", "+", "len", "-", "printf_len", ",", "<STR_LIT>", "printf", "<STR_LIT>", ")", "==", "<NUM_LIT>", ")", "new", "name", "=", "xasprintf", "(", "<STR_LIT>", "__%sieee128", "<STR_LIT>", ",", "name", ")", ";", "else", "if", "(", "len", ">=", "scanf_len", "&&", "strcmp", "(", "name", "+", "len", "-", "scanf_len", ",", "<STR_LIT>", "scanf", "<STR_LIT>", ")", "==", "<NUM_LIT>", ")", "new", "name", "=", "xasprintf", "(", "<STR_LIT>", "__isoc99_%sieee128", "<STR_LIT>", ",", "name", ")", ";", "else", "if", "(", "len", ">=", "printf_chk_len", "&&", "strcmp", "(", "name", "+", "len", "-", "printf_chk_len", ",", "<STR_LIT>", "printf_chk", "<STR_LIT>", ")", "==", "<NUM_LIT>", ")", "new", "name", "=", "xasprintf", "(", "<STR_LIT>", "%sieee128", "<STR_LIT>", ",", "name", ")", ";", "else", "if", "(", "name", "[", "len", "-", "<NUM_LIT>", "]", "==", "'", "l", "'", ")", "{", "bool", "uses_ieee128_p", "=", "false", ";", "tree", "type", "=", "TREE_TYPE", "(", "decl", ")", ";", "machine_mode", "ret_mode", "=", "TYPE_MODE", "(", "type", ")", ";", "if", "(", "ret_mode", "==", "TFmode", "||", "ret_mode", "==", "TCmode", ")", "uses_ieee128_p", "=", "true", ";", "else", "{", "function_args_iterator", "args_iter", ";", "tree", "arg", ";", "FOREACH_FUNCTION_ARGS", "(", "type", ",", "arg", ",", "args_iter", ")", "{", "machine_mode", "arg_mode", "=", "TYPE_MODE", "(", "arg", ")", ";", "if", "(", "arg_mode", "==", "TFmode", "||", "arg_mode", "==", "TCmode", ")", "{", "uses_ieee128_p", "=", "true", ";", "break", ";", "}", "}", "}", "if", "(", "uses_ieee128_p", ")", "new", "name", "=", "xasprintf", "(", "<STR_LIT>", "__%.*sieee128", "<STR_LIT>", ",", "(", "int", ")", "(", "len", "-", "<NUM_LIT>", ")", ",", "name", ")", ";", "}", "}", "if", "(", "new", "name", ")", "{", "if", "(", "TARGET_DEBUG_BUILTIN", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "Map %s => %s\\n", "<STR_LIT>", ",", "name", ",", "new", "name", ")", ";", "id", "=", "get_identifier", "(", "new", "name", ")", ";", "free", "(", "new", "name", ")", ";", "}", "}", "return", "id", ";", "}" ]

[ "On", "64-bit", "Linux", "and", "Freebsd", "systems", ",", "possibly", "switch", "the", "long", "double", "library", "function", "names", "from", "<", "foo", ">", "l", "to", "<", "foo", ">", "f128", "if", "the", "default", "long", "double", "type", "is", "IEEE", "128-bit", ".", "Typically", ",", "with", "the", "C", "and", "C++", "languages", ",", "the", "standard", "math.h", "include", "file", "switches", "the", "names", "on", "systems", "that", "support", "long", "double", "as", "IEEE", "128-bit", ",", "but", "that", "does", "n't", "work", "if", "the", "user", "uses", "__builtin_", "<", "foo", ">", "l", "directly", ".", "In", "the", "future", ",", "glibc", "will", "export", "names", "like", "__ieee128_sinf128", "and", "we", "can", "switch", "to", "using", "those", "instead", "of", "using", "sinf128", ",", "which", "pollutes", "the", "user", "'s", "namespace", ".", "This", "will", "switch", "the", "names", "for", "Fortran", "math", "functions", "as", "well", "(", "which", "does", "n't", "use", "math.h", ")", ".", "However", ",", "Fortran", "needs", "other", "changes", "to", "the", "compiler", "and", "library", "before", "you", "can", "switch", "the", "real", "*", "16", "type", "at", "compile", "time", ".", "We", "use", "the", "TARGET_MANGLE_DECL_ASSEMBLER_NAME", "hook", "to", "change", "this", "name", ".", "We", "only", "do", "this", "transformation", "if", "the", "__float128", "type", "is", "enabled", ".", "This", "prevents", "us", "from", "doing", "the", "transformation", "on", "older", "32-bit", "ports", "that", "might", "have", "enabled", "using", "IEEE", "128-bit", "floating", "point", "as", "the", "default", "long", "double", "type", ".", "We", "also", "use", "the", "TARGET_MANGLE_DECL_ASSEMBLER_NAME", "hook", "to", "change", "the", "function", "names", "used", "for", "complex", "multiply", "and", "divide", "to", "the", "appropriate", "names", "." ]

[ "Address", ",", "Decoder", ")", ";" ]

[ "DecodeStatus", "status", ";", "unsigned", "d", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "unsigned", "pos2", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "unsigned", "pos1", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "unsigned", "s2", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "unsigned", "s1", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "unsigned", "is32Bit", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "if", "(", "!", "is32Bit", ")", "return", "MCDisassembler", "::", "Fail", ";", "status", "=", "DecodeDataRegsRegisterClass", "(", "Inst", ",", "d", ",", "Address", ",", "Decoder", ")", ";", "if", "(", "status", "!=", "MCDisassembler", "::", "Success", ")", "return", "status", ";", "status", "=", "DecodeDataRegsRegisterClass", "(", "Inst", ",", "s1", "," ]

[ "return", "CallResult", ".", "second", ";" ]

[ "if", "(", "ConstantSDNode", "*", "ConstantSrc", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Src", ")", ")", "if", "(", "ConstantSrc", "->", "getZExtValue", "(", ")", "==", "<NUM_LIT>", ")", "AEABILibcall", "=", "AEABI_MEMCLR", ";", "break", ";", "default", ":", "return", "SDValue", "(", ")", ";", "}", "enum", "{", "ALIGN1", "=", "<NUM_LIT>", ",", "ALIGN4", ",", "ALIGN8", "}", "AlignVariant", ";", "if", "(", "(", "Align", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "AlignVariant", "=", "ALIGN8", ";", "else", "if", "(", "(", "Align", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "AlignVariant", "=", "ALIGN4", ";", "else", "AlignVariant", "=", "ALIGN1", ";", "TargetLowering", "::", "ArgListTy", "Args", ";", "TargetLowering", "::", "ArgListEntry", "Entry", ";", "Entry", ".", "Ty", "=", "DAG", ".", "getDataLayout", "(", ")", ".", "getIntPtrType", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "Node", "=", "Dst", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "if", "(", "AEABILibcall", "==", "AEABI_MEMCLR", ")", "{", "Entry", ".", "Node", "=", "Size", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "}", "else", "if", "(", "AEABILibcall", "==", "AEABI_MEMSET", ")", "{", "Entry", ".", "Node", "=", "Size", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "if", "(", "Src", ".", "getValueType", "(", ")", ".", "bitsGT", "(", "MVT", "::", "i32", ")", ")", "Src", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "MVT", "::", "i32", ",", "Src", ")", ";", "else", "if", "(", "Src", ".", "getValueType", "(", ")", ".", "bitsLT", "(", "MVT", "::", "i32", ")", ")", "Src", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "MVT", "::", "i32", ",", "Src", ")", ";", "Entry", ".", "Node", "=", "Src", ";", "Entry", ".", "Ty", "=", "Type", "::", "getInt32Ty", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "IsSExt", "=", "false", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "}", "else", "{", "Entry", ".", "Node", "=", "Src", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Size", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "}", "char", "const", "*", "FunctionNames", "[", "<NUM_LIT>", "]", "[", "<NUM_LIT>", "]", "=", "{", "{", "<STR_LIT>", "__aeabi_memcpy", "<STR_LIT>", ",", "<STR_LIT>", "__aeabi_memcpy4", "<STR_LIT>", ",", "<STR_LIT>", "__aeabi_memcpy8", "<STR_LIT>", "}", ",", "{", "<STR_LIT>", "__aeabi_memmove", "<STR_LIT>", ",", "<STR_LIT>", "__aeabi_memmove4", "<STR_LIT>", ",", "<STR_LIT>", "__aeabi_memmove8", "<STR_LIT>", "}", ",", "{", "<STR_LIT>", "__aeabi_memset", "<STR_LIT>", ",", "<STR_LIT>", "__aeabi_memset4", "<STR_LIT>", ",", "<STR_LIT>", "__aeabi_memset8", "<STR_LIT>", "}", ",", "{", "<STR_LIT>", "__aeabi_memclr", "<STR_LIT>", ",", "<STR_LIT>", "__aeabi_memclr4", "<STR_LIT>", ",", "<STR_LIT>", "__aeabi_memclr8", "<STR_LIT>", "}", "}", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "DAG", ")", ";", "CLI", ".", "setDebugLoc", "(", "dl", ")", ".", "setChain", "(", "Chain", ")", ".", "setLibCallee", "(", "TLI", "->", "getLibcallCallingConv", "(", "LC", ")", ",", "Type", "::", "getVoidTy", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "DAG", ".", "getExternalSymbol", "(", "FunctionNames", "[", "AEABILibcall", "]", "[", "AlignVariant", "]", ",", "TLI", "->", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ",", "std", "::", "move", "(", "Args", ")", ")", ".", "setDiscardResult", "(", ")", ";", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "CallResult", "=", "TLI", "->", "LowerCallTo", "(", "CLI", ")", ";" ]

[ "Op0", ",", "Op1", ")", ")", "return", "TruncateArithmetic", "(", "Op0", ",", "Op1", ")", ";" ]

[ "if", "(", "Op0", "==", "Op1", ")", "return", "true", ";", "unsigned", "Opcode0", "=", "Op0", ".", "getOpcode", "(", ")", ";", "if", "(", "(", "Opcode0", "==", "ISD", "::", "ANY_EXTEND", "||", "Opcode0", "==", "ISD", "::", "SIGN_EXTEND", "||", "Opcode0", "==", "ISD", "::", "ZERO_EXTEND", ")", "&&", "Op0", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getScalarValueSizeInBits", "(", ")", "<=", "TruncSizeInBits", ")", "return", "true", ";", "unsigned", "Opcode1", "=", "Op1", ".", "getOpcode", "(", ")", ";", "if", "(", "(", "Opcode1", "==", "ISD", "::", "ANY_EXTEND", "||", "Opcode1", "==", "ISD", "::", "SIGN_EXTEND", "||", "Opcode1", "==", "ISD", "::", "ZERO_EXTEND", ")", "&&", "Op1", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getScalarValueSizeInBits", "(", ")", "<=", "TruncSizeInBits", ")", "return", "true", ";", "SDValue", "BC0", "=", "peekThroughOneUseBitcasts", "(", "Op0", ")", ";", "SDValue", "BC1", "=", "peekThroughOneUseBitcasts", "(", "Op1", ")", ";", "return", "ISD", "::", "isBuildVectorOfConstantSDNodes", "(", "BC0", ".", "getNode", "(", ")", ")", "||", "ISD", "::", "isBuildVectorOfConstantSDNodes", "(", "BC1", ".", "getNode", "(", ")", ")", ";", "}", ";", "auto", "TruncateArithmetic", "=", "[", "&", "]", "(", "SDValue", "N0", ",", "SDValue", "N1", ")", "{", "SDValue", "Trunc0", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "VT", ",", "N0", ")", ";", "SDValue", "Trunc1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "VT", ",", "N1", ")", ";", "return", "DAG", ".", "getNode", "(", "Opcode", ",", "DL", ",", "VT", ",", "Trunc0", ",", "Trunc1", ")", ";", "}", ";", "if", "(", "!", "N", "->", "isOnlyUserOf", "(", "Src", ".", "getNode", "(", ")", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "SDValue", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "case", "ISD", "::", "AND", ":", "case", "ISD", "::", "XOR", ":", "case", "ISD", "::", "OR", ":", "{", "SDValue", "Op0", "=", "Src", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Op1", "=", "Src", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "TLI", ".", "isOperationLegalOrPromote", "(", "Opcode", ",", "VT", ")", "&&", "IsRepeatedOpOrFreeTruncation", "(" ]

[ "&", "O", ")", "const", "{" ]

[ "void", "HexagonInstPrinter", "::", "printBranchOperand", "(", "MCInst", "const", "*", "MI", ",", "unsigned", "OpNo", ",", "raw_ostream" ]

[ "if", "(", "VECTOR_ALIGNMENT_P", "(", "mode", ")", ")", "return", "false", ";" ]

[ "if", "(", "TARGET_VSX", "&&", "VSX_REGNO_P", "(", "regno", ")", "&&", "(", "VECTOR_MEM_VSX_P", "(", "mode", ")", "||", "VECTOR_ALIGNMENT_P", "(", "mode", ")", "||", "reg_addr", "[", "mode", "]", ".", "scalar_in_vmx_p", "||", "mode", "==", "TImode", "||", "(", "TARGET_VADDUQM", "&&", "mode", "==", "V1TImode", ")", ")", ")", "{", "if", "(", "FP_REGNO_P", "(", "regno", ")", ")", "return", "FP_REGNO_P", "(", "last_regno", ")", ";", "if", "(", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "<", "<NUM_LIT>", "&&", "!", "reg_addr", "[", "mode", "]", ".", "scalar_in_vmx_p", ")", "return", "<NUM_LIT>", ";", "return", "ALTIVEC_REGNO_P", "(", "last_regno", ")", ";", "}", "}", "if", "(", "INT_REGNO_P", "(", "regno", ")", ")", "return", "INT_REGNO_P", "(", "last_regno", ")", ";", "if", "(", "FP_REGNO_P", "(", "regno", ")", ")", "{" ]

[ "}" ]

[ "assert", "(", "Subtarget", ".", "hasBWI", "(", ")", "&&", "<STR_LIT>", "Expected AVX512BW target!", "<STR_LIT>", ")", ";", "assert", "(", "Subtarget", ".", "is32Bit", "(", ")", "&&", "<STR_LIT>", "Expecting 32 bit target", "<STR_LIT>", ")", ";", "assert", "(", "Arg", ".", "getValueType", "(", ")", "==", "MVT", "::", "i64", "&&", "<STR_LIT>", "Expecting 64 bit value", "<STR_LIT>", ")", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "NextVA", ".", "isRegLoc", "(", ")", "&&", "<STR_LIT>", "The value should reside in two registers", "<STR_LIT>", ")", ";", "Arg", "=", "DAG", ".", "getBitcast", "(", "MVT", "::", "i64", ",", "Arg", ")", ";", "SDValue", "Lo", ",", "Hi", ";", "Lo", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_ELEMENT", ",", "Dl", ",", "MVT", "::", "i32", ",", "Arg", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "Dl", ",", "MVT", "::", "i32", ")", ")", ";", "Hi", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_ELEMENT", ",", "Dl", ",", "MVT", "::", "i32", ",", "Arg", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "Dl", ",", "MVT", "::", "i32", ")", ")", ";", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "VA", ".", "getLocReg", "(", ")", ",", "Lo", ")", ")", ";", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "NextVA", ".", "getLocReg", "(", ")", ",", "Hi", ")", ")", ";" ]

[ "EndLoc", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";" ]

[ "StartLoc", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "RegNo", "=", "parseRegister", "(", "false", ")", ";" ]

[ ")", ";" ]

[ "addPass", "(", "createPatmosFunctionSplitterPass", "(", "getPatmosTargetMachine", "(", ")", ")", ")", ";", "}", "addPass", "(", "createPatmosDelaySlotKillerPass", "(", "getPatmosTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createPatmosEnsureAlignmentPass", "(", "getPatmosTargetMachine", "(", ")", ")" ]

[ "const", "SDNode", "*", "N", ")", "{" ]

[ "Value", "*", "ARMIREmitter", "::", "visitPRELOAD", "(" ]

[ "MVT", "getRegisterTypeForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ")", "const", "override", "{", "if", "(", "VT", ".", "isVector", "(", ")", "&&", "VT", ".", "getSizeInBits", "(", ")", "==", "<NUM_LIT>", "&&", "VT", ".", "getVectorNumElements", "(", ")", "==", "<NUM_LIT>", ")", "return", "MVT", "::", "v16i8", ";", "return", "TargetLowering", "::", "getRegisterTypeForCallingConv", "(", "Context", ",", "CC", ",", "VT", ")", ";", "}" ]

[ "Certain", "combinations", "of", "ABIs", ",", "Targets", "and", "features", "require", "that", "types", "are", "legal", "for", "some", "operations", "and", "not", "for", "other", "operations", "." ]

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

[ "def", "J4_cmpgt_tp0_jump_nt", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "GeneralSubRegs", ":", "$", "Rs16", ",", "GeneralSubRegs", ":", "$", "Rt16", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_56336eb0", ",", "TypeCJ", ">", ",", "Enc_6a5972", ",", "PredRel", "{", "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", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P0", "]", ";", "let", "Defs", "=", "[", "P0", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";" ]

[ "SDValue", "SPUTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "TargetMachine", "&", "TM", "=", "getTargetMachine", "(", ")", ";", "const", "SPUSubtarget", "*", "ST", "=", "SPUTM", ".", "getSubtargetImpl", "(", ")", ";", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "SDValue", "Op0", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "EVT", "NodeVT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "EVT", "Op0VT", "=", "Op0", ".", "getValueType", "(", ")", ";", "SDValue", "Result", ";", "DebugLoc", "dl", "=", "N", "->", "getDebugLoc", "(", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ADD", ":", "{", "SDValue", "Op1", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Op0", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Op1", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "SDValue", "IndirectArg", "=", "Op0", ",", "AddArg", "=", "Op1", ";", "if", "(", "Op1", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "IndirectArg", "=", "Op1", ";", "AddArg", "=", "Op0", ";", "}", "if", "(", "isa", "<", "ConstantSDNode", ">", "(", "AddArg", ")", ")", "{", "ConstantSDNode", "*", "CN0", "=", "cast", "<", "ConstantSDNode", ">", "(", "AddArg", ")", ";", "SDValue", "IndOp1", "=", "IndirectArg", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "CN0", "->", "isNullValue", "(", ")", ")", "{", "if", "(", "DebugFlag", "&&", "isCurrentDebugType", "(", "DEBUG_TYPE", ")", ")", "{", "errs", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", "<<", "<STR_LIT>", "Replace: (add (SPUindirect <arg>, <arg>), 0)\\n", "<STR_LIT>", "<<", "<STR_LIT>", "With: (SPUindirect <arg>, <arg>)\\n", "<STR_LIT>", ";", "}", "return", "IndirectArg", ";", "}", "else", "if", "(", "isa", "<", "ConstantSDNode", ">", "(", "IndOp1", ")", ")", "{", "ConstantSDNode", "*", "CN1", "=", "cast", "<", "ConstantSDNode", ">", "(", "IndOp1", ")", ";", "int64_t", "combinedConst", "=", "CN0", "->", "getSExtValue", "(", ")", "+", "CN1", "->", "getSExtValue", "(", ")", ";", "SDValue", "combinedValue", "=", "DAG", ".", "getConstant", "(", "combinedConst", ",", "Op0VT", ")", ";", "if", "(", "DebugFlag", "&&", "isCurrentDebugType", "(", "DEBUG_TYPE", ")", ")", "{", "errs", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", "<<", "<STR_LIT>", "Replace: (add (SPUindirect <arg>, ", "<STR_LIT>", "<<", "CN1", "->", "getSExtValue", "(", ")", "<<", "<STR_LIT>", "), ", "<STR_LIT>", "<<", "CN0", "->", "getSExtValue", "(", ")", "<<", "<STR_LIT>", ")\\n", "<STR_LIT>", "<<", "<STR_LIT>", "With: (SPUindirect <arg>, ", "<STR_LIT>", "<<", "combinedConst", "<<", "<STR_LIT>", ")\\n", "<STR_LIT>", ";", "}", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "Op0VT", ",", "IndirectArg", ",", "combinedValue", ")", ";", "}", "}", "}", "break", ";", "}", "case", "ISD", "::", "SIGN_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND", ":", "case", "ISD", "::", "ANY_EXTEND", ":", "{", "if", "(", "Op0", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "NodeVT", "==", "Op0VT", ")", "{", "if", "(", "DebugFlag", "&&", "isCurrentDebugType", "(", "DEBUG_TYPE", ")", ")", "{", "errs", "(", ")", "<<", "<STR_LIT>", "\\nReplace: ", "<STR_LIT>", ";", "N", "->", "dump", "(", "&", "DAG", ")", ";", "errs", "(", ")", "<<", "<STR_LIT>", "\\nWith: ", "<STR_LIT>", ";", "Op0", ".", "getNode", "(", ")", "->", "dump", "(", "&", "DAG", ")", ";", "errs", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "}", "return", "Op0", ";", "}", "break", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "if", "(", "!", "ST", "->", "usingLargeMem", "(", ")", "&&", "Op0", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "ConstantSDNode", "*", "CN", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "CN", "!=", "<NUM_LIT>", "&&", "CN", "->", "isNullValue", "(", ")", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "<STR_LIT>", "Replace: ", "<STR_LIT>", ")", ";", "DEBUG", "(", "N", "->", "dump", "(", "&", "DAG", ")", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "<STR_LIT>", "\\nWith: ", "<STR_LIT>", ")", ";", "DEBUG", "(", "Op0", ".", "getNode", "(", ")", "->", "dump", "(", "&", "DAG", ")", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "return", "Op0", ";", "}", "}", "else", "if", "(", "Op0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", ")", "{", "SDValue", "Op1", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "ConstantSDNode", "*", "CN1", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op1", ")", ")", "{", "if", "(", "CN1", "->", "isNullValue", "(", ")", ")", "{", "if", "(", "DebugFlag", "&&", "isCurrentDebugType", "(", "DEBUG_TYPE", ")", ")", "{", "errs", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", "<<", "<STR_LIT>", "Replace: (SPUindirect (add <arg>, <arg>), 0)\\n", "<STR_LIT>", "<<", "<STR_LIT>", "With: (SPUindirect <arg>, <arg>)\\n", "<STR_LIT>", ";", "}", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "Op0VT", ",", "Op0", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op0", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "}", "}", "}", "break", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "SDValue", "Op1", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "ConstantSDNode", "*", "CN", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op1", ")", ")", "{", "if", "(", "CN", "->", "isNullValue", "(", ")", ")", "{", "Result", "=", "Op0", ";", "}", "}", "break", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "switch", "(", "Op0", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ANY_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND", ":", "case", "ISD", "::", "SIGN_EXTEND", ":", "{", "SDValue", "Op00", "=", "Op0", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Op00", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "SDValue", "Op000", "=", "Op00", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Op000", ".", "getValueType", "(", ")", "==", "NodeVT", ")", "{", "Result", "=", "Op000", ";", "}", "}", "break", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "Result", "=", "Op0", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "break", ";", "}", "}", "break", ";", "}", "}", "if", "(", "Result", ".", "getNode", "(", ")", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "<STR_LIT>", "\\nReplace.SPU: ", "<STR_LIT>", ")", ";", "DEBUG", "(", "N", "->", "dump", "(", "&", "DAG", ")", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "<STR_LIT>", "\\nWith: ", "<STR_LIT>", ")", ";", "DEBUG", "(", "Result", ".", "getNode", "(", ")", "->", "dump", "(", "&", "DAG", ")", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "}", "return", "Result", ";", "}" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "for", "(", "i", "=", "<NUM_LIT>", ";", "(", "i", "+", "nelt_mode", "<=", "length", ")", ";", "i", "+=", "nelt_mode", ")", "{" ]

[ "unsigned", "int", "i", ",", "nelt_v16", ",", "nelt_v8", ",", "nelt_mode", ";", "rtx", "dst", ",", "mem", ";", "rtx", "val_vec", ",", "reg", ";", "rtx", "(", "*", "gen_func", ")", "(", "rtx", ",", "rtx", ")", ";", "machine_mode", "mode", ";", "unsigned", "HOST_WIDE_INT", "v", "=", "value", ";", "unsigned", "int", "offset", "=", "<NUM_LIT>", ";", "gcc_assert", "(", "(", "align", "&", "<NUM_LIT>", ")", "!=", "<NUM_LIT>", ")", ";", "nelt_v8", "=", "GET_MODE_NUNITS", "(", "V8QImode", ")", ";", "nelt_v16", "=", "GET_MODE_NUNITS", "(", "V16QImode", ")", ";", "if", "(", "length", ">=", "nelt_v16", ")", "{", "mode", "=", "V16QImode", ";", "gen_func", "=", "gen_movmisalignv16qi", ";", "}", "else", "{", "mode", "=", "V8QImode", ";", "gen_func", "=", "gen_movmisalignv8qi", ";", "}", "nelt_mode", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "gcc_assert", "(", "length", ">=", "nelt_mode", ")", ";", "if", "(", "!", "arm_block_set_vect_profit_p", "(", "length", ",", "align", ",", "mode", ")", ")", "return", "false", ";", "dst", "=", "copy_addr_to_reg", "(", "XEXP", "(", "dstbase", ",", "<NUM_LIT>", ")", ")", ";", "mem", "=", "adjust_automodify_address", "(", "dstbase", ",", "mode", ",", "dst", ",", "offset", ")", ";", "v", "=", "sext_hwi", "(", "v", ",", "BITS_PER_WORD", ")", ";", "reg", "=", "gen_reg_rtx", "(", "mode", ")", ";", "val_vec", "=", "gen_const_vec_duplicate", "(", "mode", ",", "GEN_INT", "(", "v", ")", ")", ";", "emit_move_insn", "(", "reg", ",", "val_vec", ")", ";" ]

[ "<FIXS>", "(", "!", "(", "Mask", "&", "<NUM_LIT>", ")", "||", "CmpVT", "==", "MVT", "::", "i8", "||", "hasNoSignedComparisonUses", "(", "Node", ")", ")", ")", "{", "<FIXE>", "<FIXS>", "(", "!", "(", "Mask", "&", "<NUM_LIT>", ")", "||", "CmpVT", "==", "MVT", "::", "i16", "||", "hasNoSignedComparisonUses", "(", "Node", ")", ")", ")", "{", "<FIXE>" ]

[ "int", "SubRegOp", ";", "unsigned", "Op", ";", "if", "(", "isUInt", "<NUM_LIT>", ">", "(", "Mask", ")", "&&", "<BUGS>", "(", "!", "(", "Mask", "&", "<NUM_LIT>", ")", "||", "hasNoSignedComparisonUses", "(", "Node", ")", ")", ")", "{", "<BUGE>", "VT", "=", "MVT", "::", "i8", ";", "SubRegOp", "=", "X86", "::", "sub_8bit", ";", "Op", "=", "X86", "::", "TEST8ri", ";", "}", "else", "if", "(", "OptForMinSize", "&&", "isUInt", "<NUM_LIT>", ">", "(", "Mask", ")", "&&", "<BUGS>", "(", "!", "(", "Mask", "&", "<NUM_LIT>", ")", "||", "hasNoSignedComparisonUses", "(", "Node", ")", ")", ")", "{", "<BUGE>" ]

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

[ "return", "_", "_", "builtin_altivec_vcmpeqfp_p", "(", "_", "_", "CR6_EQ_REV", ",", "a1" ]

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

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

[ "return", "CurDAG", "-", ">", "getTargetConstant", "(", "N", "-", ">", "getZExtValue", "(", ")", "/", "<NUM_LIT>", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i64", ")", ";" ]

[ "return", "CurDAG", "-", ">", "getTargetConstant", "(", "N", "-", ">", "getZExtValue", "(", ")", "/", "<NUM_LIT>", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i64", ")", ";", "}", "]", ">", ";", "def", "UImmS4XForm", ":", "SDNodeXForm", "<", "imm", ",", "[", "{", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "N", "-", ">", "getZExtValue", "(", ")", "/", "<NUM_LIT>", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i64", ")", ";", "}", "]", ">", ";", "def", "UImmS8XForm", ":", "SDNodeXForm", "<", "imm", ",", "[", "{" ]

[ "OPERAND_REG_INLINE_C_INT16", ":" ]

[ "case", "AMDGPU", "::", "OPERAND_REG_IMM_INT32", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_FP32", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_INT32", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_FP32", ":", "return", "<NUM_LIT>", ";", "case", "AMDGPU", "::", "OPERAND_REG_IMM_INT64", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_FP64", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_INT64", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_FP64", ":", "return", "<NUM_LIT>", ";", "case", "AMDGPU", "::", "OPERAND_REG_IMM_INT16", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_FP16", ":", "case", "AMDGPU", "::" ]

[ "<NUM_LIT>", ";" ]

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

[ "SDValue", "Ops", "[", "]", "=", "{", "TrueV", ",", "FalseV", ",", "TargetCC", ",", "Flag", "}", ";" ]

[ "SDValue", "FalseV", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "ISD", "::", "CondCode", "CC", "=", "cast", "<", "CondCodeSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "get", "(", ")", ";", "SDLoc", "dl", "(", "Op", ")", ";", "SDValue", "TargetCC", ";", "SDValue", "Flag", "=", "FISC_EmitCMP", "(", "LHS", ",", "RHS", ",", "TargetCC", ",", "CC", ",", "dl", ",", "DAG", ")", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "Op", ".", "getValueType", "(", ")", ",", "MVT", "::", "Glue", ")", ";" ]

[ ",", "shr_imm8", ">", "{" ]

[ "def", "MVE_VQSHRUNs16bh", ":", "MVE_VxQRSHRUN", "<", "<STR_LIT>", ",", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>" ]

[ "void", "PPCInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "if", "(", "PPC", "::", "F8RCRegClass", ".", "contains", "(", "DestReg", ")", "&&", "PPC", "::", "VSLRCRegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "unsigned", "SuperReg", "=", "TRI", "->", "getMatchingSuperReg", "(", "DestReg", ",", "PPC", "::", "sub_64", ",", "&", "PPC", "::", "VSRCRegClass", ")", ";", "if", "(", "SrcReg", "==", "SuperReg", ")", "return", ";", "DestReg", "=", "SuperReg", ";", "}", "else", "if", "(", "PPC", "::", "VRRCRegClass", ".", "contains", "(", "DestReg", ")", "&&", "PPC", "::", "VSHRCRegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "unsigned", "SuperReg", "=", "TRI", "->", "getMatchingSuperReg", "(", "DestReg", ",", "PPC", "::", "sub_128", ",", "&", "PPC", "::", "VSRCRegClass", ")", ";", "if", "(", "SrcReg", "==", "SuperReg", ")", "return", ";", "DestReg", "=", "SuperReg", ";", "}", "else", "if", "(", "PPC", "::", "F8RCRegClass", ".", "contains", "(", "SrcReg", ")", "&&", "PPC", "::", "VSLRCRegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "unsigned", "SuperReg", "=", "TRI", "->", "getMatchingSuperReg", "(", "SrcReg", ",", "PPC", "::", "sub_64", ",", "&", "PPC", "::", "VSRCRegClass", ")", ";", "if", "(", "DestReg", "==", "SuperReg", ")", "return", ";", "SrcReg", "=", "SuperReg", ";", "}", "else", "if", "(", "PPC", "::", "VRRCRegClass", ".", "contains", "(", "SrcReg", ")", "&&", "PPC", "::", "VSHRCRegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "unsigned", "SuperReg", "=", "TRI", "->", "getMatchingSuperReg", "(", "SrcReg", ",", "PPC", "::", "sub_128", ",", "&", "PPC", "::", "VSRCRegClass", ")", ";", "if", "(", "DestReg", "==", "SuperReg", ")", "return", ";", "SrcReg", "=", "SuperReg", ";", "}", "unsigned", "Opc", ";", "if", "(", "PPC", "::", "GPRCRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "PPC", "::", "OR", ";", "else", "if", "(", "PPC", "::", "G8RCRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "PPC", "::", "OR8", ";", "else", "if", "(", "PPC", "::", "F4RCRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "PPC", "::", "FMR", ";", "else", "if", "(", "PPC", "::", "CRRCRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "PPC", "::", "MCRF", ";", "else", "if", "(", "PPC", "::", "VRRCRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "PPC", "::", "VOR", ";", "else", "if", "(", "PPC", "::", "VSRCRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "PPC", "::", "XXLOR", ";", "else", "if", "(", "PPC", "::", "CRBITRCRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "PPC", "::", "CROR", ";", "else", "llvm_unreachable", "(", "<STR_LIT>", "Impossible reg-to-reg copy", "<STR_LIT>", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "get", "(", "Opc", ")", ";", "if", "(", "MCID", ".", "getNumOperands", "(", ")", "==", "<NUM_LIT>", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "MCID", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "else", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "MCID", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}" ]

[ "}", "Branch", "Analysis", "&", "Modification" ]

[ ";" ]

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

[ "_", "_", "p", ")", ";" ]

[ "_", "_", "arm_vmaxnmq_m_f16", "(", "float16x8_t", "_", "_", "inactive", ",", "float16x8_t", "_", "_", "a", ",", "float16x8_t", "_", "_", "b", ",", "mve_pred16_t", "_", "_", "p", ")", "{", "return", "_", "_", "builtin_mve_vmaxnmq_m_fv8hf", "(", "_", "_", "inactive", ",", "_", "_", "a", ",", "_", "_", "b", "," ]

[ "Name", ";" ]

[ "const", "char", "*", "RegNames", "[", "]", "=", "{", "<STR_LIT>", "r8_usr", "<STR_LIT>", ",", "<STR_LIT>", "r9_usr", "<STR_LIT>", ",", "<STR_LIT>", "r10_usr", "<STR_LIT>", ",", "<STR_LIT>", "r11_usr", "<STR_LIT>", ",", "<STR_LIT>", "r12_usr", "<STR_LIT>", ",", "<STR_LIT>", "sp_usr", "<STR_LIT>", ",", "<STR_LIT>", "lr_usr", "<STR_LIT>", ",", "<STR_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "r8_fiq", "<STR_LIT>", ",", "<STR_LIT>", "r9_fiq", "<STR_LIT>", ",", "<STR_LIT>", "r10_fiq", "<STR_LIT>", ",", "<STR_LIT>", "r11_fiq", "<STR_LIT>", ",", "<STR_LIT>", "r12_fiq", "<STR_LIT>", ",", "<STR_LIT>", "sp_fiq", "<STR_LIT>", ",", "<STR_LIT>", "lr_fiq", "<STR_LIT>", ",", "<STR_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "lr_irq", "<STR_LIT>", ",", "<STR_LIT>", "sp_irq", "<STR_LIT>", ",", "<STR_LIT>", "lr_svc", "<STR_LIT>", ",", "<STR_LIT>", "sp_svc", "<STR_LIT>", ",", "<STR_LIT>", "lr_abt", "<STR_LIT>", ",", "<STR_LIT>", "sp_abt", "<STR_LIT>", ",", "<STR_LIT>", "lr_und", "<STR_LIT>", ",", "<STR_LIT>", "sp_und", "<STR_LIT>", ",", "<STR_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "lr_mon", "<STR_LIT>", ",", "<STR_LIT>", "sp_mon", "<STR_LIT>", ",", "<STR_LIT>", "elr_hyp", "<STR_LIT>", ",", "<STR_LIT>", "sp_hyp", "<STR_LIT>", "}", ";", "const", "char", "*", "Name", "=", "RegNames", "[", "SysM", "]", ";", "assert", "(", "Name", "[", "<NUM_LIT>", "]", "&&", "<STR_LIT>", "invalid banked register operand", "<STR_LIT>", ")", ";", "O", "<<" ]

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

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

[ "int_arm_neon_vmins", ",", "FMINddd", ">", ";" ]

[ "def", ":", "Neon_Scalar_GeneralMath3D_pattern", "<" ]

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

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

[ "}" ]

[ "s", "=", "gen_rtx_EQ", "(", "QImode", ",", "flags", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "d", ",", "s", ")", ")", ";", "d", "=", "gen_lowpart", "(", "QImode", ",", "high", "[", "<NUM_LIT>", "]", ")", ";", "d", "=", "gen_rtx_STRICT_LOW_PART", "(", "VOIDmode", ",", "d", ")", ";", "s", "=", "gen_rtx_NE", "(", "QImode", ",", "flags", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "d", ",", "s", ")", ")", ";", "}", "else", "{", "rtx", "(", "*", "gen_lshr3", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "rtx", "(", "*", "gen_and3", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "rtx", "(", "*", "gen_xor3", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "HOST_WIDE_INT", "bits", ";", "rtx", "x", ";", "if", "(", "mode", "==", "DImode", ")", "{", "gen_lshr3", "=", "gen_lshrsi3", ";", "gen_and3", "=", "gen_andsi3", ";", "gen_xor3", "=", "gen_xorsi3", ";", "bits", "=", "<NUM_LIT>", ";", "}", "else", "{", "gen_lshr3", "=", "gen_lshrdi3", ";", "gen_and3", "=", "gen_anddi3", ";", "gen_xor3", "=", "gen_xordi3", ";", "bits", "=", "<NUM_LIT>", ";", "}", "if", "(", "TARGET_PARTIAL_REG_STALL", "&&", "!", "optimize_insn_for_size_p", "(", ")", ")", "x", "=", "gen_rtx_ZERO_EXTEND", "(", "half_mode", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "else", "x", "=", "gen_lowpart", "(", "half_mode", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "high", "[", "<NUM_LIT>", "]", ",", "x", ")", ")", ";", "emit_insn", "(", "gen_lshr3", "(", "high", "[", "<NUM_LIT>", "]", ",", "high", "[", "<NUM_LIT>", "]", ",", "GEN_INT", "(", "bits", ")", ")", ")", ";", "emit_insn", "(", "gen_and3", "(", "high", "[", "<NUM_LIT>", "]", ",", "high", "[", "<NUM_LIT>", "]", ",", "const1_rtx", ")", ")", ";", "emit_move_insn", "(", "low", "[", "<NUM_LIT>", "]", ",", "high", "[", "<NUM_LIT>", "]", ")", ";", "emit_insn", "(", "gen_xor3", "(", "low", "[", "<NUM_LIT>", "]", ",", "low", "[", "<NUM_LIT>", "]", ",", "const1_rtx", ")", ")", ";", "}", "emit_insn", "(", "gen_ashl3", "(", "low", "[", "<NUM_LIT>", "]", ",", "low", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", ";", "emit_insn", "(", "gen_ashl3", "(", "high", "[", "<NUM_LIT>", "]", ",", "high", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", ";", "return", ";", "}", "if", "(", "operands", "[", "<NUM_LIT>", "]", "==", "constm1_rtx", ")", "{", "emit_move_insn", "(", "low", "[", "<NUM_LIT>", "]", ",", "constm1_rtx", ")", ";", "if", "(", "optimize_insn_for_size_p", "(", ")", ")", "emit_move_insn", "(", "high", "[", "<NUM_LIT>", "]", ",", "low", "[", "<NUM_LIT>", "]", ")", ";", "else", "emit_move_insn", "(", "high", "[", "<NUM_LIT>", "]", ",", "constm1_rtx", ")", ";", "}", "else", "{", "gen_shld", "=", "mode", "==", "DImode", "?", "gen_x86_shld", ":", "gen_x86_64_shld", ";", "if", "(", "!", "rtx_equal_p", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "emit_move_insn", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "split_double_mode", "(", "mode", ",", "operands", ",", "<NUM_LIT>", ",", "low", ",", "high", ")", ";", "emit_insn", "(", "gen_shld", "(", "high", "[", "<NUM_LIT>", "]", ",", "low", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", ";", "}", "emit_insn", "(", "gen_ashl3", "(", "low", "[", "<NUM_LIT>", "]", ",", "low", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", ";", "if", "(", "TARGET_CMOVE", "&&", "scratch", ")", "{", "ix86_expand_clear", "(", "scratch", ")", ";", "emit_insn", "(", "gen_x86_shift_adj_1", "(", "half_mode", ",", "high", "[", "<NUM_LIT>", "]", ",", "low", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "scratch", ")", ")", ";" ]

[ "a", ";" ]

[ "return", "(", "uint32x2_t", ")", "_", "_" ]

[ ")" ]

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

[ "<FIXS>", "if", "(", "useSVEForFixedLengthVectorVT", "(", "VT", ",", "Subtarget", "->", "forceStreamingCompatibleSVE", "(", ")", ")", ")", "<FIXE>" ]

[ "return", "DAG", ".", "getAnyExtOrTrunc", "(", "Extract", ",", "DL", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "}", "<BUGS>", "if", "(", "useSVEForFixedLengthVectorVT", "(", "VT", ")", ")", "<BUGE>", "return", "LowerFixedLengthExtractVectorElt", "(", "Op", ",", "DAG", ")", ";" ]

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

[ "bool", "MipsAsmParser", "::", "parseSetMsaDirective", "(", ")", "{", "MCAsmParser", "&", "Parser", "=", "getParser", "(", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "reportParseError", "(", "<STR_LIT>", "unexpected token, expected end of statement", "<STR_LIT>", ")", ";", "setFeatureBits", "(", "Mips", "::", "FeatureMSA", ",", "<STR_LIT>", "msa", "<STR_LIT>", ")", ";", "getTargetStreamer", "(", ")", "." ]

[ ">", ";" ]

[ "def", "VLD3DUPq32OddPseudo", ":", "VLDQQQQPseudo", "<", "IIC_VLD3dup", ">", ",", "Sched", "<", "[", "WriteVLD2", "]" ]

[ "let", "ParserMatchClass", "=", "ArithmeticShifterOperand", ";" ]

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

[ "]" ]

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

[ "NOT_KNOWN", ";" ]

[ "static", "void", "process_postponed_content_update", "(", "void", ")", "{", "if", "(", "saved_update_index", "!=", "NOT_KNOWN", ")", "{", "update_content", "(", "saved_update_index", ",", "saved_update_value", ",", "saved_update_mode", ")", ";", "saved_update_index", "=" ]

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

[ "(", "sign_extend", ":", "DI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<BUGS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>" ]

[ "<FIXS>", "Inst", ".", "RemoveOperand", "(", "<NUM_LIT>", ")", ";", "Inst", ".", "addOperand", "(", "MachineOperand", "::", "CreateImm", "(", "Offset", ")", ")", ";", "Inst", ".", "addOperand", "(", "MachineOperand", "::", "CreateImm", "(", "BitWidth", ")", ")", ";", "<FIXE>", "<FIXS>", "bool", "HasDst", "=", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isDef", "(", ")", ";", "<FIXE>", "<FIXS>", "const", "TargetRegisterClass", "*", "NewDstRC", "=", "getDestEquivalentVGPRClass", "(", "Inst", ")", ";", "<FIXE>", "<FIXS>", "unsigned", "DstReg", "=", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "<FIXE>" ]

[ "uint32_t", "Offset", "=", "Imm", "&", "<NUM_LIT>", ";", "uint32_t", "BitWidth", "=", "(", "Imm", "&", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "<BUGS>", "Inst", "->", "RemoveOperand", "(", "<NUM_LIT>", ")", ";", "Inst", "->", "addOperand", "(", "MachineOperand", "::", "CreateImm", "(", "Offset", ")", ")", ";", "Inst", "->", "addOperand", "(", "MachineOperand", "::", "CreateImm", "(", "BitWidth", ")", ")", ";", "<BUGE>", "}", "<BUGS>", "bool", "HasDst", "=", "Inst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "Inst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isDef", "(", ")", ";", "<BUGE>", "unsigned", "NewDstReg", "=", "AMDGPU", "::", "NoRegister", ";", "if", "(", "HasDst", ")", "{", "<BUGS>", "const", "TargetRegisterClass", "*", "NewDstRC", "=", "getDestEquivalentVGPRClass", "(", "*", "Inst", ")", ";", "<BUGE>", "if", "(", "!", "NewDstRC", ")", "continue", ";", "<BUGS>", "unsigned", "DstReg", "=", "Inst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "<BUGE>", "NewDstReg", "=", "MRI", ".", "createVirtualRegister", "(", "NewDstRC", ")", ";", "MRI", ".", "replaceRegWith", "(", "DstReg", ",", "NewDstReg", ")", ";", "}" ]

[ "_", "a", ")", "{" ]

[ "vld1_p64", "(", "const", "poly64_t", "*", "_" ]

[ "if", "(", "!", "GET_MODE_2XWIDER_MODE", "(", "GET_MODE", "(", "op0", ")", ")", ".", "exists", "(", "&", "v2mode", ")", ")", "return", "false", ";" ]

[ "static", "bool", "mips_expand_vselect_vconcat", "(", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ",", "const", "unsigned", "char", "*", "perm", ",", "unsigned", "nelt", ")", "{", "machine_mode", "v2mode", ";", "rtx", "x", ";" ]

[ "<STR_LIT>", ";" ]

[ "let", "PrintMethod", "=" ]

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

[ "def", ":", "InstRW", "[", "CortexA510Write", "<NUM_LIT>", ",", "CortexA510UnitVALU", ">", "]", ",", "(", "instregex", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ")", ">", ";", "<BUGS>", "def", ":", "InstRW", "[", "CortexA510Write", "<NUM_LIT>", ",", "CortexA510UnitVALU", ">", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "CortexA510Write", "<NUM_LIT>", ",", "CortexA510UnitVALU", ">", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGE>", "def", ":", "InstRW", "[", "CortexA510Write", "<NUM_LIT>", ",", "CortexA510UnitVALU", ">", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";" ]

[ "<FIXS>", "if", "(", "VT", ".", "isVector", "(", ")", ")", "{", "assert", "(", "getTypeAction", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "VT", ")", "==", "TypeWidenVector", "&&", "<STR_LIT>", "Unexpected type action!", "<STR_LIT>", ")", ";", "<FIXE>" ]

[ "case", "ISD", "::", "SREM", ":", "case", "ISD", "::", "UREM", ":", "{", "EVT", "VT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "<BUGS>", "if", "(", "getTypeAction", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "VT", ")", "==", "TypeWidenVector", ")", "{", "<BUGE>" ]

[ "<FIXS>", "clampmod0", ":", "$", "clamp", ",", "<FIXE>" ]

[ "(", "ins", "Src0Mod", ":", "$", "src0_modifiers", ",", "Src0RC", ":", "$", "src0", ",", "Src1Mod", ":", "$", "src1_modifiers", ",", "Src1RC", ":", "$", "src1", ",", "Src2Mod", ":", "$", "src2_modifiers", ",", "Src2RC", ":", "$", "src2", ",", "<BUGS>", "clampmod", ":", "$", "clamp", ",", "<BUGE>", "op_sel", ":", "$", "op_sel", ",", "op_sel_hi", ":", "$", "op_sel_hi", ",", "neg_lo", ":", "$", "neg_lo", ",", "neg_hi", ":", "$", "neg_hi", ")", ",", "(", "ins", "Src0Mod", ":", "$", "src0_modifiers", ",", "Src0RC", ":", "$", "src0", "," ]

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

[ "unsigned", "Opc", "=", "Def", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "!=", "TargetOpcode", "::", "G_SHL", "&&", "Opc", "!=", "TargetOpcode", "::", "G_ASHR", "&&", "Opc", "!=", "TargetOpcode", "::", "G_LSHR", ")", "return", "<NUM_LIT>", ";", "auto", "MaybeShiftAmt", "=", "getIConstantVRegValWithLookThrough", "(", "Def", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "MRI", ")", ";", "if", "(", "!", "MaybeShiftAmt", ")", "return", "<NUM_LIT>", ";", "uint64_t", "ShiftAmt", "=", "MaybeShiftAmt", "->", "Value", ".", "getZExtValue", "(", ")", ";", "MachineInstr", "*", "ShiftLHS", "=", "getDefIgnoringCopies", "(", "Def", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "MRI", ")", ";", "if", "(", "IsSupportedExtend", "(", "*", "ShiftLHS", ")", ")", "return", "(", "ShiftAmt", "<=", "<NUM_LIT>", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "LLT", "Ty", "=", "MRI", ".", "getType", "(", "Def", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg" ]

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

[ "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", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "WordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "mayStore", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "(", "MOVLHPSrr", "(", "v4f32", "VR128", ":", "$", "src", ")", ",", "(", "v4f32", "VR128", ":", "$", "src", ")", ")", ">", ";", "<FIXE>", "<FIXS>", "(", "MOVLHPSrr", "(", "v2i64", "VR128", ":", "$", "src", ")", ",", "(", "v2i64", "VR128", ":", "$", "src", ")", ")", ">", ";", "<FIXE>" ]

[ "let", "AddedComplexity", "=", "<NUM_LIT>", "in", "{", "def", ":", "Pat", "(", "v4f32", "(", "movddup", "VR128", ":", "$", "src", ",", "(", "undef", ")", ")", ")", ",", "<BUGS>", "(", "MOVLHPSrr", "VR128", ":", "$", "src", ",", "VR128", ":", "$", "src", ")", ">", ";", "<BUGE>", "def", ":", "Pat", "(", "v2i64", "(", "movddup", "VR128", ":", "$", "src", ",", "(", "undef", ")", ")", ")", ",", "<BUGS>", "(", "MOVLHPSrr", "VR128", ":", "$", "src", ",", "VR128", ":", "$", "src", ")", ">", ";", "<BUGE>", "}" ]

[ "else", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "sltu", ")", ")", ";" ]

[ "if", "(", "code", "==", "GTU", ")", "{", "rtx", "tmp", "=", "op1", ";", "op1", "=", "op2", ";", "op2", "=", "tmp", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "sltu", "=", "gen_rtx_LTU", "(", "SImode", ",", "op1", ",", "op2", ")", ";", "if", "(", "reverse", ")", "{", "rtx", "tmp", "=", "copy_to_mode_reg", "(", "SImode", ",", "gen_rtx_NEG", "(", "SImode", ",", "sltu", ")", ")", ";", "emit_insn", "(", "gen_add3_insn", "(", "op0", ",", "tmp", ",", "const1_rtx", ")", ")", ";", "}" ]

[ "<FIXS>", "case", "ISD", "::", "SETEQ", ":", "return", "UseSPE", "?", "PPC", "::", "PRED_GT", ":", "PPC", "::", "PRED_EQ", ";", "<FIXE>", "<FIXS>", "case", "ISD", "::", "SETNE", ":", "return", "UseSPE", "?", "PPC", "::", "PRED_LE", ":", "PPC", "::", "PRED_NE", ";", "<FIXE>", "<FIXS>", "case", "ISD", "::", "SETLT", ":", "return", "UseSPE", "?", "PPC", "::", "PRED_GT", ":", "PPC", "::", "PRED_LT", ";", "<FIXE>", "<FIXS>", "case", "ISD", "::", "SETLE", ":", "return", "UseSPE", "?", "PPC", "::", "PRED_LE", ":", "PPC", "::", "PRED_LE", ";", "<FIXE>", "<FIXS>", "case", "ISD", "::", "SETGT", ":", "return", "UseSPE", "?", "PPC", "::", "PRED_GT", ":", "PPC", "::", "PRED_GT", ";", "<FIXE>", "<FIXS>", "case", "ISD", "::", "SETGE", ":", "return", "UseSPE", "?", "PPC", "::", "PRED_LE", ":", "PPC", "::", "PRED_GE", ";", "<FIXE>" ]

[ "llvm_unreachable", "(", "<STR_LIT>", "Should be lowered by legalize!", "<STR_LIT>", ")", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown condition!", "<STR_LIT>", ")", ";", "case", "ISD", "::", "SETOEQ", ":", "<BUGS>", "case", "ISD", "::", "SETEQ", ":", "return", "PPC", "::", "PRED_EQ", ";", "<BUGE>", "case", "ISD", "::", "SETUNE", ":", "<BUGS>", "case", "ISD", "::", "SETNE", ":", "return", "PPC", "::", "PRED_NE", ";", "<BUGE>", "case", "ISD", "::", "SETOLT", ":", "<BUGS>", "case", "ISD", "::", "SETLT", ":", "return", "PPC", "::", "PRED_LT", ";", "<BUGE>", "case", "ISD", "::", "SETULE", ":", "<BUGS>", "case", "ISD", "::", "SETLE", ":", "return", "PPC", "::", "PRED_LE", ";", "<BUGE>", "case", "ISD", "::", "SETOGT", ":", "<BUGS>", "case", "ISD", "::", "SETGT", ":", "return", "PPC", "::", "PRED_GT", ";", "<BUGE>", "case", "ISD", "::", "SETUGE", ":", "<BUGS>", "case", "ISD", "::", "SETGE", ":", "return", "PPC", "::", "PRED_GE", ";", "<BUGE>", "case", "ISD", "::", "SETO", ":", "return", "PPC", "::", "PRED_NU", ";", "case", "ISD", "::", "SETUO", ":", "return", "PPC", "::", "PRED_UN", ";" ]

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

[ "off", "=", "XEXP", "(", "off", ",", "<NUM_LIT>", ")", ";", "if", "(", "satisfies_constraint_Rgs", "(", "reg", ")", "&&", "satisfies_constraint_Rgs", "(", "off", ")", ")", "return", "<NUM_LIT>", ";", "return", "<NUM_LIT>", ";", "case", "REG", ":", "default", ":", "reg", "=", "addr", ";", "break", ";", "}", "if", "(", "!", "satisfies_constraint_Rgs", "(", "reg", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "!", "satisfies_constraint_L", "(", "off", ")", ")", "return", "<NUM_LIT>", ";", "i", "=", "INTVAL", "(", "off", ")", ";", "switch", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", "{", "default", ":", "case", "<NUM_LIT>", ":", "if", "(", "i", "&", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";", "i", ">>=", "<NUM_LIT>", ";", "case", "<NUM_LIT>", ":", "if", "(", "i", "&", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Qd", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "bit_12", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "imm", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", "{" ]

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

[ "}", "arm_builtin_datum", "*", "d", "=", "&", "vfp_builtin_data", "[", "fcode", "-", "ARM_BUILTIN_VFP_PATTERN_START", "]", ";", "return", "arm_general_expand_builtin_1", "(", "fcode", ",", "exp", ",", "target", "," ]

[ "}" ]

[ "const", "HSAILInstrInfo", "*", "getInstrInfo", "(", ")", "const", "override", "{", "return", "InstrInfo", ".", "get", "(", ")", ";" ]

[ "bool", "SystemZAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "const", "MCRegisterInfo", "&", "MRI", "=", "*", "TM", ".", "getMCRegisterInfo", "(", ")", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "MCOperand", "MCOp", ";", "if", "(", "ExtraCode", ")", "{", "if", "(", "ExtraCode", "[", "<NUM_LIT>", "]", "==", "'", "N", "'", "&&", "!", "ExtraCode", "[", "<NUM_LIT>", "]", "&&", "MO", ".", "isReg", "(", ")", "&&", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "MO", ".", "getReg", "(", ")", ")", ")", "MCOp", "=", "MCOperand", "::", "createReg", "(", "MRI", ".", "getSubReg", "(", "MO", ".", "getReg", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "else", "return", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "ExtraCode", ",", "OS", ")", ";", "}", "else", "{", "SystemZMCInstLower", "Lower", "(", "MF", "->", "getContext", "(", ")", ",", "*", "this", ")", ";", "MCOp", "=", "Lower", ".", "lowerOperand", "(", "MO", ")", ";", "}", "printOperand", "(", "MCOp", ",", "MAI", ",", "OS", ")", ";", "return", "false", ";", "}" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

[ "<FIXS>", "CPUsers", ".", "push_back", "(", "CPUser", "(", "I", ",", "CPEMI", ",", "MaxOffs", ",", "NegOk", ",", "IsSoImm", ")", ")", ";", "<FIXE>" ]

[ "unsigned", "CPI", "=", "I", "->", "getOperand", "(", "op", ")", ".", "getIndex", "(", ")", ";", "MachineInstr", "*", "CPEMI", "=", "CPEMIs", "[", "CPI", "]", ";", "unsigned", "MaxOffs", "=", "(", "(", "<NUM_LIT>", "<<", "Bits", ")", "-", "<NUM_LIT>", ")", "*", "Scale", ";", "<BUGS>", "CPUsers", ".", "push_back", "(", "CPUser", "(", "I", ",", "CPEMI", ",", "MaxOffs", ",", "NegOk", ")", ")", ";", "<BUGE>", "CPEntry", "*", "CPE", "=", "findConstPoolEntry", "(", "CPI", ",", "CPEMI", ")", ";" ]

[ "<FIXS>", "fprintf", "(", "(", "STREAM", ")", ",", "<STR_LIT>", "\\tmov.l\\t%sLP%d,r1\\n", "<STR_LIT>", ",", "\\", "<FIXE>", "<FIXS>", "fprintf", "(", "(", "STREAM", ")", ",", "<STR_LIT>", "\\tmova\\t%sLP%dr,r0\\n", "<STR_LIT>", ",", "\\", "<FIXE>", "<FIXS>", "fprintf", "(", "(", "STREAM", ")", ",", "<STR_LIT>", "%sLP%d:\\t.long\\t__mcount\\n", "<STR_LIT>", ",", "\\", "<FIXE>", "<FIXS>", "fprintf", "(", "(", "STREAM", ")", ",", "<STR_LIT>", "%sLP%dr:\\n", "<STR_LIT>", ",", "LOCAL_LABEL_PREFIX", ",", "(", "LABELNO", ")", ")", ";", "\\", "<FIXE>" ]

[ "}", "\\", "else", "\\", "{", "\\", "<BUGS>", "fprintf", "(", "(", "STREAM", ")", ",", "<STR_LIT>", "\\tmov.l\\t%cLP%d,r1\\n", "<STR_LIT>", ",", "\\", "<BUGE>", "LOCAL_LABEL_PREFIX", ",", "(", "LABELNO", ")", ")", ";", "\\", "<BUGS>", "fprintf", "(", "(", "STREAM", ")", ",", "<STR_LIT>", "\\tmova\\t%cLP%dr,r0\\n", "<STR_LIT>", ",", "\\", "<BUGE>", "LOCAL_LABEL_PREFIX", ",", "(", "LABELNO", ")", ")", ";", "\\", "fprintf", "(", "(", "STREAM", ")", ",", "<STR_LIT>", "\\tjmp\\t@r1\\n", "<STR_LIT>", ")", ";", "\\", "fprintf", "(", "(", "STREAM", ")", ",", "<STR_LIT>", "\\tnop\\n", "<STR_LIT>", ")", ";", "\\", "fprintf", "(", "(", "STREAM", ")", ",", "<STR_LIT>", "\\t.align\\t2\\n", "<STR_LIT>", ")", ";", "\\", "<BUGS>", "fprintf", "(", "(", "STREAM", ")", ",", "<STR_LIT>", "%cLP%d:\\t.long\\t__mcount\\n", "<STR_LIT>", ",", "\\", "<BUGE>", "LOCAL_LABEL_PREFIX", ",", "(", "LABELNO", ")", ")", ";", "\\", "<BUGS>", "fprintf", "(", "(", "STREAM", ")", ",", "<STR_LIT>", "%cLP%dr:\\n", "<STR_LIT>", ",", "LOCAL_LABEL_PREFIX", ",", "(", "LABELNO", ")", ")", ";", "\\", "<BUGE>", "}", "\\", "}", "\\", "while", "(", "<NUM_LIT>", ")" ]

[ "int", "rs6000_emit_vector_cond_expr", "(", "rtx", "dest", ",", "rtx", "op_true", ",", "rtx", "op_false", ",", "rtx", "cond", ",", "rtx", "cc_op0", ",", "rtx", "cc_op1", ")", "{", "machine_mode", "dest_mode", "=", "GET_MODE", "(", "dest", ")", ";", "machine_mode", "mask_mode", "=", "GET_MODE", "(", "cc_op0", ")", ";", "enum", "rtx_code", "rcode", "=", "GET_CODE", "(", "cond", ")", ";", "machine_mode", "cc_mode", "=", "CCmode", ";", "rtx", "mask", ";", "rtx", "cond2", ";", "rtx", "tmp", ";", "bool", "invert_move", "=", "false", ";", "if", "(", "VECTOR_UNIT_NONE_P", "(", "dest_mode", ")", ")", "return", "<NUM_LIT>", ";", "gcc_assert", "(", "GET_MODE_SIZE", "(", "dest_mode", ")", "==", "GET_MODE_SIZE", "(", "mask_mode", ")", "&&", "GET_MODE_NUNITS", "(", "dest_mode", ")", "==", "GET_MODE_NUNITS", "(", "mask_mode", ")", ")", ";", "switch", "(", "rcode", ")", "{", "case", "NE", ":", "case", "UNLE", ":", "case", "UNLT", ":", "case", "UNGE", ":", "case", "UNGT", ":", "invert_move", "=", "true", ";", "rcode", "=", "reverse_condition_maybe_unordered", "(", "rcode", ")", ";", "if", "(", "rcode", "==", "UNKNOWN", ")", "return", "<NUM_LIT>", ";", "break", ";", "case", "GTU", ":", "case", "GEU", ":", "case", "LTU", ":", "case", "LEU", ":", "cc_mode", "=", "CCUNSmode", ";", "break", ";", "default", ":", "break", ";", "}", "mask", "=", "rs6000_emit_vector_compare", "(", "rcode", ",", "cc_op0", ",", "cc_op1", ",", "mask_mode", ")", ";", "if", "(", "!", "mask", ")", "return", "<NUM_LIT>", ";", "if", "(", "invert_move", ")", "{", "tmp", "=", "op_true", ";", "op_true", "=", "op_false", ";", "op_false", "=", "tmp", ";", "}", "cond2", "=", "gen_rtx_fmt_ee", "(", "NE", ",", "cc_mode", ",", "gen_lowpart", "(", "dest_mode", ",", "mask", ")", ",", "CONST0_RTX", "(", "dest_mode", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "gen_rtx_IF_THEN_ELSE", "(", "dest_mode", ",", "cond2", ",", "op_true", ",", "op_false", ")", ")", ")", ";", "return", "<NUM_LIT>", ";", "}" ]

[ "Emit", "vector", "conditional", "expression", ".", "DEST", "is", "destination", ".", "OP1", "and", "OP2", "are", "two", "VEC_COND_EXPR", "operands", ".", "CC_OP0", "and", "CC_OP1", "are", "the", "two", "operands", "for", "the", "relation", "operation", "COND", "." ]

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

[ "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "bits", "<", "<NUM_LIT>", ">", "rot", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rd", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "rot", ";" ]

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

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

[ "TargetRegistry", "::", "RegisterMCInstPrinter", "(", "TheSparcV9Target", ",", "createSparcMCInstPrinter", ")", ";" ]

[ "TargetRegistry", "::", "RegisterMCCodeEmitter", "(", "TheSparcTarget", ",", "createSparcMCCodeEmitter", ")", ";", "TargetRegistry", "::", "RegisterMCCodeEmitter", "(", "TheSparcV9Target", ",", "createSparcMCCodeEmitter", ")", ";", "TargetRegistry", "::", "RegisterMCAsmBackend", "(", "TheSparcTarget", ",", "createSparcAsmBackend", ")", ";", "TargetRegistry", "::", "RegisterMCAsmBackend", "(", "TheSparcV9Target", ",", "createSparcAsmBackend", ")", ";", "TargetRegistry", "::", "RegisterMCObjectStreamer", "(", "TheSparcTarget", ",", "createMCStreamer", ")", ";", "TargetRegistry", "::", "RegisterMCObjectStreamer", "(", "TheSparcV9Target", ",", "createMCStreamer", ")", ";", "TargetRegistry", "::", "RegisterAsmStreamer", "(", "TheSparcTarget", ",", "createMCAsmStreamer", ")", ";", "TargetRegistry", "::", "RegisterAsmStreamer", "(", "TheSparcV9Target", ",", "createMCAsmStreamer", ")", ";", "TargetRegistry", "::", "RegisterMCInstPrinter", "(", "TheSparcTarget", ",", "createSparcMCInstPrinter", ")", ";" ]

[ ":", "$", "rA", ",", "R8C", ":", "$", "rB", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "rotl", "R32C", ":", "$", "rA", ",", "(", "i32", "(", "zext", "R8C", ":", "$", "rB", ")", ")", ")", ",", "(", "ROTr32_r8_anyext", "R32C" ]

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

[ "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "for", "(", "unsigned", "Idx", "=", "<NUM_LIT>", ",", "E", "=", "TRI", "->", "getNumSubRegIndices", "(", ")", ";", "Idx", "<", "E", ";", "++", "Idx", ")", "{", "if", "(", "TRI", "->", "getSubRegIdxOffset", "(", "Idx", ")", "==", "Offset", "&&", "TRI", "->", "getSubRegIdxSize", "(", "Idx", ")", "==", "Size", ")", "{", "I", "->", "second", "=", "Idx", ";", "break", ";", "}", "}" ]

[ "<NUM_LIT>", ";" ]

[ "unsigned", "getCSRFirstUseCost", "(", ")", "const", "override", "{", "return" ]

[ "return", "build_int_cst", "(", "long_integer_type_node", ",", "temp", ")", ";" ]

[ "if", "(", "op_const", "==", "<NUM_LIT>", ")", "return", "NULL", ";", "if", "(", "opint", "[", "<NUM_LIT>", "]", "==", "<NUM_LIT>", ")", "temp", "=", "<NUM_LIT>", ";", "else", "temp", "=", "<NUM_LIT>", "-", "floor_log2", "(", "opint", "[", "<NUM_LIT>", "]", ")", "-", "<NUM_LIT>", ";" ]

[ "{" ]

[ "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "LUi", ")", ",", "GP", ")", ".", "addGlobalAddress", "(", "FName", ",", "<NUM_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ADDu", ")", ",", "GP", ")", ".", "addReg", "(", "GP", ")", ".", "addReg", "(", "T9", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ADDiu", ")", ",", "GP", ")", ".", "addReg", "(", "GP", ")", ".", "addGlobalAddress", "(", "FName", ",", "<NUM_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}", "if", "(", "StackSize", "==", "<NUM_LIT>", "&&", "!", "MFI", "->", "adjustsStack", "(", ")", ")", "return", ";", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "std", "::", "vector", "<", "MachineMove", ">", "&", "Moves", "=", "MMI", ".", "getFrameMoves", "(", ")", ";", "MachineLocation", "DstML", ",", "SrcML", ";", "ATUsed", "=", "expandRegLargeImmPair", "(", "SP", ",", "-", "StackSize", ",", "NewReg", ",", "NewImm", ",", "MBB", ",", "MBBI", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ADDiu", ")", ",", "SP", ")", ".", "addReg", "(", "NewReg", ")", ".", "addImm", "(", "NewImm", ")", ";", "if", "(", "ATUsed", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "ATMACRO", ")", ")", ";", "MCSymbol", "*", "AdjustSPLabel", "=", "MMI", ".", "getContext", "(", ")", ".", "CreateTempSymbol", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "PROLOG_LABEL", ")", ")", ".", "addSym", "(", "AdjustSPLabel", ")", ";", "DstML", "=", "MachineLocation", "(", "MachineLocation", "::", "VirtualFP", ")", ";", "SrcML", "=", "MachineLocation", "(", "MachineLocation", "::", "VirtualFP", ",", "-", "StackSize", ")", ";", "Moves", ".", "push_back", "(", "MachineMove", "(", "AdjustSPLabel", ",", "DstML", ",", "SrcML", ")", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", "->", "getCalleeSavedInfo", "(", ")", ";", "if", "(", "CSI", ".", "size", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "CSI", ".", "size", "(", ")", ";", "++", "i", ")", "++", "MBBI", ";", "MCSymbol", "*", "CSLabel", "=", "MMI", ".", "getContext", "(", ")", ".", "CreateTempSymbol", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "PROLOG_LABEL", ")", ")", ".", "addSym", "(", "CSLabel", ")", ";", "for", "(", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "::", "const_iterator", "I", "=", "CSI", ".", "begin", "(", ")", ",", "E", "=", "CSI", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "int64_t", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "I", "->", "getFrameIdx", "(", ")", ")", ";", "unsigned", "Reg", "=", "I", "->", "getReg", "(", ")", ";", "if", "(", "Mips", "::", "AFGR64RegisterClass", "->", "contains", "(", "Reg", ")", ")", "{", "const", "unsigned", "*", "SubRegs", "=", "RegInfo", "->", "getSubRegisters", "(", "Reg", ")", ";", "MachineLocation", "DstML0", "(", "MachineLocation", "::", "VirtualFP", ",", "Offset", ")", ";", "MachineLocation", "DstML1", "(", "MachineLocation", "::", "VirtualFP", ",", "Offset", "+", "<NUM_LIT>", ")", ";", "MachineLocation", "SrcML0", "(", "*", "SubRegs", ")", ";", "MachineLocation", "SrcML1", "(", "*", "(", "SubRegs", "+", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "STI", ".", "isLittle", "(", ")", ")", "std", "::", "swap", "(", "SrcML0", ",", "SrcML1", ")", ";", "Moves", ".", "push_back", "(", "MachineMove", "(", "CSLabel", ",", "DstML0", ",", "SrcML0", ")", ")", ";", "Moves", ".", "push_back", "(", "MachineMove", "(", "CSLabel", ",", "DstML1", ",", "SrcML1", ")", ")", ";", "}", "else", "{", "DstML", "=", "MachineLocation", "(", "MachineLocation", "::", "VirtualFP", ",", "Offset", ")", ";", "SrcML", "=", "MachineLocation", "(", "Reg", ")", ";", "Moves", ".", "push_back", "(", "MachineMove", "(", "CSLabel", ",", "DstML", ",", "SrcML", ")", ")", ";", "}", "}", "}", "if", "(", "hasFP", "(", "MF", ")", ")" ]

[ ".", "push_back", "(", "Inst", "->", "getOperand", "(", "i", ")", ")", ";" ]

[ "void", "MipsInstrInfo", "::", "AnalyzeCondBr", "(", "const", "MachineInstr", "*", "Inst", ",", "unsigned", "Opc", ",", "MachineBasicBlock", "*", "&", "BB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "assert", "(", "getAnalyzableBrOpc", "(", "Opc", ")", "&&", "<STR_LIT>", "Not an analyzable branch", "<STR_LIT>", ")", ";", "int", "NumOp", "=", "Inst", "->", "getNumExplicitOperands", "(", ")", ";", "BB", "=", "Inst", "->", "getOperand", "(", "NumOp", "-", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "Opc", ")", ")", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "NumOp", "-", "<NUM_LIT>", ";", "i", "++", ")", "Cond" ]

[ "void", "SIInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "unsigned", "Size", "=", "FrameInfo", ".", "getObjectSize", "(", "FrameIndex", ")", ";", "unsigned", "Align", "=", "FrameInfo", ".", "getObjectAlignment", "(", "FrameIndex", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOStore", ",", "Size", ",", "Align", ")", ";", "unsigned", "SpillSize", "=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "MFI", "->", "setHasSpilledSGPRs", "(", ")", ";", "const", "MCInstrDesc", "&", "OpDesc", "=", "get", "(", "getSGPRSpillSaveOpcode", "(", "SpillSize", ")", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "SrcReg", ")", "&&", "SpillSize", "==", "<NUM_LIT>", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "SrcReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "}", "MachineInstrBuilder", "Spill", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "OpDesc", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ".", "addReg", "(", "MFI", "->", "getFrameOffsetReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ";", "if", "(", "ST", ".", "hasScalarStores", "(", ")", ")", "{", "Spill", ".", "addReg", "(", "AMDGPU", "::", "M0", ",", "RegState", "::", "ImplicitDefine", "|", "RegState", "::", "Dead", ")", ";", "}", "return", ";", "}", "if", "(", "!", "ST", ".", "isVGPRSpillingEnabled", "(", "*", "MF", "->", "getFunction", "(", ")", ")", ")", "{", "LLVMContext", "&", "Ctx", "=", "MF", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "Ctx", ".", "emitError", "(", "<STR_LIT>", "SIInstrInfo::storeRegToStackSlot - Do not know how to", "<STR_LIT>", "<STR_LIT>", " spill register", "<STR_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "KILL", ")", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", ";", "}", "assert", "(", "RI", ".", "hasVGPRs", "(", "RC", ")", "&&", "<STR_LIT>", "Only VGPR spilling expected", "<STR_LIT>", ")", ";", "unsigned", "Opcode", "=", "getVGPRSpillSaveOpcode", "(", "SpillSize", ")", ";", "MFI", "->", "setHasSpilledVGPRs", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ")", ".", "addReg", "(", "MFI", "->", "getFrameOffsetReg", "(", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

[ "const", "MachineDominanceFrontier", "::", "DomSetType", "&", "DF", "=", "DFLoc", "->", "second", ";" ]

[ "if", "(", "DFLoc", "==", "MDF", ".", "end", "(", ")", "||", "DFLoc", "->", "second", ".", "empty", "(", ")", ")", "return", ";", "RegisterSet", "Defs", ";", "for", "(", "NodeAddr", "<", "InstrNode", "*", ">", "IA", ":", "BA", ".", "Addr", "->", "members", "(", "*", "this", ")", ")", "for", "(", "NodeAddr", "<", "RefNode", "*", ">", "RA", ":", "IA", ".", "Addr", "->", "members_if", "(", "IsDef", ",", "*", "this", ")", ")", "Defs", ".", "insert", "(", "RA", ".", "Addr", "->", "getRegRef", "(", "*", "this", ")", ")", ";" ]

[ "return", "CCmode", ";" ]

[ "case", "LE", ":", "case", "GT", ":", "case", "GE", ":", "return", "CCFPEmode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "if", "(", "(", "GET_MODE", "(", "x", ")", "==", "SImode", "||", "GET_MODE", "(", "x", ")", "==", "DImode", ")", "&&", "y", "==", "const0_rtx", "&&", "(", "code", "==", "EQ", "||", "code", "==", "NE", "||", "code", "==", "LT", "||", "code", "==", "GE", ")", "&&", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "||", "GET_CODE", "(", "x", ")", "==", "MINUS", "||", "GET_CODE", "(", "x", ")", "==", "AND", "||", "GET_CODE", "(", "x", ")", "==", "NEG", ")", ")", "return", "CC_NZmode", ";", "if", "(", "(", "GET_MODE", "(", "x", ")", "==", "SImode", "||", "GET_MODE", "(", "x", ")", "==", "DImode", ")", "&&", "(", "REG_P", "(", "y", ")", "||", "GET_CODE", "(", "y", ")", "==", "SUBREG", ")", "&&", "(", "GET_CODE", "(", "x", ")", "==", "ASHIFT", "||", "GET_CODE", "(", "x", ")", "==", "ASHIFTRT", "||", "GET_CODE", "(", "x", ")", "==", "LSHIFTRT", "||", "GET_CODE", "(", "x", ")", "==", "ZERO_EXTEND", "||", "GET_CODE", "(", "x", ")", "==", "SIGN_EXTEND", ")", ")", "return", "CC_SWPmode", ";", "if", "(", "(", "GET_MODE", "(", "x", ")", "==", "SImode", "||", "GET_MODE", "(", "x", ")", "==", "DImode", ")", "&&", "(", "REG_P", "(", "y", ")", "||", "GET_CODE", "(", "y", ")", "==", "SUBREG", ")", "&&", "(", "code", "==", "EQ", "||", "code", "==", "NE", ")", "&&", "GET_CODE", "(", "x", ")", "==", "NEG", ")", "return", "CC_Zmode", ";", "if", "(", "(", "GET_MODE", "(", "x", ")", "==", "QImode", "||", "GET_MODE", "(", "x", ")", "==", "HImode", ")", "&&", "y", "==", "const0_rtx", ")", "return", "(", "(", "code", "==", "GT", "||", "code", "==", "GE", "||", "code", "==", "LE", "||", "code", "==", "LT", ")", "?", "CC_SESWPmode", ":", "CC_ZESWPmode", ")", ";" ]

[ "operands", "[", "<NUM_LIT>", "]", "=", "simplify_gen_subreg", "(", "QImode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "HImode", ",", "<NUM_LIT>", ")" ]

[ "{", "operands", "[", "<NUM_LIT>", "]", "=", "simplify_gen_subreg", "(", "QImode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "HImode", ",", "<NUM_LIT>", ")" ]

[ "emit_insn", "(", "gen_klshiftrtqi", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", "," ]

[ "HOST_WIDE_INT", "nunits", "=", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "if", "(", "nunits", "!", "=", "<NUM_LIT>", "&", "&", "nunits", "!", "=", "<NUM_LIT>", ")", "FAIL", "if", "(", "TARGET_AVX512DQ", ")" ]

[ "}" ]

[ "_", "_", "arm_vbicq_m_n_u32", "(", "uint32x4_t", "_", "_", "a", ",", "const", "int", "_", "_", "imm", ",", "mve_pred16_t", "_", "_", "p", ")", "{", "return", "_", "_", "builtin_mve_vbicq_m_n_uv4si", "(", "_", "_", "a", ",", "_", "_", "imm", ",", "_", "_", "p", ")", ";" ]

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

[ "const", "CallLowering", "*", "getCallLowering", "(" ]

[ "break", ";" ]

[ "case", "PR_REGS", ":", "if", "(", "from", "==", "PR_REGS", ")", "return", "<NUM_LIT>", ";", "if", "(", "from", "!=", "GR_REGS", ")", "return", "memory_move_cost", "(", "mode", ",", "to", ",", "false", ")", ";", "break", ";", "case", "BR_REGS", ":", "if", "(", "from", "!=", "GR_REGS", "&&", "from", "!=", "GR_AND_BR_REGS", ")", "return", "memory_move_cost", "(", "mode", ",", "to", ",", "false", ")", ";", "break", ";", "case", "AR_I_REGS", ":", "case", "AR_M_REGS", ":", "if", "(", "from", "!=", "GR_REGS", ")", "return", "memory_move_cost", "(", "mode", ",", "to", ",", "false", ")", ";" ]

[ "}" ]

[ "Register", "Mips16InstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "return", "<NUM_LIT>", ";" ]

[ "}" ]

[ "let", "Name", "=", "<STR_LIT>", ";", "let", "DiagnosticType", "=", "<STR_LIT>", ";" ]

[ ")", ";" ]

[ "if", "(", "!", "Op", ".", "isReg", "(", ")", "||", "!", "Op", ".", "isDef", "(", ")", "||", "Op", ".", "getReg", "(", ")", "!=", "Reg", ")", "continue", ";", "Op", ".", "setIsDead", "(", "false", ")", ";", "}", "LiveInterval", "::", "iterator", "End", "=", "LI", ".", "end", "(", ")", ";", "SlotIndex", "S", "=", "LIS", "->", "getInstructionIndex", "(", "MI", ")", ".", "getRegSlot", "(", ")", ";", "LiveInterval", "::", "iterator", "T", "=", "LI", ".", "FindSegmentContaining", "(", "S", ")", ";", "assert", "(", "T", "!=", "End", ")", ";", "LiveInterval", "::", "iterator", "N", "=", "std", "::", "next", "(", "T" ]

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

[ "AArch64Subtarget", "::", "AArch64Subtarget", "(", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ")", ":", "AArch64GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "HasNEON", "(", "false", ")", ",", "HasCrypto", "(", "false", ")", ",", "TargetTriple", "(", "TT", ")", "{", "ParseSubtargetFeatures", "(", "CPU" ]