Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "this", "->", "m_id", "=", "id", ";" ]

[ "this", "->", "m_globals", "=", "fma_steer", ";", "this", "->", "m_roots", "=", "new", "std", "::", "list", "<", "fma_root_node", "*", ">", ";", "this", "->", "m_roots", "->", "push_back", "(", "fma_root", ")", ";" ]

[ "<STR_LIT>" ]

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

[ "bool", "HexagonOptimizeSZextends", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "unsigned", "Idx", "=", "<NUM_LIT>", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "if", "(", "F", ".", "getAttributes", "(", ")", ".", "hasParamAttr", "(", "Idx", ",", "Attribute", "::", "SExt", ")", ")", "{", "if", "(", "!", "isa", "<", "PointerType", ">", "(", "Arg", ".", "getType", "(", ")", ")", ")", "{", "for", "(", "Use", "&", "U", ":", "llvm", "::", "make_early_inc_range", "(", "Arg", ".", "uses", "(", ")", ")", ")", "{", "if", "(", "isa", "<", "SExtInst", ">", "(", "U", ")", ")", "{", "Instruction", "*", "Use", "=", "cast", "<", "Instruction", ">", "(", "U", ")", ";", "SExtInst", "*", "SI", "=", "new", "SExtInst", "(", "&", "Arg", ",", "Use", "->", "getType", "(", ")", ")", ";", "assert", "(", "EVT", "::", "getEVT", "(", "SI", "->", "getType", "(", ")", ")", "==", "(", "EVT", "::", "getEVT", "(", "Use", "->", "getType", "(", ")", ")", ")", ")", ";", "Use", "->", "replaceAllUsesWith", "(", "SI", ")", ";", "Instruction", "*", "First", "=", "&", "F", ".", "getEntryBlock", "(", ")", ".", "front", "(", ")", ";", "SI", "->", "insertBefore", "(", "First", ")", ";", "Use", "->", "eraseFromParent", "(", ")", ";", "}", "}", "}", "}", "++", "Idx", ";", "}", "for", "(", "auto", "&", "B", ":", "F", ")", "{", "for", "(", "auto", "&", "I", ":", "B", ")", "{", "BinaryOperator", "*", "Ashr", "=", "dyn_cast", "<", "BinaryOperator", ">", "(", "&", "I", ")", ";", "if", "(", "!", "(", "Ashr", "&&", "Ashr", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "AShr", ")", ")", "continue", ";", "Value", "*", "AshrOp1", "=", "Ashr", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "ConstantInt", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "AshrOp1", ")", ";", "if", "(", "!", "(", "C", "&&", "C", "->", "getSExtValue", "(", ")", "==", "<NUM_LIT>", ")", ")", "continue", ";", "Instruction", "*", "Shl", "=", "dyn_cast", "<", "Instruction", ">", "(", "Ashr", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "(", "Shl", "&&", "Shl", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "Shl", ")", ")", "continue", ";", "Value", "*", "Intr", "=", "Shl", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "Value", "*", "ShlOp1", "=", "Shl", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "ShlOp1", ")", ";", "if", "(", "!", "(", "C", "&&", "C", "->", "getSExtValue", "(", ")", "==", "<NUM_LIT>", ")", ")", "continue", ";", "if", "(", "IntrinsicInst", "*", "I", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "Intr", ")", ")", "{", "if", "(", "!", "intrinsicAlreadySextended", "(", "I", "->", "getIntrinsicID", "(", ")", ")", ")", "continue", ";", "for", "(", "auto", "UI", "=", "Ashr", "->", "user_begin", "(", ")", ",", "UE", "=", "Ashr", "->", "user_end", "(", ")", ";", "UI", "!=", "UE", ";", "++", "UI", ")", "{", "const", "Use", "&", "TheUse", "=", "UI", ".", "getUse", "(", ")", ";", "if", "(", "Instruction", "*", "J", "=", "dyn_cast", "<", "Instruction", ">", "(", "TheUse", ".", "getUser", "(", ")", ")", ")", "{", "J", "->", "replaceUsesOfWith", "(", "Ashr", ",", "I", ")", ";", "}", "}", "}", "}", "}", "return", "true", ";", "}" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

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

[ "bits", "<", "<NUM_LIT>", ">", "RdLo", ";", "bits", "<", "<NUM_LIT>", ">", "RdHi", ";", "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";" ]

[ "<STR_LIT>", ")" ]

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

[ "Pmode", ",", "tmpreg", ",", "basereg", ")", ")", ";" ]

[ "if", "(", "VAL_14_BITS_P", "(", "disp", ")", ")", "{", "insn", "=", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "reg", ")", ",", "plus_constant", "(", "Pmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "base", ")", ",", "disp", ")", ")", ";", "}", "else", "if", "(", "TARGET_64BIT", "&&", "!", "VAL_32_BITS_P", "(", "disp", ")", ")", "{", "rtx", "basereg", "=", "gen_rtx_REG", "(", "Pmode", ",", "base", ")", ";", "rtx", "delta", "=", "GEN_INT", "(", "disp", ")", ";", "rtx", "tmpreg", "=", "gen_rtx_REG", "(", "Pmode", ",", "<NUM_LIT>", ")", ";", "emit_move_insn", "(", "tmpreg", ",", "delta", ")", ";", "insn", "=", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "reg", ")", ",", "gen_rtx_PLUS", "(" ]

[ ",", "output_section_asm_op", ",", "<STR_LIT>", "\\t.section .zbss,\\\"aw\\\"", "<STR_LIT>", ")", ";" ]

[ "rozdata_section", "=", "get_unnamed_section", "(", "<NUM_LIT>", ",", "output_section_asm_op", ",", "<STR_LIT>", "\\t.section .rozdata,\\\"a\\\"", "<STR_LIT>", ")", ";", "tdata_section", "=", "get_unnamed_section", "(", "SECTION_WRITE", ",", "output_section_asm_op", ",", "<STR_LIT>", "\\t.section .tdata,\\\"aw\\\"", "<STR_LIT>", ")", ";", "zdata_section", "=", "get_unnamed_section", "(", "SECTION_WRITE", ",", "output_section_asm_op", ",", "<STR_LIT>", "\\t.section .zdata,\\\"aw\\\"", "<STR_LIT>", ")", ";", "zbss_section", "=", "get_unnamed_section", "(", "SECTION_WRITE", "|", "SECTION_BSS" ]

[ "else", "dest", "=", "gen_reg_rtx", "(", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", ";" ]

[ "op", "=", "gen_rtx_fmt_e", "(", "code", ",", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "}", "else", "{", "operands", "[", "<NUM_LIT>", "]", "=", "force_reg", "(", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "operands", "[", "<NUM_LIT>", "]", "=", "force_reg", "(", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "op", "=", "gen_rtx_fmt_ee", "(", "code", ",", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "}", "if", "(", "register_operand", "(", "operands", "[", "<NUM_LIT>", "]", ",", "VOIDmode", ")", ")", "dest", "=", "operands", "[", "<NUM_LIT>", "]", ";" ]

[ "<STR_LIT>", ")" ]

[ "(", "match_operand", ":", "V4SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>" ]

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

[ "(", "define_cpu_unit" ]

[ ")" ]

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

[ "if", "(", "Val", "==", "DoubleToBits", "(", "<NUM_LIT>", ")", ")", "return", "<NUM_LIT>", ";" ]

[ "uint32_t", "IntImm", "=", "getIntInlineImmEncoding", "(", "static_cast", "<", "int64_t", ">", "(", "Val", ")", ")", ";", "if", "(", "IntImm", "!=", "<NUM_LIT>", ")", "return", "IntImm", ";", "if", "(", "Val", "==", "DoubleToBits", "(", "<NUM_LIT>", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "Val", "==", "DoubleToBits", "(", "-", "<NUM_LIT>", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "Val", "==", "DoubleToBits", "(", "<NUM_LIT>", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "Val", "==", "DoubleToBits", "(", "-", "<NUM_LIT>", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "Val", "==", "DoubleToBits", "(", "<NUM_LIT>", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "Val", "==", "DoubleToBits", "(", "-", "<NUM_LIT>", ")", ")", "return", "<NUM_LIT>", ";" ]

[ ";" ]

[ "if", "(", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", "*", "Caller", ")", ".", "useAVX512Regs", "(", ")", "==", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", "*", "Callee", ")", ".", "useAVX512Regs", "(", ")", ")", "return", "true", ";", "return", "llvm", "::", "none_of", "(", "Args", ",", "[", "]", "(", "Argument", "*", "A", ")", "{", "auto", "*", "EltTy", "=", "cast", "<", "PointerType", ">", "(", "A", "->", "getType", "(", ")", ")", "->", "getElementType", "(", ")", ";", "return", "EltTy", "->", "isVectorTy", "(", ")", "||", "EltTy", "->", "isAggregateType", "(", ")", ";", "}", ")" ]

[ "}" ]

[ "static", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "always_inline__", ")", ")", "_", "mm_min_epi16", "(", "_", "_", "m128i", "_", "_", "A", ",", "_", "_", "m128i", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_pminsw128", "(", "(", "_", "_", "v8hi", ")", "_", "_", "A", ",", "(", "_", "_", "v8hi", ")", "_", "_", "B", ")", ";" ]

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

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

[ "}" ]

[ "int", "i", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "if", "(", "!", "df_regs_ever_live_p", "(", "i", ")", ")", "return", "i", ";", "return", "<NUM_LIT>", ";" ]

[ ")", ";" ]

[ "return", "isAmdHsaOS", "(", ")", "||", "isMesaKernel", "(", "F" ]

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

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

[ "int", "i", ";" ]

[ "unsigned", "HOST_WIDE_INT", "s390_extract_part", "(", "rtx", "op", ",", "machine_mode", "mode", ",", "int", "def", ")", "{", "unsigned", "HOST_WIDE_INT", "value", "=", "<NUM_LIT>", ";", "int", "max_parts", "=", "HOST_BITS_PER_WIDE_INT", "/", "GET_MODE_BITSIZE", "(", "mode", ")", ";", "int", "part_bits", "=", "GET_MODE_BITSIZE", "(", "mode", ")", ";", "unsigned", "HOST_WIDE_INT", "part_mask", "=", "(", "HOST_WIDE_INT_1U", "<<", "part_bits", ")", "-", "<NUM_LIT>", ";" ]

[ "Init", ".", "push_back", "(", "ConstantInt", "::", "get", "(", "Int8Ty", ",", "input", "[", "i", "]", ")", ")", ";" ]

[ "static", "std", "::", "vector", "<", "Constant", "*", ">", "createAString", "(", "std", "::", "string", "input", ",", "Type", "*", "&", "Int8Ty", ")", "{", "std", "::", "vector", "<", "Constant", "*", ">", "Init", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "input", ".", "size", "(", ")", ";", "i", "++", ")", "{" ]

[ "<STR_LIT>", ")" ]

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

[ "return", ";" ]

[ "return", ";", "}", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "DestReg", ")", "&&", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "SrcReg", ")", ")", "{", "static", "const", "unsigned", "Indices", "[", "]", "=", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "}", ";", "copyPhysRegTuple", "(", "MBB", ",", "I", ",", "DL", ",", "DestReg", ",", "SrcReg", ",", "KillSrc", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "Indices", ")", ";", "return", ";", "}", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "DestReg", ")", "&&", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "SrcReg", ")", ")", "{", "static", "const", "unsigned", "Indices", "[", "]", "=", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "}", ";", "copyPhysRegTuple", "(", "MBB", ",", "I", ",", "DL", ",", "DestReg", ",", "SrcReg", ",", "KillSrc", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "Indices", ")", ";", "return", ";", "}", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "DestReg", ")", "&&", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "SrcReg", ")", ")", "{", "static", "const", "unsigned", "Indices", "[", "]", "=", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "}", ";", "copyPhysRegTuple", "(", "MBB", ",", "I", ",", "DL", ",", "DestReg", ",", "SrcReg", ",", "KillSrc", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "Indices", ")", ";", "return", ";", "}", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "DestReg", ")", "&&", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "SrcReg", ")", ")", "{", "if", "(", "Subtarget", ".", "hasNEON", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "-", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "}", "return", ";", "}", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "DestReg", ")", "&&", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "SrcReg", ")", ")", "{", "if", "(", "Subtarget", ".", "hasNEON", "(", ")", ")", "{", "DestReg", "=", "RI", ".", "getMatchingSuperReg", "(", "DestReg", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "SrcReg", "=", "RI", ".", "getMatchingSuperReg", "(", "SrcReg", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "return", ";", "}", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "DestReg", ")", "&&", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "SrcReg", ")", ")", "{", "if", "(", "Subtarget", ".", "hasNEON", "(", ")", ")", "{", "DestReg", "=", "RI", ".", "getMatchingSuperReg", "(", "DestReg", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "SrcReg", "=", "RI", ".", "getMatchingSuperReg", "(", "SrcReg", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "return", ";", "}", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "DestReg", ")", "&&", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "SrcReg", ")", ")", "{", "if", "(", "Subtarget", ".", "hasNEON", "(", ")", ")", "{", "DestReg", "=", "RI", ".", "getMatchingSuperReg", "(", "DestReg", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "SrcReg", "=", "RI", ".", "getMatchingSuperReg", "(", "SrcReg", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "else", "{", "DestReg", "=", "RI", ".", "getMatchingSuperReg", "(", "DestReg", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "SrcReg", "=", "RI", ".", "getMatchingSuperReg", "(", "SrcReg", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "return", ";", "}", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "DestReg", ")", "&&", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "SrcReg", ")", ")", "{", "if", "(", "Subtarget", ".", "hasNEON", "(", ")", ")", "{", "DestReg", "=", "RI", ".", "getMatchingSuperReg", "(", "DestReg", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "SrcReg", "=", "RI", ".", "getMatchingSuperReg", "(", "SrcReg", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "else", "{", "DestReg", "=", "RI", ".", "getMatchingSuperReg", "(", "DestReg", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "SrcReg", "=", "RI", ".", "getMatchingSuperReg", "(", "SrcReg", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}" ]

[ "_", "mm512_maskz_or_pd", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m512d", "_", "_", "A", ",", "_", "_", "m512d", "_", "_", "B", ")", "{" ]

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

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

[ "<FIXS>", "pa_function_arg_padding", "(", "enum", "machine_mode", "mode", ",", "const_tree", "type", ")", "<FIXE>" ]

[ "}", "enum", "direction", "<BUGS>", "function_arg_padding", "(", "enum", "machine_mode", "mode", ",", "const_tree", "type", ")", "<BUGE>", "{", "if", "(", "mode", "==", "BLKmode", "||", "(", "TARGET_64BIT" ]

[ "BrOpc", "==", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

[ "return", "BrOpc", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "BrOpc", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "BrOpc", "==", "<STR_LIT>", "::", "<STR_LIT>", "||" ]

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

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

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

[ "return", "(", "_", "_", "m128", ")", "_", "_", "builtin_ia32_cmpngeps", "(", "(", "_", "_", "v4sf", ")", "_", "_", "A", ",", "(", "_", "_", "v4sf", ")", "_" ]

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

[ "class", "X86SrcIdxOperand", "<", "string", "printMethod", ",", "AsmOperandClass", "parserMatchClass", ">", ":", "X86MemOperand", "<", "printMethod", ",", "parserMatchClass", ">", "{", "let", "MIOperandInfo", "=", "(", "ops", "ptr_rc" ]

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

[ "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_Sparc32", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "RetOps", "(", "<NUM_LIT>", ",", "Chain", ")", ";", "RetOps", ".", "push_back", "(", "SDValue", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "<STR_LIT>", "Can only return in registers!", "<STR_LIT>", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "unsigned", "RetAddrOffset", "=", "<NUM_LIT>", ";", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ")", "{", "SparcMachineFunctionInfo", "*", "SFI", "=", "MF", ".", "getInfo", "<", "SparcMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "Reg", "=", "SFI", "->", "getSRetReturnReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "llvm_unreachable", "(", "<STR_LIT>", "sret virtual register not created in the entry block", "<STR_LIT>", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "getPointerTy", "(", ")", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "getPointerTy", "(", ")", ")", ")", ";", "RetAddrOffset", "=", "<NUM_LIT>", ";", "}" ]

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

[ "bool", "SITargetLowering", "::", "isFreeAddrSpaceCast", "(", "unsigned", "SrcAS", ",", "unsigned", "DestAS", ")", "const", "{", "if", "(", "SrcAS", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", ")" ]

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

[ "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]

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

[ "case", "X86", "::", "JMP16m", ":", "case", "X86", "::", "JMP32m", ":", "case", "X86", "::", "JMP64m", ":", "case", "X86", "::", "CALL16m", ":", "case", "X86", "::", "CALL32m", ":", "case", "X86", "::", "CALL64m", ":", "emitWarningForSpecialLVIInstruction", "(", "Inst", ".", "getLoc", "(", ")", ")", ";", "return", "true", ";", "}" ]

[ "Optional", "<", "uint64_t", ">", "X86MCInstrAnalysis", "::", "evaluateMemoryOperandAddress", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "*", "STI", ",", "uint64_t", "Addr", ",", "uint64_t", "Size", ")", "const", "{", "const", "MCInstrDesc", "&", "MCID", "=", "Info", "->", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ";", "int", "MemOpStart", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", "MCID", ".", "TSFlags", ")", ";", "if", "(", "MemOpStart", "==", "-", "<NUM_LIT>", ")", "return", "None", ";", "MemOpStart", "+=", "<STR_LIT>", "::", "<STR_LIT>", "(", "MCID", ")", ";", "const", "MCOperand", "&", "SegReg", "=", "Inst", ".", "getOperand", "(", "MemOpStart", "+", "X86", "::", "AddrSegmentReg", ")", ";", "const", "MCOperand", "&", "BaseReg", "=", "Inst", ".", "getOperand", "(", "MemOpStart", "+", "X86", "::", "AddrBaseReg", ")", ";", "const", "MCOperand", "&", "IndexReg", "=", "Inst", ".", "getOperand", "(", "MemOpStart", "+", "X86", "::", "AddrIndexReg", ")", ";", "const", "MCOperand", "&", "ScaleAmt", "=", "Inst", ".", "getOperand", "(", "MemOpStart", "+", "X86", "::", "AddrScaleAmt", ")", ";", "const", "MCOperand", "&", "Disp", "=", "Inst", ".", "getOperand", "(", "MemOpStart", "+", "X86", "::", "AddrDisp", ")", ";", "if", "(", "SegReg", ".", "getReg", "(", ")", "!=", "<NUM_LIT>", "||", "IndexReg", ".", "getReg", "(", ")", "!=", "<NUM_LIT>", "||", "ScaleAmt", ".", "getImm", "(", ")", "!=", "<NUM_LIT>", "||", "!", "Disp", ".", "isImm", "(", ")", ")", "return", "None", ";", "if", "(", "BaseReg", ".", "getReg", "(", ")", "==", "X86", "::", "RIP", ")", "return", "Addr", "+", "Size", "+", "Disp", ".", "getImm", "(", ")", ";", "return", "None", ";", "}" ]

[ "Given", "an", "instruction", "tries", "to", "get", "the", "address", "of", "a", "memory", "operand", "." ]

[ "Register", "AArch64RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "AArch64FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "}" ]

[ "Debug", "information", "queries", "." ]

[ "assert", "(", "Channel", "<", "std", "::", "size", "(", "SubRegFromChannelTable", ")", ")", ";" ]

[ "static", "const", "uint16_t", "SubRegFromChannelTable", "[", "]", "=", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "}", ";" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sz", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "nregs", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Pg", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";" ]

[ "}" ]

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

[ ")" ]

[ "(", "if_then_else", ":", "SI", "(", "match_operator", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "match_operator", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "CC_REGNUM", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]" ]

[ "<FIXS>", "SDValue", "Zeros", "=", "getZeroVector", "(", "VT", ",", "true", ",", "true", ",", "DAG", ",", "dl", ")", ";", "<FIXE>" ]

[ "if", "(", "Op", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SRA", ")", "{", "if", "(", "ShiftAmt", "==", "<NUM_LIT>", ")", "{", "<BUGS>", "SDValue", "Zeros", "=", "getZeroVector", "(", "VT", ",", "true", ",", "DAG", ",", "dl", ")", ";", "<BUGE>", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "Zeros", ",", "R", ")", ";", "}" ]

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

[ "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", ".. gave up (calling convention is not C)\\n", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "const", "ArrayRef", "<", "MCPhysReg", ">", "GPR32ArgRegs", "=", "{", "Mips", "::", "A0", ",", "Mips", "::", "A1", ",", "Mips", "::", "A2", ",", "Mips", "::", "A3", "}", ";", "const", "ArrayRef", "<", "MCPhysReg", ">", "FGR32ArgRegs", "=", "{", "Mips", "::", "F12", ",", "Mips", "::", "F14", "}", ";", "const", "ArrayRef", "<", "MCPhysReg", ">", "AFGR64ArgRegs", "=", "{", "Mips", "::", "D6", ",", "Mips", "::", "D7", "}", ";", "ArrayRef", "<", "MCPhysReg", ">", "::", "iterator", "NextGPR32", "=", "GPR32ArgRegs", ".", "begin", "(", ")", ";", "ArrayRef", "<", "MCPhysReg", ">", "::", "iterator", "NextFGR32", "=", "FGR32ArgRegs", ".", "begin", "(", ")", ";", "ArrayRef", "<", "MCPhysReg", ">", "::", "iterator", "NextAFGR64", "=", "AFGR64ArgRegs", ".", "begin", "(", ")", ";", "struct", "AllocatedReg", "{", "const", "TargetRegisterClass", "*", "RC", ";", "unsigned", "Reg", ";", "AllocatedReg", "(", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Reg", ")", ":", "RC", "(", "RC", ")", ",", "Reg", "(", "Reg", ")", "{", "}", "}", ";", "SmallVector", "<", "AllocatedReg", ",", "<NUM_LIT>", ">", "Allocation", ";", "unsigned", "Idx", "=", "<NUM_LIT>", ";", "for", "(", "const", "auto", "&", "FormalArg", ":", "F", "->", "args", "(", ")", ")", "{", "if", "(", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "Idx", ",", "Attribute", "::", "InReg", ")", "||", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "Idx", ",", "Attribute", "::", "StructRet", ")", "||", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "Idx", ",", "Attribute", "::", "ByVal", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", ".. gave up (inreg, structret, byval)\\n", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "Type", "*", "ArgTy", "=", "FormalArg", ".", "getType", "(", ")", ";", "if", "(", "ArgTy", "->", "isStructTy", "(", ")", "||", "ArgTy", "->", "isArrayTy", "(", ")", "||", "ArgTy", "->", "isVectorTy", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", ".. gave up (struct, array, or vector)\\n", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "EVT", "ArgVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "ArgTy", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", ".. ", "<STR_LIT>", "<<", "(", "Idx", "-", "<NUM_LIT>", ")", "<<", "<STR_LIT>", ": ", "<STR_LIT>", "<<", "ArgVT", ".", "getEVTString", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "if", "(", "!", "ArgVT", ".", "isSimple", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", ".. .. gave up (not a simple type)\\n", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "switch", "(", "ArgVT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "case", "MVT", "::", "i1", ":", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i16", ":", "if", "(", "!", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "Idx", ",", "Attribute", "::", "SExt", ")", "&&", "!", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "Idx", ",", "Attribute", "::", "ZExt", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", ".. .. gave up (i8/i16 arg is not extended)\\n", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "if", "(", "NextGPR32", "==", "GPR32ArgRegs", ".", "end", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", ".. .. gave up (ran out of GPR32 arguments)\\n", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", ".. .. GPR32(", "<STR_LIT>", "<<", "*", "NextGPR32", "<<", "<STR_LIT>", ")\\n", "<STR_LIT>", ")", ";", "Allocation", ".", "emplace_back", "(", "&", "Mips", "::", "GPR32RegClass", ",", "*", "NextGPR32", "++", ")", ";", "NextFGR32", "=", "FGR32ArgRegs", ".", "end", "(", ")", ";", "NextAFGR64", "=", "AFGR64ArgRegs", ".", "end", "(", ")", ";", "break", ";", "case", "MVT", "::", "i32", ":", "if", "(", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "Idx", ",", "Attribute", "::", "ZExt", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", ".. .. gave up (i32 arg is zero extended)\\n", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "if", "(", "NextGPR32", "==", "GPR32ArgRegs", ".", "end", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", ".. .. gave up (ran out of GPR32 arguments)\\n", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", ".. .. GPR32(", "<STR_LIT>", "<<", "*", "NextGPR32", "<<", "<STR_LIT>", ")\\n", "<STR_LIT>", ")", ";", "Allocation", ".", "emplace_back", "(", "&", "Mips", "::", "GPR32RegClass", ",", "*", "NextGPR32", "++", ")", ";", "NextFGR32", "=", "FGR32ArgRegs", ".", "end", "(", ")", ";", "NextAFGR64", "=", "AFGR64ArgRegs", ".", "end", "(", ")", ";", "break", ";", "case", "MVT", "::", "f32", ":", "if", "(", "UnsupportedFPMode", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", ".. .. gave up (UnsupportedFPMode)\\n", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "if", "(", "NextFGR32", "==", "FGR32ArgRegs", ".", "end", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", ".. .. gave up (ran out of FGR32 arguments)\\n", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", ".. .. FGR32(", "<STR_LIT>", "<<", "*", "NextFGR32", "<<", "<STR_LIT>", ")\\n", "<STR_LIT>", ")", ";", "Allocation", ".", "emplace_back", "(", "&", "Mips", "::", "FGR32RegClass", ",", "*", "NextFGR32", "++", ")", ";", "if", "(", "NextGPR32", "!=", "GPR32ArgRegs", ".", "end", "(", ")", ")", "NextGPR32", "++", ";", "if", "(", "NextAFGR64", "!=", "AFGR64ArgRegs", ".", "end", "(", ")", ")", "NextAFGR64", "++", ";", "break", ";", "case", "MVT", "::", "f64", ":", "if", "(", "UnsupportedFPMode", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", ".. .. gave up (UnsupportedFPMode)\\n", "<STR_LIT>", ")", ";" ]

[ "i64", ":", "$", "src1", ")", ")", "]", ">", ";" ]

[ "def", "SI_ELSE_BREAK", ":", "InstSI", "<", "(", "outs", "SReg_64", ":", "$", "dst", ")", ",", "(", "ins", "SReg_64", ":", "$", "src0", ",", "SReg_64", ":", "$", "src1", ")", ",", "<STR_LIT>", ",", "[", "(", "set", "i64", ":", "$", "dst", ",", "(", "int_SI_else_break", "i64", ":", "$", "src0", "," ]

[ ":", "V2DI" ]

[ "[", "(", "set", "(", "match_operand", ":", "V2DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "plus", ":", "V2DI", "(", "any_extend", ":", "V2DI", "(", "vec_select", ":", "V2SI", "(", "match_operand", ":", "V4SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "(", "any_extend" ]

[ "}", "]", ">", ";" ]

[ "return", "(", "(", "uint32_t", ")", "Imm", ")", "<", "<NUM_LIT>", ";", "}", "]", ">", ";", "def", "i64_imm0_65535", ":", "Operand", "<", "i64", ">", ",", "TImmLeaf", "<", "i64", ",", "[", "{", "return", "(", "(", "uint64_t", ")", "Imm", ")", "<", "<NUM_LIT>", ";" ]

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

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

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

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

[ "x", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "UNITS_PER_WORD", ")", ";" ]

[ "if", "(", "sr", "->", "saved", ")", "{", "if", "(", "release_via_pop", ")", "{", "struct", "machine_function", "*", "m", "=", "cfun", "->", "machine", ";", "rtx", "x", ",", "insn", "=", "emit_insn", "(", "gen_pop", "(", "sr", "->", "reg", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";" ]

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

[ "def", "INTERP_PAIR_ZW", ":", "AMDGPUShaderInst", "<", "(", "outs", "R600_TReg32_Z", ":", "$", "dst0", ",", "R600_TReg32_W", ":", "$", "dst1", ")", ",", "(", "ins", "i32imm", ":", "$", "src0", ",", "R600_TReg32_Y", ":", "$", "src1", ",", "R600_TReg32_X", ":" ]

[ "if", "(", "Addr", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{" ]

[ "if", "(", "ConstantSDNode", "*", "CN", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Addr", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{", "if", "(", "isInt", "<", "<NUM_LIT>", ">", "(", "CN", "->", "getSExtValue", "(", ")", ")", ")", "{", "if", "(", "FrameIndexSDNode", "*", "FIN", "=", "dyn_cast", "<", "FrameIndexSDNode", ">", "(", "Addr", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{", "Base", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FIN", "->", "getIndex", "(", ")", ",", "TLI", "->", "getPointerTy", "(", "CurDAG", "->", "getDataLayout", "(", ")", ")", ")", ";", "}", "else", "{", "Base", "=", "Addr", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "}", "Offset", "=", "CurDAG", "->", "getTargetConstant", "(", "CN", "->", "getZExtValue", "(", ")", ",", "SDLoc", "(", "Addr", ")", ",", "MVT", "::", "i32", ")", ";", "return", "true", ";", "}", "}" ]

[ "ArgInfo", "RetInfo", "(", "Reg", ",", "VT", ".", "getTypeForEVT", "(", "Ctx", ")", ")", ";" ]

[ "bool", "AMDGPUCallLowering", "::", "lowerReturnVal", "(", "MachineIRBuilder", "&", "B", ",", "const", "Value", "*", "Val", ",", "ArrayRef", "<", "Register", ">", "VRegs", ",", "MachineInstrBuilder", "&", "Ret", ")", "const", "{", "if", "(", "!", "Val", ")", "return", "true", ";", "auto", "&", "MF", "=", "B", ".", "getMF", "(", ")", ";", "const", "auto", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "MachineRegisterInfo", "*", "MRI", "=", "B", ".", "getMRI", "(", ")", ";", "LLVMContext", "&", "Ctx", "=", "F", ".", "getContext", "(", ")", ";", "CallingConv", "::", "ID", "CC", "=", "F", ".", "getCallingConv", "(", ")", ";", "const", "SITargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "SITargetLowering", ">", "(", ")", ";", "SmallVector", "<", "EVT", ",", "<NUM_LIT>", ">", "SplitEVTs", ";", "ComputeValueVTs", "(", "TLI", ",", "DL", ",", "Val", "->", "getType", "(", ")", ",", "SplitEVTs", ")", ";", "assert", "(", "VRegs", ".", "size", "(", ")", "==", "SplitEVTs", ".", "size", "(", ")", "&&", "<STR_LIT>", "For each split Type there should be exactly one VReg.", "<STR_LIT>", ")", ";", "SmallVector", "<", "ArgInfo", ",", "<NUM_LIT>", ">", "PreSplitRetInfos", ";", "SmallVector", "<", "ArgInfo", ",", "<NUM_LIT>", ">", "SplitRetInfos", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "SplitEVTs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "EVT", "VT", "=", "SplitEVTs", "[", "i", "]", ";", "Register", "Reg", "=", "VRegs", "[", "i", "]", ";" ]

[ "static", "bool", "s390_cannot_force_const_mem", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST_INT", ":", "case", "CONST_DOUBLE", ":", "return", "false", ";", "case", "LABEL_REF", ":", "return", "flag_pic", "!=", "<NUM_LIT>", ";", "case", "SYMBOL_REF", ":", "if", "(", "tls_symbolic_operand", "(", "x", ")", ")", "return", "true", ";", "else", "return", "flag_pic", "!=", "<NUM_LIT>", ";", "case", "CONST", ":", "return", "s390_cannot_force_const_mem", "(", "mode", ",", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ";", "case", "PLUS", ":", "case", "MINUS", ":", "return", "s390_cannot_force_const_mem", "(", "mode", ",", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "||", "s390_cannot_force_const_mem", "(", "mode", ",", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ";", "case", "UNSPEC", ":", "switch", "(", "XINT", "(", "x", ",", "<NUM_LIT>", ")", ")", "{", "case", "UNSPEC_LTREL_OFFSET", ":", "case", "UNSPEC_GOT", ":", "case", "UNSPEC_GOTOFF", ":", "case", "UNSPEC_PLTOFF", ":", "case", "UNSPEC_TLSGD", ":", "case", "UNSPEC_TLSLDM", ":", "case", "UNSPEC_NTPOFF", ":", "case", "UNSPEC_DTPOFF", ":", "case", "UNSPEC_GOTNTPOFF", ":", "case", "UNSPEC_INDNTPOFF", ":", "return", "false", ";", "case", "UNSPEC_INSN", ":", "return", "TARGET_CPU_ZARCH", ";", "default", ":", "return", "true", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}" ]

[ "Determine", "if", "it", "'s", "legal", "to", "put", "X", "into", "the", "constant", "pool", ".", "This", "is", "not", "possible", "if", "X", "contains", "the", "address", "of", "a", "symbol", "that", "is", "not", "constant", "(", "TLS", ")", "or", "not", "known", "at", "final", "link", "time", "(", "PIC", ")", "." ]

[ "_", "X", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m256d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_movedup_pd", "(", "_", "_", "m256d", "_", "_", "X", ")", "{", "return", "(", "_", "_", "m256d", ")", "_", "_", "builtin_ia32_movddup256", "(", "(", "_", "_", "v4df", ")", "_" ]

[ "<FIXS>", "auto", "*", "WasmSym", "=", "cast", "MCSymbolWasm", ">", "(", "Sym", ")", ";", "<FIXE>" ]

[ "if", "(", "WebAssembly", "::", "isCallIndirect", "(", "*", "MI", ")", ")", "Params", ".", "pop_back", "(", ")", ";", "<BUGS>", "MCSymbolWasm", "*", "WasmSym", "=", "cast", "MCSymbolWasm", ">", "(", "Sym", ")", ";", "<BUGE>", "auto", "Signature", "=", "make_unique", "<STR_LIT>", "::", "<STR_LIT>", ">", "(", "std", "::", "move", "(", "Returns", ")", ",", "std", "::", "move", "(", "Params", ")", ")", ";", "WasmSym", "->", "setSignature", "(", "Signature", ".", "get", "(", ")", ")", ";" ]

[ "=", "B", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "B", ";", "let", "Pattern", "=", "pattern", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "A", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}" ]

[ "ReplaceNode", "(", "N", ",", "CurDAG", "->", "getMachineNode", "(", "ARM", "::", "t2MSR_M", ",", "DL", ",", "MVT", "::", "Other", ",", "Ops", ")", ")", ";" ]

[ "SDValue", "WriteValue", "[", "]", "=", "{", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", "}", ";", "Ops", ".", "insert", "(", "Ops", ".", "begin", "(", ")", "+", "<NUM_LIT>", ",", "WriteValue", ",", "WriteValue", "+", "<NUM_LIT>", ")", ";", "}", "Ops", ".", "push_back", "(", "getAL", "(", "CurDAG", ",", "DL", ")", ")", ";", "Ops", ".", "push_back", "(", "CurDAG", "->", "getRegister", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "Ops", ".", "push_back", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "ReplaceNode", "(", "N", ",", "CurDAG", "->", "getMachineNode", "(", "Opcode", ",", "DL", ",", "MVT", "::", "Other", ",", "Ops", ")", ")", ";", "return", "true", ";", "}", "std", "::", "string", "SpecialReg", "=", "RegString", "->", "getString", "(", ")", ".", "lower", "(", ")", ";", "int", "BankedReg", "=", "getBankedRegisterMask", "(", "SpecialReg", ")", ";", "if", "(", "BankedReg", "!=", "-", "<NUM_LIT>", ")", "{", "Ops", "=", "{", "CurDAG", "->", "getTargetConstant", "(", "BankedReg", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "getAL", "(", "CurDAG", ",", "DL", ")", ",", "CurDAG", "->", "getRegister", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", "}", ";", "ReplaceNode", "(", "N", ",", "CurDAG", "->", "getMachineNode", "(", "IsThumb2", "?", "ARM", "::", "t2MSRbanked", ":", "ARM", "::", "MSRbanked", ",", "DL", ",", "MVT", "::", "Other", ",", "Ops", ")", ")", ";", "return", "true", ";", "}", "unsigned", "Opcode", "=", "StringSwitch", "<", "unsigned", ">", "(", "SpecialReg", ")", ".", "Case", "(", "<STR_LIT>", "fpscr", "<STR_LIT>", ",", "ARM", "::", "VMSR", ")", ".", "Case", "(", "<STR_LIT>", "fpexc", "<STR_LIT>", ",", "ARM", "::", "VMSR_FPEXC", ")", ".", "Case", "(", "<STR_LIT>", "fpsid", "<STR_LIT>", ",", "ARM", "::", "VMSR_FPSID", ")", ".", "Case", "(", "<STR_LIT>", "fpinst", "<STR_LIT>", ",", "ARM", "::", "VMSR_FPINST", ")", ".", "Case", "(", "<STR_LIT>", "fpinst2", "<STR_LIT>", ",", "ARM", "::", "VMSR_FPINST2", ")", ".", "Default", "(", "<NUM_LIT>", ")", ";", "if", "(", "Opcode", ")", "{", "if", "(", "!", "Subtarget", "->", "hasVFP2Base", "(", ")", ")", "return", "false", ";", "Ops", "=", "{", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "getAL", "(", "CurDAG", ",", "DL", ")", ",", "CurDAG", "->", "getRegister", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", "}", ";", "ReplaceNode", "(", "N", ",", "CurDAG", "->", "getMachineNode", "(", "Opcode", ",", "DL", ",", "MVT", "::", "Other", ",", "Ops", ")", ")", ";", "return", "true", ";", "}", "std", "::", "pair", "<", "StringRef", ",", "StringRef", ">", "Fields", ";", "Fields", "=", "StringRef", "(", "SpecialReg", ")", ".", "rsplit", "(", "'", "_", "'", ")", ";", "std", "::", "string", "Reg", "=", "Fields", ".", "first", ".", "str", "(", ")", ";", "StringRef", "Flags", "=", "Fields", ".", "second", ";", "if", "(", "Subtarget", "->", "isMClass", "(", ")", ")", "{", "int", "SYSmValue", "=", "getMClassRegisterMask", "(", "SpecialReg", ",", "Subtarget", ")", ";", "if", "(", "SYSmValue", "==", "-", "<NUM_LIT>", ")", "return", "false", ";", "SDValue", "Ops", "[", "]", "=", "{", "CurDAG", "->", "getTargetConstant", "(", "SYSmValue", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "getAL", "(", "CurDAG", ",", "DL", ")", ",", "CurDAG", "->", "getRegister", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", "}", ";" ]

[ "[", "In64BitMode", "]", ">", ";" ]

[ "def", "MFVSRLD", ":", "XX1_RS6_RD5_XO", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "g8rc", ":", "$", "rA", ")", ",", "(", "ins", "vsrc", ":", "$", "XT", ")", ",", "<STR_LIT>", ",", "IIC_VecGeneral", ",", "[", "]", ">", ",", "Requires", "<" ]

[ "else", "MIB", ".", "addOperand", "(", "MI", "->", "getOperand", "(", "i", ")", ")", ";" ]

[ "MachineBasicBlock", "*", "X86TargetLowering", "::", "emitEHSjLjLongJmp", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", "->", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "MF", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MachineInstr", "::", "mmo_iterator", "MMOBegin", "=", "MI", "->", "memoperands_begin", "(", ")", ";", "MachineInstr", "::", "mmo_iterator", "MMOEnd", "=", "MI", "->", "memoperands_end", "(", ")", ";", "MVT", "PVT", "=", "getPointerTy", "(", ")", ";", "assert", "(", "(", "PVT", "==", "MVT", "::", "i64", "||", "PVT", "==", "MVT", "::", "i32", ")", "&&", "<STR_LIT>", "Invalid Pointer Size!", "<STR_LIT>", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "(", "PVT", "==", "MVT", "::", "i64", ")", "?", "&", "X86", "::", "GR64RegClass", ":", "&", "X86", "::", "GR32RegClass", ";", "unsigned", "Tmp", "=", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ";", "const", "X86RegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "X86RegisterInfo", "*", ">", "(", "MF", "->", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "unsigned", "FP", "=", "(", "PVT", "==", "MVT", "::", "i64", ")", "?", "X86", "::", "RBP", ":", "X86", "::", "EBP", ";", "unsigned", "SP", "=", "RegInfo", "->", "getStackRegister", "(", ")", ";", "MachineInstrBuilder", "MIB", ";", "const", "int64_t", "LabelOffset", "=", "<NUM_LIT>", "*", "PVT", ".", "getStoreSize", "(", ")", ";", "const", "int64_t", "SPOffset", "=", "<NUM_LIT>", "*", "PVT", ".", "getStoreSize", "(", ")", ";", "unsigned", "PtrLoadOpc", "=", "(", "PVT", "==", "MVT", "::", "i64", ")", "?", "X86", "::", "MOV64rm", ":", "X86", "::", "MOV32rm", ";", "unsigned", "IJmpOpc", "=", "(", "PVT", "==", "MVT", "::", "i64", ")", "?", "X86", "::", "JMP64r", ":", "X86", "::", "JMP32r", ";", "MIB", "=", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "PtrLoadOpc", ")", ",", "FP", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "X86", "::", "AddrNumOperands", ";", "++", "i", ")", "MIB", ".", "addOperand", "(", "MI", "->", "getOperand", "(", "i", ")", ")", ";", "MIB", ".", "setMemRefs", "(", "MMOBegin", ",", "MMOEnd", ")", ";", "MIB", "=", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "PtrLoadOpc", ")", ",", "Tmp", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "X86", "::", "AddrNumOperands", ";", "++", "i", ")", "{", "if", "(", "i", "==", "X86", "::", "AddrDisp", ")", "MIB", ".", "addDisp", "(", "MI", "->", "getOperand", "(", "i", ")", ",", "LabelOffset", ")", ";", "else", "MIB", ".", "addOperand", "(", "MI", "->", "getOperand", "(", "i", ")", ")", ";", "}", "MIB", ".", "setMemRefs", "(", "MMOBegin", ",", "MMOEnd", ")", ";", "MIB", "=", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "PtrLoadOpc", ")", ",", "SP", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "X86", "::", "AddrNumOperands", ";", "++", "i", ")", "{", "if", "(", "i", "==", "X86", "::", "AddrDisp", ")", "MIB", ".", "addDisp", "(", "MI", "->", "getOperand", "(", "i", ")", ",", "SPOffset", ")", ";" ]

[ "==", "MEM", ")", ")", "return", "<NUM_LIT>", ";" ]

[ "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", "!=", "<NUM_LIT>", "&&", "(", "GET_CODE", "(", "SET_DEST", "(", "set", ")", ")", "==", "MEM", "||", "GET_CODE", "(", "SET_SRC", "(", "set", ")", ")" ]

[ "GPR32", ">", ";" ]

[ "def", "ATOMIC_SWAP_I8", ":", "Atomic2Ops", "<", "atomic_swap_8", "," ]

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

[ "return", "AMDGPU", "::", "isGFX10Plus", "(" ]

[ "<FIXS>", "Chain", "=", "EmitTailCallStoreRetAddr", "(", "DAG", ",", "MF", ",", "Chain", ",", "RetAddrFrIdx", ",", "Is64Bit", ",", "FPDiff", ")", ";", "<FIXE>" ]

[ "Chain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "MVT", "::", "Other", ",", "&", "MemOpChains2", "[", "<NUM_LIT>", "]", ",", "MemOpChains2", ".", "size", "(", ")", ")", ";", "<BUGS>", "if", "(", "FPDiff", ")", "{", "int", "SlotSize", "=", "Is64Bit", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "int", "NewReturnAddrFI", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "CreateFixedObject", "(", "SlotSize", ",", "FPDiff", "-", "SlotSize", ")", ";", "MVT", "::", "ValueType", "VT", "=", "Is64Bit", "?", "MVT", "::", "i64", ":", "MVT", "::", "i32", ";", "SDOperand", "NewRetAddrFrIdx", "=", "DAG", ".", "getFrameIndex", "(", "NewReturnAddrFI", ",", "VT", ")", ";", "Chain", "=", "DAG", ".", "getStore", "(", "Chain", ",", "RetAddrFrIdx", ",", "NewRetAddrFrIdx", ",", "PseudoSourceValue", "::", "getFixedStack", "(", ")", ",", "NewReturnAddrFI", ")", ";", "}", "<BUGE>", "}" ]

[ "$", "Rm", ")", ")", ")", ",", "(", "FRSQRTSddd", "FPR64", ":", "$", "Rn", ",", "FPR64", ":", "$", "Rm", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v1f64", "(", "int_arm_neon_vrsqrts", "(", "v1f64", "FPR64", ":", "$", "Rn", ")", ",", "(", "v1f64", "FPR64", ":" ]

[ "}" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "asr", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "ror", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "msl", "<STR_LIT>", ";" ]

[ "}" ]

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

[ "}" ]

[ "let", "PredicateMethod", "=", "<STR_LIT>", ";", "let", "RenderMethod", "=", "<STR_LIT>", ";" ]

[ "}" ]

[ "if", "(", "hasFP", "(", "MF", ")", ")", "{", "SavedRegs", ".", "set", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "SavedRegs", ".", "set", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";" ]

[ "<FIXS>", "const", "char", "Emitter", "::", "ID", "=", "<NUM_LIT>", ";", "<FIXE>" ]

[ "bool", "isX86_64ExtendedReg", "(", "const", "MachineOperand", "&", "MO", ")", ";", "unsigned", "determineREX", "(", "const", "MachineInstr", "&", "MI", ")", ";", "}", ";", "<BUGS>", "const", "int", "Emitter", "::", "ID", "=", "<NUM_LIT>", ";", "<BUGE>", "}" ]

[ "<FIXS>", "assert", "(", "Subtarget", ".", "hasSVEorSME", "(", ")", "&&", "<STR_LIT>", "Unexpected SVE register.", "<STR_LIT>", ")", ";", "<FIXE>" ]

[ "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "DestReg", ")", "&&", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "SrcReg", ")", ")", "{", "<BUGS>", "assert", "(", "(", "Subtarget", ".", "hasSVE", "(", ")", "||", "Subtarget", ".", "hasSME", "(", ")", ")", "&&", "<STR_LIT>", "Unexpected SVE register.", "<STR_LIT>", ")", ";", "<BUGE>", "static", "const", "unsigned", "Indices", "[", "]", "=", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "}", ";", "copyPhysRegTuple", "(", "MBB", ",", "I", ",", "DL", ",", "DestReg", ",", "SrcReg", ",", "KillSrc", ",", "<STR_LIT>", "::", "<STR_LIT>", "," ]

[ "else", "gcc_unreachable", "(", ")", ";" ]

[ "rtx", "addr", "=", "NULL", ";", "if", "(", "!", "slot", "||", "REG_P", "(", "slot", ")", ")", "{", "gcc_assert", "(", "CONST_INT_P", "(", "slot_no", ")", ")", ";", "addr", "=", "plus_constant", "(", "Pmode", ",", "special_base", ",", "-", "(", "INTVAL", "(", "slot_no", ")", "+", "<NUM_LIT>", ")", "*", "GET_MODE_SIZE", "(", "Pmode", ")", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "slot", ")", ")", "{", "addr", "=", "XEXP", "(", "slot", ",", "<NUM_LIT>", ")", ";", "if", "(", "!", "register_operand", "(", "addr", ",", "Pmode", ")", ")", "addr", "=", "copy_addr_to_reg", "(", "addr", ")", ";", "}" ]

[ "<FIXS>", "if", "(", "isInlinableIntLiteral", "(", "SImm", ")", ")", "{", "<FIXE>" ]

[ "printOperand", "(", "MI", ",", "OpNo", ",", "STI", ",", "O", ")", ";", "}", "void", "AMDGPUInstPrinter", "::", "printImmediate16", "(", "uint32_t", "Imm", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "O", ")", "{", "int16_t", "SImm", "=", "static_cast", "int16_t", ">", "(", "Imm", ")", ";", "<BUGS>", "if", "(", "SImm", ">=", "-", "<NUM_LIT>", "&&", "SImm", "<=", "<NUM_LIT>", ")", "{", "<BUGE>", "O", "<<", "SImm", ";", "return", ";", "}" ]

[ "if", "(", "CONST_INT_P", "(", "x", ")", ")", "output_addr_const", "(", "file", ",", "x", ")", ";" ]

[ "loongarch_print_operand", "(", "file", ",", "addr", ".", "offset", ",", "<NUM_LIT>", ")", ";", "return", ";", "case", "ADDRESS_REG_REG", ":", "fprintf", "(", "file", ",", "<STR_LIT>", "%s,%s", "<STR_LIT>", ",", "reg_names", "[", "REGNO", "(", "addr", ".", "reg", ")", "]", ",", "reg_names", "[", "REGNO", "(", "addr", ".", "offset", ")", "]", ")", ";", "return", ";", "case", "ADDRESS_LO_SUM", ":", "fprintf", "(", "file", ",", "<STR_LIT>", "%s,", "<STR_LIT>", ",", "reg_names", "[", "REGNO", "(", "addr", ".", "reg", ")", "]", ")", ";", "loongarch_print_operand_reloc", "(", "file", ",", "addr", ".", "offset", ",", "false", ",", "false", ")", ";", "return", ";", "case", "ADDRESS_CONST_INT", ":", "fprintf", "(", "file", ",", "<STR_LIT>", "%s,", "<STR_LIT>", ",", "reg_names", "[", "GP_REG_FIRST", "]", ")", ";", "output_addr_const", "(", "file", ",", "x", ")", ";", "return", ";", "case", "ADDRESS_SYMBOLIC", ":", "output_addr_const", "(", "file", ",", "loongarch_strip_unspec_address", "(", "x", ")", ")", ";", "return", ";", "}" ]

[ ")", "return", "Result", ";" ]

[ "unsigned", "asB", "=", "LocB", ".", "Ptr", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ";", "AliasResult", "Result", "=", "getAliasResult", "(", "asA", ",", "asB", ")", ";", "if", "(", "Result", "==", "NoAlias" ]

[ "return", "group_count", ";" ]

[ "group_insns", "[", "slot", "]", "=", "insn", ";", "can_issue_more", "=", "rs6000_variable_issue", "(", "dump", ",", "sched_verbose", ",", "insn", ",", "can_issue_more", ")", ";", "if", "(", "insn_terminates_group_p", "(", "insn", ",", "current_group", ")", ")", "can_issue_more", "=", "<NUM_LIT>", ";", "next_insn", "=", "get_next_active_insn", "(", "insn", ",", "tail", ")", ";", "if", "(", "next_insn", "==", "NULL_RTX", ")", "return", "group_count", "+", "<NUM_LIT>", ";", "group_end", "=", "(", "can_issue_more", "==", "<NUM_LIT>", "||", "(", "can_issue_more", "==", "<NUM_LIT>", "&&", "!", "is_branch_slot_insn", "(", "next_insn", ")", ")", "||", "(", "can_issue_more", "<=", "<NUM_LIT>", "&&", "is_cracked_insn", "(", "next_insn", ")", ")", "||", "(", "can_issue_more", "<", "issue_rate", "&&", "insn_terminates_group_p", "(", "next_insn", ",", "previous_group", ")", ")", ")", ";", "can_issue_more", "=", "force_new_group", "(", "sched_verbose", ",", "dump", ",", "group_insns", ",", "next_insn", ",", "&", "group_end", ",", "can_issue_more", ",", "&", "group_count", ")", ";", "if", "(", "group_end", ")", "{", "group_count", "++", ";", "can_issue_more", "=", "<NUM_LIT>", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "issue_rate", ";", "i", "++", ")", "{", "group_insns", "[", "i", "]", "=", "<NUM_LIT>", ";", "}", "}", "if", "(", "GET_MODE", "(", "next_insn", ")", "==", "TImode", "&&", "can_issue_more", ")", "PUT_MODE", "(", "next_insn", ",", "VOIDmode", ")", ";", "else", "if", "(", "!", "can_issue_more", "&&", "GET_MODE", "(", "next_insn", ")", "!=", "TImode", ")", "PUT_MODE", "(", "next_insn", ",", "TImode", ")", ";", "insn", "=", "next_insn", ";", "if", "(", "can_issue_more", "==", "<NUM_LIT>", ")", "can_issue_more", "=", "issue_rate", ";", "}" ]

[ "let", "addrMode", "=", "BaseImmOffset", ";" ]

[ "def", "L4_ior_memopb_io", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "u32_0Imm", ":", "$", "Ii", ",", "u5_0Imm", ":", "$", "II", ")", ",", "<STR_LIT>", ",", "tc_096199d3", ",", "TypeV4LDST", ">", ",", "Enc_46c951", "{", "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", "Constraints", "=", "<STR_LIT>", ";" ]

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

[ "void", "PPCRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Unexpected", "<STR_LIT>", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "unsigned", "OffsetOperandNo", "=", "getOffsetONFromFION", "(", "MI", ",", "FIOperandNum", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "PPCFunctionInfo", "*", "FI", "=", "MF", ".", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "int", "FPSI", "=", "FI", "->", "getFramePointerSaveIndex", "(", ")", ";", "unsigned", "OpC", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "FPSI", "&&", "FrameIndex", "==", "FPSI", "&&", "(", "OpC", "==", "PPC", "::", "DYNALLOC", "||", "OpC", "==", "PPC", "::", "DYNALLOC8", ")", ")", "{", "lowerDynamicAlloc", "(", "II", ")", ";", "return", ";", "}", "if", "(", "OpC", "==", "PPC", "::", "SPILL_CR", ")", "{", "lowerCRSpilling", "(", "II", ",", "FrameIndex", ")", ";", "return", ";", "}", "else", "if", "(", "OpC", "==", "PPC", "::", "RESTORE_CR", ")", "{", "lowerCRRestore", "(", "II", ",", "FrameIndex", ")", ";", "return", ";", "}", "else", "if", "(", "OpC", "==", "PPC", "::", "SPILL_CRBIT", ")", "{", "lowerCRBitSpilling", "(", "II", ",", "FrameIndex", ")", ";", "return", ";", "}", "else", "if", "(", "OpC", "==", "PPC", "::", "RESTORE_CRBIT", ")", "{", "lowerCRBitRestore", "(", "II", ",", "FrameIndex", ")", ";", "return", ";", "}", "else", "if", "(", "OpC", "==", "PPC", "::", "SPILL_VRSAVE", ")", "{", "lowerVRSAVESpilling", "(", "II", ",", "FrameIndex", ")", ";", "return", ";", "}", "else", "if", "(", "OpC", "==", "PPC", "::", "RESTORE_VRSAVE", ")", "{", "lowerVRSAVERestore", "(", "II", ",", "FrameIndex", ")", ";", "return", ";", "}", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FrameIndex", "<", "<NUM_LIT>", "?", "getBaseRegister", "(", "MF", ")", ":", "getFrameRegister", "(", "MF", ")", ",", "false", ")", ";", "bool", "isIXAddr", "=", "usesIXAddr", "(", "MI", ")", ";", "bool", "noImmForm", "=", "!", "MI", ".", "isInlineAsm", "(", ")", "&&", "OpC", "!=", "TargetOpcode", "::", "STACKMAP", "&&", "OpC", "!=", "TargetOpcode", "::", "PATCHPOINT", "&&", "!", "ImmToIdxMap", ".", "count", "(", "OpC", ")", ";", "int", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "OffsetOperandNo", ")", ".", "getImm", "(", ")", ";", "if", "(", "!", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "Naked", ")", ")", "{", "if", "(", "!", "(", "hasBasePointer", "(", "MF", ")", "&&", "FrameIndex", "<", "<NUM_LIT>", ")", ")", "Offset", "+=", "MFI", "->", "getStackSize", "(", ")", ";", "}", "assert", "(", "OpC", "!=", "PPC", "::", "DBG_VALUE", "&&", "<STR_LIT>", "This should be handled in a target-independent way", "<STR_LIT>", ")", ";", "if", "(", "!", "noImmForm", "&&", "(", "(", "isInt", "<", "<NUM_LIT>", ">", "(", "Offset", ")", "&&", "(", "!", "isIXAddr", "||", "(", "Offset", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", ")", "||", "OpC", "==", "TargetOpcode", "::", "STACKMAP", "||", "OpC", "==", "TargetOpcode", "::", "PATCHPOINT", ")", ")", "{", "MI", ".", "getOperand", "(", "OffsetOperandNo", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "bool", "is64Bit", "=", "Subtarget", ".", "isPPC64", "(", ")", ";", "const", "TargetRegisterClass", "*", "G8RC", "=", "&", "PPC", "::", "G8RCRegClass", ";", "const", "TargetRegisterClass", "*", "GPRC", "=", "&", "PPC", "::", "GPRCRegClass", ";", "const", "TargetRegisterClass", "*", "RC", "=", "is64Bit", "?", "G8RC", ":", "GPRC", ";", "unsigned", "SRegHi", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "RC", ")", ",", "SReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "RC", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "is64Bit", "?", "PPC", "::", "LIS8", ":", "PPC", "::", "LIS", ")", ",", "SRegHi", ")", ".", "addImm", "(", "Offset", ">>", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "is64Bit", "?", "PPC", "::", "ORI8", ":", "PPC", "::", "ORI", ")", ",", "SReg", ")", ".", "addReg", "(", "SRegHi", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "Offset", ")", ";", "unsigned", "OperandBase", ";", "if", "(", "noImmForm", ")", "OperandBase", "=", "<NUM_LIT>", ";", "else", "if", "(", "OpC", "!=", "TargetOpcode", "::", "INLINEASM", ")", "{", "assert", "(", "ImmToIdxMap", ".", "count", "(", "OpC", ")", "&&", "<STR_LIT>", "No indexed form of load or store available!", "<STR_LIT>", ")", ";", "unsigned", "NewOpcode", "=", "ImmToIdxMap", ".", "find", "(", "OpC", ")", "->", "second", ";", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "NewOpcode", ")", ")", ";", "OperandBase", "=", "<NUM_LIT>", ";", "}", "else", "{", "OperandBase", "=", "OffsetOperandNo", ";", "}", "unsigned", "StackReg", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getReg", "(", ")", ";", "MI", ".", "getOperand", "(", "OperandBase", ")", ".", "ChangeToRegister", "(", "StackReg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "OperandBase", "+", "<NUM_LIT>", ")", ".", "ChangeToRegister", "(", "SReg", ",", "false", ",", "false", ",", "true", ")", ";", "}" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

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

[ "}" ]

[ "case", "SHIFT_ASHIFT", ":", "info", "->", "special", "=", "<STR_LIT>", "mov.w\\t%e0,%f4\\n\\tmov.b\\t%s4,%t4\\n\\tmov.b\\t%t0,%s4\\n\\tmov.b\\t%s0,%t0\\n\\tsub.b\\t%s0,%s0\\n\\tmov.w\\t%f4,%e0", "<STR_LIT>", ";", "goto", "end", ";", "case", "SHIFT_LSHIFTRT", ":", "info", "->", "special", "=", "<STR_LIT>", "mov.w\\t%e0,%f4\\n\\tmov.b\\t%t0,%s0\\n\\tmov.b\\t%s4,%t0\\n\\tmov.b\\t%t4,%s4\\n\\textu.w\\t%f4\\n\\tmov.w\\t%f4,%e0", "<STR_LIT>", ";", "goto", "end", ";", "case", "SHIFT_ASHIFTRT", ":", "info", "->", "special", "=", "<STR_LIT>", "mov.w\\t%e0,%f4\\n\\tmov.b\\t%t0,%s0\\n\\tmov.b\\t%s4,%t0\\n\\tmov.b\\t%t4,%s4\\n\\texts.w\\t%f4\\n\\tmov.w\\t%f4,%e0", "<STR_LIT>", ";", "goto", "end", ";", "}", "}", "else", "if", "(", "count", "==", "<NUM_LIT>", "&&", "TARGET_H8300", ")", "{", "switch", "(", "shift_type", ")", "{", "case", "SHIFT_ASHIFT", ":", "gcc_unreachable", "(", ")", ";", "case", "SHIFT_LSHIFTRT", ":", "info", "->", "special", "=", "<STR_LIT>", "bld\\t#7,%z0\\n\\tmov.w\\t%e0,%f0\\n\\txor\\t%y0,%y0\\n\\txor\\t%z0,%z0\\n\\trotxl\\t%w0\\n\\trotxl\\t%x0\\n\\trotxl\\t%y0", "<STR_LIT>", ";", "goto", "end", ";", "case", "SHIFT_ASHIFTRT", ":", "info", "->", "special", "=", "<STR_LIT>", "bld\\t#7,%z0\\n\\tmov.w\\t%e0,%f0\\n\\trotxl\\t%w0\\n\\trotxl\\t%x0\\n\\tsubx\\t%y0,%y0\\n\\tsubx\\t%z0,%z0", "<STR_LIT>", ";", "goto", "end", ";", "}", "}", "else", "if", "(", "count", "==", "<NUM_LIT>", "&&", "!", "TARGET_H8300", ")", "{", "switch", "(", "shift_type", ")", "{", "case", "SHIFT_ASHIFT", ":", "info", "->", "special", "=", "<STR_LIT>", "shlr.w\\t%e0\\n\\tmov.w\\t%f0,%e0\\n\\txor.w\\t%f0,%f0\\n\\trotxr.l\\t%S0", "<STR_LIT>", ";", "info", "->", "cc_special", "=", "CC_SET_ZNV", ";", "goto", "end", ";", "case", "SHIFT_LSHIFTRT", ":", "info", "->", "special", "=", "<STR_LIT>", "shll.w\\t%f0\\n\\tmov.w\\t%e0,%f0\\n\\txor.w\\t%e0,%e0\\n\\trotxl.l\\t%S0", "<STR_LIT>", ";", "info", "->", "cc_special", "=", "CC_SET_ZNV", ";", "goto", "end", ";", "case", "SHIFT_ASHIFTRT", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "if", "(", "(", "TARGET_H8300", "&&", "<NUM_LIT>", "<=", "count", "&&", "count", "<=", "<NUM_LIT>", ")", "||", "(", "TARGET_H8300H", "&&", "<NUM_LIT>", "<=", "count", "&&", "count", "<=", "<NUM_LIT>", ")", "||", "(", "TARGET_H8300S", "&&", "<NUM_LIT>", "<=", "count", "&&", "count", "<=", "<NUM_LIT>", ")", ")", "{", "info", "->", "remainder", "=", "count", "-", "<NUM_LIT>", ";", "switch", "(", "shift_type", ")", "{", "case", "SHIFT_ASHIFT", ":", "info", "->", "special", "=", "<STR_LIT>", "mov.w\\t%f0,%e0\\n\\tsub.w\\t%f0,%f0", "<STR_LIT>", ";", "if", "(", "TARGET_H8300", ")", "info", "->", "shift1", "=", "<STR_LIT>", "add.w\\t%e0,%e0", "<STR_LIT>", ";", "goto", "end", ";", "case", "SHIFT_LSHIFTRT", ":", "if", "(", "TARGET_H8300", ")", "{", "info", "->", "special", "=", "<STR_LIT>", "mov.w\\t%e0,%f0\\n\\tsub.w\\t%e0,%e0", "<STR_LIT>", ";", "info", "->", "shift1", "=", "<STR_LIT>", "shlr\\t%x0\\n\\trotxr\\t%w0", "<STR_LIT>", ";", "}", "else", "{", "info", "->", "special", "=", "<STR_LIT>", "mov.w\\t%e0,%f0\\n\\textu.l\\t%S0", "<STR_LIT>", ";", "info", "->", "cc_special", "=", "CC_SET_ZNV", ";", "}", "goto", "end", ";", "case", "SHIFT_ASHIFTRT", ":", "if", "(", "TARGET_H8300", ")", "{", "info", "->", "special", "=", "<STR_LIT>", "mov.w\\t%e0,%f0\\n\\tshll\\t%z0\\n\\tsubx\\t%z0,%z0\\n\\tmov.b\\t%z0,%y0", "<STR_LIT>", ";", "info", "->", "shift1", "=", "<STR_LIT>", "shar\\t%x0\\n\\trotxr\\t%w0", "<STR_LIT>", ";", "}", "else", "{", "info", "->", "special", "=", "<STR_LIT>", "mov.w\\t%e0,%f0\\n\\texts.l\\t%S0", "<STR_LIT>", ";", "info", "->", "cc_special", "=", "CC_SET_ZNV", ";", "}", "goto", "end", ";", "}", "}", "else", "if", "(", "TARGET_H8300", "&&", "<NUM_LIT>", "<=", "count", "&&", "count", "<=", "<NUM_LIT>", ")", "{", "info", "->", "remainder", "=", "count", "-", "<NUM_LIT>", ";", "switch", "(", "shift_type", ")", "{", "case", "SHIFT_ASHIFT", ":", "info", "->", "special", "=", "<STR_LIT>", "mov.b\\t%w0,%z0\\n\\tsub.b\\t%y0,%y0\\n\\tsub.w\\t%f0,%f0", "<STR_LIT>", ";", "info", "->", "shift1", "=", "<STR_LIT>", "shll.b\\t%z0", "<STR_LIT>", ";", "info", "->", "cc_inline", "=", "CC_SET_ZNV", ";", "goto", "end", ";", "case", "SHIFT_LSHIFTRT", ":", "info", "->", "special", "=", "<STR_LIT>", "mov.b\\t%z0,%w0\\n\\tsub.b\\t%x0,%x0\\n\\tsub.w\\t%e0,%e0", "<STR_LIT>", ";", "info", "->", "shift1", "=", "<STR_LIT>", "shlr.b\\t%w0", "<STR_LIT>", ";", "info", "->", "cc_inline", "=", "CC_SET_ZNV", ";", "goto", "end", ";", "case", "SHIFT_ASHIFTRT", ":", "info", "->", "special", "=", "<STR_LIT>", "mov.b\\t%z0,%w0\\n\\tbld\\t#7,%w0\\n\\tsubx\\t%x0,%x0\\n\\tsubx\\t%y0,%y0\\n\\tsubx\\t%z0,%z0", "<STR_LIT>", ";", "info", "->", "shift1", "=", "<STR_LIT>", "shar.b\\t%w0", "<STR_LIT>", ";", "info", "->", "cc_inline", "=", "CC_SET_ZNV", ";", "goto", "end", ";", "}", "}", "else", "if", "(", "(", "TARGET_H8300H", "&&", "count", "==", "<NUM_LIT>", ")", "||", "(", "TARGET_H8300S", "&&", "<NUM_LIT>", "<=", "count", "&&", "count", "<=", "<NUM_LIT>", ")", ")", "{", "info", "->", "remainder", "=", "count", "-", "<NUM_LIT>", ";", "switch", "(", "shift_type", ")", "{", "case", "SHIFT_ASHIFT", ":", "info", "->", "special", "=", "<STR_LIT>", "mov.b\\t%s0,%t0\\n\\tsub.b\\t%s0,%s0\\n\\tmov.w\\t%f0,%e0\\n\\tsub.w\\t%f0,%f0", "<STR_LIT>", ";", "goto", "end", ";", "case", "SHIFT_LSHIFTRT", ":", "info", "->", "special", "=", "<STR_LIT>", "mov.w\\t%e0,%f0\\n\\tmov.b\\t%t0,%s0\\n\\textu.w\\t%f0\\n\\textu.l\\t%S0", "<STR_LIT>", ";", "info", "->", "cc_special", "=", "CC_SET_ZNV", ";", "goto", "end", ";", "case", "SHIFT_ASHIFTRT", ":", "info", "->", "special", "=", "<STR_LIT>", "mov.w\\t%e0,%f0\\n\\tmov.b\\t%t0,%s0\\n\\texts.w\\t%f0\\n\\texts.l\\t%S0", "<STR_LIT>", ";", "info", "->", "cc_special", "=", "CC_SET_ZNV", ";", "goto", "end", ";", "}", "}", "else", "if", "(", "!", "TARGET_H8300", "&&", "count", "==", "<NUM_LIT>", ")", "{", "switch", "(", "shift_type", ")", "{", "case", "SHIFT_ASHIFT", ":", "if", "(", "TARGET_H8300H", ")", "info", "->", "special", "=", "<STR_LIT>", "sub.w\\t%e0,%e0\\n\\trotr.l\\t%S0\\n\\trotr.l\\t%S0\\n\\trotr.l\\t%S0\\n\\trotr.l\\t%S0\\n\\tsub.w\\t%f0,%f0", "<STR_LIT>", ";", "else", "info", "->", "special", "=", "<STR_LIT>", "sub.w\\t%e0,%e0\\n\\trotr.l\\t#2,%S0\\n\\trotr.l\\t#2,%S0\\n\\tsub.w\\t%f0,%f0", "<STR_LIT>", ";", "goto", "end", ";", "case", "SHIFT_LSHIFTRT", ":", "if", "(", "TARGET_H8300H", ")", "{", "info", "->", "special", "=", "<STR_LIT>", "sub.w\\t%f0,%f0\\n\\trotl.l\\t%S0\\n\\trotl.l\\t%S0\\n\\trotl.l\\t%S0\\n\\trotl.l\\t%S0\\n\\textu.l\\t%S0", "<STR_LIT>", ";", "info", "->", "cc_special", "=", "CC_SET_ZNV", ";", "}", "else", "info", "->", "special", "=", "<STR_LIT>", "sub.w\\t%f0,%f0\\n\\trotl.l\\t#2,%S0\\n\\trotl.l\\t#2,%S0\\n\\textu.l\\t%S0", "<STR_LIT>", ";", "goto", "end", ";", "case", "SHIFT_ASHIFTRT", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "if", "(", "!", "TARGET_H8300", "&&", "count", "==", "<NUM_LIT>", ")", "{", "switch", "(", "shift_type", ")", "{", "case", "SHIFT_ASHIFT", ":", "if", "(", "TARGET_H8300H", ")", "info", "->", "special", "=", "<STR_LIT>", "sub.w\\t%e0,%e0\\n\\trotr.l\\t%S0\\n\\trotr.l\\t%S0\\n\\trotr.l\\t%S0\\n\\tsub.w\\t%f0,%f0", "<STR_LIT>", ";", "else", "info", "->", "special", "=", "<STR_LIT>", "sub.w\\t%e0,%e0\\n\\trotr.l\\t#2,%S0\\n\\trotr.l\\t%S0\\n\\tsub.w\\t%f0,%f0", "<STR_LIT>", ";", "goto", "end", ";", "case", "SHIFT_LSHIFTRT", ":", "if", "(", "TARGET_H8300H", ")", "{", "info", "->", "special", "=", "<STR_LIT>", "sub.w\\t%f0,%f0\\n\\trotl.l\\t%S0\\n\\trotl.l\\t%S0\\n\\trotl.l\\t%S0\\n\\textu.l\\t%S0", "<STR_LIT>", ";", "info", "->", "cc_special", "=", "CC_SET_ZNV", ";", "}", "else", "{", "info", "->", "special", "=", "<STR_LIT>", "sub.w\\t%f0,%f0\\n\\trotl.l\\t#2,%S0\\n\\trotl.l\\t%S0\\n\\textu.l\\t%S0", "<STR_LIT>", ";", "info", "->", "cc_special", "=", "CC_SET_ZNV", ";", "}", "goto", "end", ";", "case", "SHIFT_ASHIFTRT", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "if", "(", "!", "TARGET_H8300", "&&", "count", "==", "<NUM_LIT>", ")", "{", "switch", "(", "shift_type", ")", "{", "case", "SHIFT_ASHIFT", ":", "if", "(", "TARGET_H8300H", ")", "info", "->", "special", "=", "<STR_LIT>", "sub.w\\t%e0,%e0\\n\\trotr.l\\t%S0\\n\\trotr.l\\t%S0\\n\\tsub.w\\t%f0,%f0", "<STR_LIT>", ";", "else", "info", "->", "special", "=", "<STR_LIT>", "sub.w\\t%e0,%e0\\n\\trotr.l\\t#2,%S0\\n\\tsub.w\\t%f0,%f0", "<STR_LIT>", ";", "goto", "end", ";", "case", "SHIFT_LSHIFTRT", ":", "if", "(", "TARGET_H8300H", ")", "info", "->", "special", "=", "<STR_LIT>", "sub.w\\t%f0,%f0\\n\\trotl.l\\t%S0\\n\\trotl.l\\t%S0\\n\\textu.l\\t%S0", "<STR_LIT>", ";", "else", "info", "->", "special", "=", "<STR_LIT>", "sub.w\\t%f0,%f0\\n\\trotl.l\\t#2,%S0\\n\\textu.l\\t%S0", "<STR_LIT>", ";", "goto", "end", ";", "case", "SHIFT_ASHIFTRT", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "if", "(", "count", "==", "<NUM_LIT>", ")", "{", "if", "(", "TARGET_H8300", ")", "{", "switch", "(", "shift_type", ")", "{", "case", "SHIFT_ASHIFT", ":", "info", "->", "special", "=", "<STR_LIT>", "sub.w\\t%e0,%e0\\n\\tshlr\\t%w0\\n\\tmov.w\\t%e0,%f0\\n\\trotxr\\t%z0", "<STR_LIT>", ";", "goto", "end", ";", "case", "SHIFT_LSHIFTRT", ":", "info", "->", "special", "=", "<STR_LIT>", "sub.w\\t%f0,%f0\\n\\tshll\\t%z0\\n\\tmov.w\\t%f0,%e0\\n\\trotxl\\t%w0", "<STR_LIT>", ";", "goto", "end", ";", "case", "SHIFT_ASHIFTRT", ":", "info", "->", "special", "=", "<STR_LIT>", "shll\\t%z0\\n\\tsubx\\t%w0,%w0\\n\\tmov.b\\t%w0,%x0\\n\\tmov.w\\t%f0,%e0", "<STR_LIT>", ";", "goto", "end", ";", "}", "}", "else", "{", "switch", "(", "shift_type", ")", "{", "case", "SHIFT_ASHIFT", ":", "info", "->", "special", "=", "<STR_LIT>", "shlr.l\\t%S0\\n\\txor.l\\t%S0,%S0\\n\\trotxr.l\\t%S0", "<STR_LIT>", ";", "info", "->", "cc_special", "=", "CC_SET_ZNV", ";", "goto", "end", ";", "case", "SHIFT_LSHIFTRT", ":", "info", "->", "special", "=", "<STR_LIT>", "shll.l\\t%S0\\n\\txor.l\\t%S0,%S0\\n\\trotxl.l\\t%S0", "<STR_LIT>", ";", "info", "->", "cc_special", "=", "CC_SET_ZNV", ";", "goto", "end", ";", "case", "SHIFT_ASHIFTRT", ":", "info", "->", "special", "=", "<STR_LIT>", "shll\\t%e0\\n\\tsubx\\t%w0,%w0\\n\\texts.w\\t%T0\\n\\texts.l\\t%S0", "<STR_LIT>", ";", "info", "->", "cc_special", "=", "CC_SET_ZNV", ";", "goto", "end", ";", "}", "}", "}", "gcc_unreachable", "(", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";" ]

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

[ "return", "_", "_", "builtin_loongson_pandn_uw", "(", "s" ]

[ ";" ]

[ "std", "::", "string", "FS", ";", "return", "FS" ]

[ ")", ")" ]

[ "(", "define_attr", "<STR_LIT>", "<STR_LIT>", "(", "const", "(", "if_then_else", "(", "symbol_ref", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", ")" ]

[ "src", ",", "dsub_0", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "insert_subvector", "undef", ",", "(", "v4i16", "DPR", ":", "$", "src", ")", ",", "(", "i32", "<NUM_LIT>", ")", ")", ",", "(", "INSERT_SUBREG", "(", "v8i16", "(", "IMPLICIT_DEF", ")", ")", ",", "DPR", ":", "$" ]

[ "for", "(", "const", "auto", "&", "SrcOp", ":", "Def", "->", "explicit_operands", "(", ")", ")", "if", "(", "SrcOp", ".", "isUse", "(", ")", "&&", "(", "!", "SrcOp", ".", "isReg", "(", ")", "||", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "SrcOp", ".", "getReg", "(", ")", ")", "||", "SrcOp", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "EXEC", ")", ")", "Src", ".", "push_back", "(", "SrcOp", ")", ";" ]

[ "if", "(", "!", "Op", ".", "isReg", "(", ")", "||", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "Op", ".", "getReg", "(", ")", ")", ")", "{", "Src", ".", "push_back", "(", "Op", ")", ";", "return", ";", "}", "MachineInstr", "*", "Def", "=", "MRI", "->", "getUniqueVRegDef", "(", "Op", ".", "getReg", "(", ")", ")", ";", "if", "(", "!", "Def", "||", "Def", "->", "getParent", "(", ")", "!=", "MI", ".", "getParent", "(", ")", "||", "!", "(", "Def", "->", "isFullCopy", "(", ")", "||", "(", "Def", "->", "getOpcode", "(", ")", "==", "MI", ".", "getOpcode", "(", ")", ")", ")", ")", "return", ";", "for", "(", "auto", "I", "=", "Def", "->", "getIterator", "(", ")", ";", "I", "!=", "MI", ".", "getIterator", "(", ")", ";", "++", "I", ")", "if", "(", "I", "->", "modifiesRegister", "(", "AMDGPU", "::", "EXEC", ",", "TRI", ")", "&&", "!", "(", "I", "->", "isCopy", "(", ")", "&&", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "!=", "AMDGPU", "::", "EXEC", ")", ")", "return", ";" ]

[ "v4i32", ",", "VReg_128", ">", ";" ]

[ "def", ":", "BitConvert", "<", "v2f64", "," ]

[ "<FIXS>", "machine_mode", "omode", ";", "<FIXE>", "<FIXS>", "omode", "=", "(", "machine_mode", ")", "insn_data", "[", "code", "]", ".", "operand", "[", "o", "]", ".", "mode", ";", "<FIXE>" ]

[ "{", "char", "ao", "=", "s16builtins", "[", "i", "]", ".", "arg_ops", "[", "o", "]", ";", "char", "c", "=", "insn_data", "[", "code", "]", ".", "operand", "[", "o", "]", ".", "constraint", "[", "<NUM_LIT>", "]", ";", "<BUGS>", "enum", "machine_mode", "omode", ";", "<BUGE>", "copyto", "[", "o", "]", "=", "<NUM_LIT>", ";", "<BUGS>", "omode", "=", "(", "enum", "machine_mode", ")", "insn_data", "[", "code", "]", ".", "operand", "[", "o", "]", ".", "mode", ";", "<BUGE>", "if", "(", "ao", "==", "'", "r", "'", ")", "op", "[", "o", "]", "=", "target", "?", "target", ":", "gen_reg_rtx", "(", "omode", ")", ";", "else", "if", "(", "ao", "==", "'", "t", "'", ")" ]

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

[ "def", "L2_loadrb_zomap", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_17e0d2cd", ",", "TypeMAPPING", ">", "{", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "isPseudo", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "static", "inline", "const", "MachineInstrBuilder", "&", "AddNoT1CC", "(", "const", "MachineInstrBuilder", "&", "MIB", ")", "{", "return", "MIB", ".", "addReg", "(", "<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", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=" ]

[ "(", "v4f32", "MQPR", ":", "$", "val1", ")", ",", "(", "v4f32", "MQPR", ":", "$", "val2", ")", ")", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v4f32", "(", "fmaxnum", "(", "v4f32", "MQPR", ":", "$", "val1", ")", ",", "(", "v4f32", "MQPR", ":", "$", "val2", ")", ")", ")", ",", "(", "v4f32", "(", "MVE_VMAXNMf32" ]

[ "PUT_MODE", "(", "condition_rtx", ",", "DImode", ")", ";" ]

[ "t", "=", "XEXP", "(", "condition_rtx", ",", "<NUM_LIT>", ")", ";", "gcc_assert", "(", "cond_code", "==", "NE", "||", "cond_code", "==", "EQ", ")", ";", "if", "(", "cond_code", "==", "NE", ")", "emit_insn", "(", "gen_e500_flip_gt_bit", "(", "t", ",", "t", ")", ")", ";", "emit_insn", "(", "gen_move_from_CR_gt_bit", "(", "result", ",", "t", ")", ")", ";", "return", ";", "}", "if", "(", "cond_code", "==", "NE", "||", "cond_code", "==", "GE", "||", "cond_code", "==", "LE", "||", "cond_code", "==", "GEU", "||", "cond_code", "==", "LEU", "||", "cond_code", "==", "ORDERED", "||", "cond_code", "==", "UNGE", "||", "cond_code", "==", "UNLE", ")", "{", "rtx", "not", "_", "result", "=", "gen_reg_rtx", "(", "CCEQmode", ")", ";", "rtx", "not", "_", "op", ",", "rev_cond_rtx", ";", "machine_mode", "cc_mode", ";", "cc_mode", "=", "GET_MODE", "(", "XEXP", "(", "condition_rtx", ",", "<NUM_LIT>", ")", ")", ";", "rev_cond_rtx", "=", "gen_rtx_fmt_ee", "(", "rs6000_reverse_condition", "(", "cc_mode", ",", "cond_code", ")", ",", "SImode", ",", "XEXP", "(", "condition_rtx", ",", "<NUM_LIT>", ")", ",", "const0_rtx", ")", ";", "not", "_", "op", "=", "gen_rtx_COMPARE", "(", "CCEQmode", ",", "rev_cond_rtx", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "not", "_", "result", ",", "not", "_", "op", ")", ")", ";", "condition_rtx", "=", "gen_rtx_EQ", "(", "VOIDmode", ",", "not", "_", "result", ",", "const0_rtx", ")", ";", "}", "op_mode", "=", "GET_MODE", "(", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ")", ";", "if", "(", "op_mode", "==", "VOIDmode", ")", "op_mode", "=", "GET_MODE", "(", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ")", ";", "if", "(", "TARGET_POWERPC64", "&&", "(", "op_mode", "==", "DImode", "||", "FLOAT_MODE_P", "(", "mode", ")", ")", ")", "{" ]

[ "override", "{" ]

[ "unsigned", "getMachineCSELookAheadLimit", "(", ")", "const" ]

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

[ "(", "define_predicate", "<STR_LIT>", "(", "ior", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>" ]

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

[ "static", "DecodeStatus", "DecodeSimm19Lsl2", "(", "MCInst", "&", "Inst", ",", "unsigned", "Insn", ",", "uint64_t", "Address", ",", "const", "void", "*", "Decoder", ")", "{", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "SignExtend32", "<", "<NUM_LIT>", ">", "(", "Insn", ")", "*", "<NUM_LIT>", ")", ")", ";" ]

[ "(", "mult", ":", "HI", "(", "sign_extend", ":", "HI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "minus", ":", "HI", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

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

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

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

[ "return", "new", "AArch64PromoteConstant" ]

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

[ "(", "define_predicate", "<STR_LIT>", "(", "ior", "(", "match_operand", "<NUM_LIT>" ]

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

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

[ "\t", "<NUM_LIT>", ")" ]

[ "(", "ROUND_TRUNC", "\t", "\t", "\t", "<NUM_LIT>", ")", "(", "ROUND_MXCSR", "\t", "\t" ]

[ "}" ]

[ "class", "MVE_MI", "<", "dag", "oops", ",", "dag", "iops", ",", "InstrItinClass", "itin", ",", "string", "asm", ",", "string", "ops", ",", "string", "cstr", ",", "list", "<", "dag", ">", "pattern", ">", ":", "Thumb2XI", "<", "oops", ",", "iops", ",", "AddrModeNone", ",", "<NUM_LIT>", ",", "itin", ",", "!", "strconcat", "(", "asm", ",", "<STR_LIT>", ",", "ops", ")", ",", "cstr", ",", "pattern", ">", ",", "Requires", "<", "[", "HasMVEInt", "]", ">", "{", "let", "D", "=", "MVEDomain", ";", "let", "DecoderNamespace", "=", "<STR_LIT>", ";" ]