Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "pc", ")", "(", "unspec", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "pc", ")" ]

[ "<FIXS>", "fprintf", "(", "file", ",", "<STR_LIT>", "%u,-", "<STR_LIT>", ",", "GET_MODE_SIZE", "(", "GET_MODE", "(", "op", ")", ")", ")", ";", "<FIXE>" ]

[ "case", "PRE_DEC", ":", "if", "(", "TARGET_M6812", ")", "{", "<BUGS>", "asm_fprintf", "(", "file", ",", "<STR_LIT>", "%u,-", "<STR_LIT>", ",", "GET_MODE_SIZE", "(", "GET_MODE", "(", "op", ")", ")", ")", ";", "<BUGE>", "asm_print_register", "(", "file", ",", "REGNO", "(", "XEXP", "(", "base", ",", "<NUM_LIT>", ")", ")", ")", ";", "}", "else" ]

[ "static", "int", "rs6000_sched_reorder2", "(", "FILE", "*", "dump", ",", "int", "sched_verbose", ",", "rtx_insn", "*", "*", "ready", ",", "int", "*", "pn_ready", ",", "int", "clock_var", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "sched_verbose", ")", "fprintf", "(", "dump", ",", "<STR_LIT>", "// rs6000_sched_reorder2 :\\n", "<STR_LIT>", ")", ";", "if", "(", "rs6000_cpu", "==", "PROCESSOR_POWER6", "&&", "last_scheduled_insn", ")", "{", "int", "pos", ";", "int", "i", ";", "rtx_insn", "*", "tmp", ";", "rtx", "load_mem", ",", "str_mem", ";", "if", "(", "is_store_insn", "(", "last_scheduled_insn", ",", "&", "str_mem", ")", ")", "load_store_pendulum", "--", ";", "else", "if", "(", "is_load_insn", "(", "last_scheduled_insn", ",", "&", "load_mem", ")", ")", "load_store_pendulum", "++", ";", "else", "return", "cached_can_issue_more", ";", "if", "(", "(", "load_store_pendulum", "==", "<NUM_LIT>", ")", "||", "(", "*", "pn_ready", "<=", "<NUM_LIT>", ")", ")", "return", "cached_can_issue_more", ";", "if", "(", "load_store_pendulum", "==", "<NUM_LIT>", ")", "{", "pos", "=", "*", "pn_ready", "-", "<NUM_LIT>", ";", "while", "(", "pos", ">=", "<NUM_LIT>", ")", "{", "if", "(", "is_load_insn", "(", "ready", "[", "pos", "]", ",", "&", "load_mem", ")", ")", "{", "tmp", "=", "ready", "[", "pos", "]", ";", "for", "(", "i", "=", "pos", ";", "i", "<", "*", "pn_ready", "-", "<NUM_LIT>", ";", "i", "++", ")", "ready", "[", "i", "]", "=", "ready", "[", "i", "+", "<NUM_LIT>", "]", ";", "ready", "[", "*", "pn_ready", "-", "<NUM_LIT>", "]", "=", "tmp", ";", "if", "(", "!", "sel_sched_p", "(", ")", "&&", "INSN_PRIORITY_KNOWN", "(", "tmp", ")", ")", "INSN_PRIORITY", "(", "tmp", ")", "++", ";", "break", ";", "}", "pos", "--", ";", "}", "}", "else", "if", "(", "load_store_pendulum", "==", "-", "<NUM_LIT>", ")", "{", "pos", "=", "*", "pn_ready", "-", "<NUM_LIT>", ";", "while", "(", "pos", ">=", "<NUM_LIT>", ")", "{", "if", "(", "is_load_insn", "(", "ready", "[", "pos", "]", ",", "&", "load_mem", ")", "&&", "!", "sel_sched_p", "(", ")", "&&", "INSN_PRIORITY_KNOWN", "(", "ready", "[", "pos", "]", ")", ")", "{", "INSN_PRIORITY", "(", "ready", "[", "pos", "]", ")", "++", ";", "load_store_pendulum", "--", ";", "break", ";", "}", "pos", "--", ";", "}", "}", "else", "if", "(", "load_store_pendulum", "==", "-", "<NUM_LIT>", ")", "{", "int", "first_store_pos", "=", "-", "<NUM_LIT>", ";", "pos", "=", "*", "pn_ready", "-", "<NUM_LIT>", ";", "while", "(", "pos", ">=", "<NUM_LIT>", ")", "{", "if", "(", "is_store_insn", "(", "ready", "[", "pos", "]", ",", "&", "str_mem", ")", ")", "{", "rtx", "str_mem2", ";", "if", "(", "first_store_pos", "==", "-", "<NUM_LIT>", ")", "first_store_pos", "=", "pos", ";", "if", "(", "is_store_insn", "(", "last_scheduled_insn", ",", "&", "str_mem2", ")", "&&", "adjacent_mem_locations", "(", "str_mem", ",", "str_mem2", ")", ")", "{", "tmp", "=", "ready", "[", "pos", "]", ";", "for", "(", "i", "=", "pos", ";", "i", "<", "*", "pn_ready", "-", "<NUM_LIT>", ";", "i", "++", ")", "ready", "[", "i", "]", "=", "ready", "[", "i", "+", "<NUM_LIT>", "]", ";", "ready", "[", "*", "pn_ready", "-", "<NUM_LIT>", "]", "=", "tmp", ";", "if", "(", "!", "sel_sched_p", "(", ")", "&&", "INSN_PRIORITY_KNOWN", "(", "tmp", ")", ")", "INSN_PRIORITY", "(", "tmp", ")", "++", ";", "first_store_pos", "=", "-", "<NUM_LIT>", ";", "break", ";", "}", ";", "}", "pos", "--", ";", "}", "if", "(", "first_store_pos", ">=", "<NUM_LIT>", ")", "{", "tmp", "=", "ready", "[", "first_store_pos", "]", ";", "for", "(", "i", "=", "first_store_pos", ";", "i", "<", "*", "pn_ready", "-", "<NUM_LIT>", ";", "i", "++", ")", "ready", "[", "i", "]", "=", "ready", "[", "i", "+", "<NUM_LIT>", "]", ";", "ready", "[", "*", "pn_ready", "-", "<NUM_LIT>", "]", "=", "tmp", ";", "if", "(", "!", "sel_sched_p", "(", ")", "&&", "INSN_PRIORITY_KNOWN", "(", "tmp", ")", ")", "INSN_PRIORITY", "(", "tmp", ")", "++", ";", "}", "}", "else", "if", "(", "load_store_pendulum", "==", "<NUM_LIT>", ")", "{", "pos", "=", "*", "pn_ready", "-", "<NUM_LIT>", ";", "while", "(", "pos", ">=", "<NUM_LIT>", ")", "{", "if", "(", "is_store_insn", "(", "ready", "[", "pos", "]", ",", "&", "str_mem", ")", "&&", "!", "sel_sched_p", "(", ")", "&&", "INSN_PRIORITY_KNOWN", "(", "ready", "[", "pos", "]", ")", ")", "{", "INSN_PRIORITY", "(", "ready", "[", "pos", "]", ")", "++", ";", "load_store_pendulum", "++", ";", "break", ";", "}", "pos", "--", ";", "}", "}", "}", "if", "(", "rs6000_cpu", "==", "PROCESSOR_POWER9", "&&", "last_scheduled_insn", "&&", "recog_memoized", "(", "last_scheduled_insn", ")", ">=", "<NUM_LIT>", ")", "return", "power9_sched_reorder2", "(", "ready", ",", "*", "pn_ready", "-", "<NUM_LIT>", ")", ";", "return", "cached_can_issue_more", ";", "}" ]

[ "Like", "rs6000_sched_reorder", ",", "but", "called", "after", "issuing", "each", "insn", "." ]

[ "return", "RC", ";" ]

[ "const", "TargetRegisterClass", "*", "SystemZRegisterInfo", "::", "getCrossCopyRegClass", "(", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "if", "(", "RC", "==", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "&", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

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

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

[ "static", "int", "iq2000_address_cost", "(", "rtx", "addr", ",", "machine_mode", "mode", ",", "addr_space_t", "as", ",", "bool", "speed", ")", "{", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "LO_SUM", ":", "return", "<NUM_LIT>", ";", "case", "LABEL_REF", ":", "return", "<NUM_LIT>", ";", "case", "CONST", ":", "{", "rtx", "offset", "=", "const0_rtx", ";", "addr", "=", "eliminate_constant_term", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ",", "&", "offset", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "LABEL_REF", ")", "return", "<NUM_LIT>", ";", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "SYMBOL_REF", ")", "return", "<NUM_LIT>", ";", "if", "(", "!", "SMALL_INT", "(", "offset", ")", ")", "return", "<NUM_LIT>", ";", "}", "case", "SYMBOL_REF", ":", "return", "SYMBOL_REF_FLAG", "(", "addr", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "case", "PLUS", ":", "{", "rtx", "plus0", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "rtx", "plus1", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "plus0", ")", "!=", "REG", "&&", "GET_CODE", "(", "plus1", ")", "==", "REG", ")", "plus0", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ",", "plus1", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "plus0", ")", "!=", "REG", ")", "break", ";", "switch", "(", "GET_CODE", "(", "plus1", ")", ")", "{", "case", "CONST_INT", ":", "return", "SMALL_INT", "(", "plus1", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "case", "HIGH", ":", "case", "LO_SUM", ":", "return", "iq2000_address_cost", "(", "plus1", ",", "mode", ",", "as", ",", "speed", ")", "+", "<NUM_LIT>", ";", "default", ":", "break", ";", "}", "}", "default", ":", "break", ";", "}", "return", "<NUM_LIT>", ";", "}" ]

[ "Provide", "the", "costs", "of", "an", "addressing", "mode", "that", "contains", "ADDR", "." ]

[ "{" ]

[ "(", "float", ":", "X87MODEF", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "[", "(", "const_int", "<NUM_LIT>", ")", "]" ]

[ "else", "return", "gen_altivec_lvx_v4si_internal", "(", "dest", ",", "src", ")", ";" ]

[ "gcc_assert", "(", "GET_MODE", "(", "dest", ")", "==", "V4SImode", "&&", "GET_MODE", "(", "src", ")", "==", "V4SImode", ")", ";", "if", "(", "MEM_P", "(", "dest", ")", ")", "return", "gen_altivec_stvx_v4si_internal", "(", "dest", ",", "src", ")", ";" ]

[ "Cost", ";" ]

[ "if", "(", "Opcode", "==", "Instruction", "::", "ExtractElement", ")", "{", "int", "Cost", "=", "(", "(", "Val", "->", "getScalarSizeInBits", "(", ")", "==", "<NUM_LIT>", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "if", "(", "Index", "==", "<NUM_LIT>", "&&", "Val", "->", "isIntOrIntVectorTy", "(", ")", ")", "Cost", "+=", "<NUM_LIT>", ";", "return" ]

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

[ "}", "if", "(", "ptr_mode", "==", "SImode", ")", "{", "opcode", "=", "<NUM_LIT>", ";", "size", "=", "<NUM_LIT>", ";", "}", "else", "{", "opcode", "=", "<NUM_LIT>", ";", "size", "=", "<NUM_LIT>", ";", "}", "mem", "=", "adjust_address", "(", "m_tramp", ",", "HImode", ",", "offset", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_int_mode", "(", "opcode", ",", "HImode", ")", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "ptr_mode", ",", "offset", "+", "<NUM_LIT>", ")", ";", "emit_move_insn", "(", "mem", ",", "chain_value", ")", ";", "offset", "+=", "size", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "offset", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_int_mode", "(", "<NUM_LIT>", ",", "SImode", ")", ")", ";", "offset", "+=", "<NUM_LIT>", ";", "}", "else", "{", "rtx", "disp", ",", "chain", ";", "chain", "=", "ix86_static_chain", "(", "fndecl", ",", "true", ")", ";", "if", "(", "REG_P", "(", "chain", ")", ")", "{", "switch", "(", "REGNO", "(", "chain", ")", ")", "{", "case", "AX_REG", ":", "opcode", "=", "<NUM_LIT>", ";", "break", ";", "case", "CX_REG", ":", "opcode", "=", "<NUM_LIT>", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "opcode", "=", "<NUM_LIT>", ";", "if", "(", "need_endbr", ")", "{", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "offset", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_int_mode", "(", "<NUM_LIT>", ",", "SImode", ")", ")", ";", "offset", "+=", "<NUM_LIT>", ";", "}", "mem", "=", "adjust_address", "(", "m_tramp", ",", "QImode", ",", "offset", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_int_mode", "(", "opcode", ",", "QImode", ")", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "offset", "+", "<NUM_LIT>", ")", ";", "emit_move_insn", "(", "mem", ",", "chain_value", ")", ";", "offset", "+=", "<NUM_LIT>", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "QImode", ",", "offset", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_int_mode", "(", "<NUM_LIT>", ",", "QImode" ]

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

[ "def", "A2_svaddh", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "IntRegs", ":", "$", "Rt32", ")", ",", "<STR_LIT>", ",", "tc_5a2711e5", ",", "TypeALU32_3op", ">", ",", "Enc_5ab2be", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

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

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

[ "_", "_", "a", ";" ]

[ "return", "(", "uint16x8_t", ")" ]

[ "<FIXS>", "tmp", "=", "gen_rtx_SET", "(", "gen_rtx_REG", "(", "fpcmp_mode", ",", "FLAGS_REG", ")", ",", "tmp", ")", ";", "<FIXE>", "<FIXS>", "tmp", "=", "gen_rtx_SET", "(", "gen_rtx_REG", "(", "fpcmp_mode", ",", "FLAGS_REG", ")", ",", "tmp", ")", ";", "<FIXE>" ]

[ "case", "IX86_FPCMP_COMI", ":", "intcmp_mode", "=", "fpcmp_mode", ";", "tmp", "=", "gen_rtx_COMPARE", "(", "fpcmp_mode", ",", "op0", ",", "op1", ")", ";", "<BUGS>", "tmp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "fpcmp_mode", ",", "FLAGS_REG", ")", ",", "tmp", ")", ";", "<BUGE>", "emit_insn", "(", "tmp", ")", ";", "break", ";", "case", "IX86_FPCMP_SAHF", ":", "intcmp_mode", "=", "fpcmp_mode", ";", "tmp", "=", "gen_rtx_COMPARE", "(", "fpcmp_mode", ",", "op0", ",", "op1", ")", ";", "<BUGS>", "tmp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "fpcmp_mode", ",", "FLAGS_REG", ")", ",", "tmp", ")", ";", "<BUGE>", "if", "(", "!", "scratch", ")", "scratch", "=", "gen_reg_rtx", "(", "HImode", ")", ";" ]

[ "SDValue", "WebAssemblyTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "assert", "(", "Outs", ".", "size", "(", ")", "<=", "<NUM_LIT>", "&&", "<STR_LIT>", "WebAssembly can only return up to one value", "<STR_LIT>", ")", ";", "if", "(", "!", "CallingConvSupported", "(", "CallConv", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "<STR_LIT>", "WebAssembly doesn't support non-C calling conventions", "<STR_LIT>", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "RetOps", "(", "<NUM_LIT>", ",", "Chain", ")", ";", "RetOps", ".", "append", "(", "OutVals", ".", "begin", "(", ")", ",", "OutVals", ".", "end", "(", ")", ")", ";", "Chain", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "for", "(", "const", "ISD", "::", "OutputArg", "&", "Out", ":", "Outs", ")", "{", "assert", "(", "!", "Out", ".", "Flags", ".", "isByVal", "(", ")", "&&", "<STR_LIT>", "byval is not valid for return values", "<STR_LIT>", ")", ";", "assert", "(", "!", "Out", ".", "Flags", ".", "isNest", "(", ")", "&&", "<STR_LIT>", "nest is not valid for return values", "<STR_LIT>", ")", ";", "assert", "(", "Out", ".", "IsFixed", "&&", "<STR_LIT>", "non-fixed return value is not valid", "<STR_LIT>", ")", ";", "if", "(", "Out", ".", "Flags", ".", "isInAlloca", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "<STR_LIT>", "WebAssembly hasn't implemented inalloca results", "<STR_LIT>", ")", ";", "if", "(", "Out", ".", "Flags", ".", "isInConsecutiveRegs", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "<STR_LIT>", "WebAssembly hasn't implemented cons regs results", "<STR_LIT>", ")", ";", "if", "(", "Out", ".", "Flags", ".", "isInConsecutiveRegsLast", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "<STR_LIT>", "WebAssembly hasn't implemented cons regs last results", "<STR_LIT>", ")", ";", "}", "return", "Chain", ";", "}" ]

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

[ "}" ]

[ "_", "_", "arm_vqrshrnbq_m_n_s16", "(", "int8x16_t", "_", "_", "a", ",", "int16x8_t", "_", "_", "b", ",", "const", "int", "_", "_", "imm", ",", "mve_pred16_t", "_", "_", "p", ")", "{", "return", "_", "_", "builtin_mve_vqrshrnbq_m_n_sv8hi", "(", "_", "_", "a", ",", "_", "_", "b", ",", "_", "_", "imm", ",", "_", "_", "p", ")", ";" ]

[ "bool", "VLIWResourceModel", "::", "reserveResources", "(", "SUnit", "*", "SU", ")", "{", "bool", "startNewCycle", "=", "false", ";", "if", "(", "!", "SU", ")", "{", "ResourcesModel", "->", "clearResources", "(", ")", ";", "Packet", ".", "clear", "(", ")", ";", "TotalPackets", "++", ";", "return", "false", ";", "}", "if", "(", "!", "isResourceAvailable", "(", "SU", ")", ")", "{", "ResourcesModel", "->", "clearResources", "(", ")", ";", "Packet", ".", "clear", "(", ")", ";", "TotalPackets", "++", ";", "startNewCycle", "=", "true", ";", "}", "switch", "(", "SU", "->", "getInstr", "(", ")", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "ResourcesModel", "->", "reserveResources", "(", "SU", "->", "getInstr", "(", ")", ")", ";", "break", ";", "case", "TargetOpcode", "::", "EXTRACT_SUBREG", ":", "case", "TargetOpcode", "::", "INSERT_SUBREG", ":", "case", "TargetOpcode", "::", "SUBREG_TO_REG", ":", "case", "TargetOpcode", "::", "REG_SEQUENCE", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "PROLOG_LABEL", ":", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "COPY", ":", "case", "TargetOpcode", "::", "INLINEASM", ":", "break", ";", "}", "Packet", ".", "push_back", "(", "SU", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Packet[", "<STR_LIT>", "<<", "TotalPackets", "<<", "<STR_LIT>", "]:\\n", "<STR_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "Packet", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "\\t[", "<STR_LIT>", "<<", "i", "<<", "<STR_LIT>", "] SU(", "<STR_LIT>", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "Packet", "[", "i", "]", "->", "NodeNum", "<<", "<STR_LIT>", ")\\t", "<STR_LIT>", ")", ";", "DEBUG", "(", "Packet", "[", "i", "]", "->", "getInstr", "(", ")", "->", "dump", "(", ")", ")", ";", "}", "if", "(", "Packet", ".", "size", "(", ")", ">=", "SchedModel", "->", "getIssueWidth", "(", ")", ")", "{", "ResourcesModel", "->", "clearResources", "(", ")", ";", "Packet", ".", "clear", "(", ")", ";", "TotalPackets", "++", ";", "startNewCycle", "=", "true", ";", "}", "return", "startNewCycle", ";", "}" ]

[ "Keep", "track", "of", "available", "resources", "." ]

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

[ "&&", "(", "INSN_ADDRESSES", "(", "INSN_UID", "(", "dest", ")", ")", "-", "addr", "+", "(", "unsigned", ")", "<NUM_LIT>", ">", "<NUM_LIT>", "+", "<NUM_LIT>", ")", ")", "{", "<BUGS>", "rtx", "scan", ";", "<BUGE>", "unsigned", "attempt", "=", "<NUM_LIT>", ",", "used", ";" ]

[ "return", "mode_for_vector", "(", "elem_mode", ",", "nunits", ")", ";" ]

[ "}", "machine_mode", "elem_mode", "=", "smallest_mode_for_size", "(", "elem_size", "*", "BITS_PER_UNIT", ",", "MODE_INT", ")", ";", "gcc_assert", "(", "elem_size", "*", "nunits", "==", "vector_size", ")", ";" ]

[ "MachineDominatorTree", ">", "(", ")", ";" ]

[ "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<" ]

[ "==", "Log2_32", "(", "ExtWidth", "/", "<NUM_LIT>", ")", ")", "return", "DiagnosticPredicateTy", "::", "Match", ";" ]

[ "if", "(", "isGPR64", "<", "RegClassID", ">", "(", ")", "&&", "getShiftExtendType", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "getShiftExtendAmount", "(", ")" ]

[ "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "<STR_LIT>", "SI Fix SGPR copies", "<STR_LIT>", ";", "}" ]

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

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

[ "extern", "_", "_", "inline", "_", "_", "m128d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_cvtsi32_sd", "(", "_", "_", "m128d", "_", "_", "A", ",", "int", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m128d", ")", "_", "_", "builtin_ia32_cvtsi2sd", "(", "(", "_", "_", "v2df" ]

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

[ "class", "BaseSIMDTwoSameVectorTied", "<", "bit", "Q", ",", "bit", "U", ",", "bits", "<", "<NUM_LIT>", ">", "size", ",", "bits", "<", "<NUM_LIT>", ">", "opcode", ",", "bits", "<", "<NUM_LIT>", ">", "size2", ",", "RegisterOperand", "regtype", ",", "string", "asm", ",", "string", "dstkind", ",", "string", "srckind", ",", "list", "<", "dag", ">", "pattern", ">", ":", "I", "<", "(", "outs", "regtype", ":", "$", "dst", ")", ",", "(", "ins", "regtype", ":", "$", "Rd", ",", "regtype", ":", "$", "Rn", ")", ",", "asm", ",", "<STR_LIT>", "#", "dstkind", "#", "<STR_LIT>", "#", "srckind", "#", "<STR_LIT>", "#", "dstkind", "#", "<STR_LIT>", ",", "<STR_LIT>", ",", "pattern", ">", ",", "Sched", "<", "[", "!", "if", "(", "Q", ",", "WriteVq", ",", "WriteVd", ")", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Q", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "U", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "size", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "size2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opcode", ";" ]

[ "<FIXS>", "(", "v2f64", "(", "X86VSintToFP", "(", "bc_v4i32", "(", "v2i64", "(", "scalar_to_vector", "(", "loadi64", "addr", ":", "$", "src", ")", ")", ")", ")", ")", ")", ")", "]", ">", ",", "<FIXE>" ]

[ "def", "CVTDQ2PDrm", ":", "S2SI", "<NUM_LIT>", ",", "MRMSrcMem", ",", "(", "outs", "VR128", ":", "$", "dst", ")", ",", "(", "ins", "i64mem", ":", "$", "src", ")", ",", "<STR_LIT>", ",", "[", "(", "set", "VR128", ":", "$", "dst", ",", "<BUGS>", "(", "v2f64", "(", "X86VSintToFP", "(", "loadv4i32", "addr", ":", "$", "src", ")", ")", ")", ")", "]", ">", ",", "<BUGE>", "Sched", "[", "WriteCvtI2PDLd", "]", ">", ";", "def", "CVTDQ2PDrr", ":", "S2SI", "<NUM_LIT>", ",", "MRMSrcReg", ",", "(", "outs", "VR128", ":", "$", "dst", ")", ",", "(", "ins", "VR128", ":", "$", "src", ")", ",", "<STR_LIT>", "," ]

[ "v8u16", ")", "_", "<NUM_LIT>", ",", "(", "v8u16", ")", "_", "<NUM_LIT>", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "_", "m128i", "_", "_", "lsx_vavg_hu", "(", "_", "_", "m128i", "_", "<NUM_LIT>", ",", "_", "_", "m128i", "_", "<NUM_LIT>", ")", "{", "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_lsx_vavg_hu", "(", "(" ]

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

[ "return", "false", ";", "}", "if", "(", "IDVal", "==", "<STR_LIT>", ".frame", "<STR_LIT>", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "<STR_LIT>", ".set", "<STR_LIT>", ")", "{", "return", "parseDirectiveSet", "(", ")", ";", "}", "if", "(", "IDVal", "==", "<STR_LIT>", ".fmask", "<STR_LIT>", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "<STR_LIT>", ".mask", "<STR_LIT>", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "<STR_LIT>", ".nan", "<STR_LIT>", ")", "return", "parseDirectiveNaN", "(", ")", ";", "if", "(", "IDVal", "==", "<STR_LIT>", ".gpword", "<STR_LIT>", ")", "{", "parseDirectiveGpWord", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "<STR_LIT>", ".gpdword", "<STR_LIT>", ")", "{" ]

[ "}" ]

[ "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "PostInc", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "CS", "]", ";", "let", "Constraints", "=", "<STR_LIT>", ";" ]

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

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

[ "<FIXS>", "case", "Match_MissingFeature", ":", "return", "ErrorMissingFeature", "(", "IDLoc", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "<FIXE>" ]

[ "EmitInstruction", "(", "Inst", ",", "Operands", ",", "Out", ")", ";", "Opcode", "=", "Inst", ".", "getOpcode", "(", ")", ";", "return", "false", ";", "<BUGS>", "case", "Match_MissingFeature", ":", "{", "assert", "(", "ErrorInfo", "&&", "<STR_LIT>", "Unknown missing feature!", "<STR_LIT>", ")", ";", "std", "::", "string", "Msg", "=", "<STR_LIT>", "instruction requires:", "<STR_LIT>", ";", "uint64_t", "Mask", "=", "<NUM_LIT>", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "(", "sizeof", "(", "ErrorInfo", ")", "*", "<NUM_LIT>", "-", "<NUM_LIT>", ")", ";", "++", "i", ")", "{", "if", "(", "ErrorInfo", "&", "Mask", ")", "{", "Msg", "+=", "<STR_LIT>", "<STR_LIT>", ";", "Msg", "+=", "getSubtargetFeatureName", "(", "ErrorInfo", "&", "Mask", ")", ";", "}", "Mask", "<<=", "<NUM_LIT>", ";", "}", "return", "Error", "(", "IDLoc", ",", "Msg", ",", "EmptyRanges", ",", "MatchingInlineAsm", ")", ";", "}", "<BUGE>", "case", "Match_InvalidOperand", ":", "WasOriginallyInvalidOperand", "=", "true", ";", "break", ";" ]

[ "<FIXS>", "if", "(", "!", "CPU", ".", "empty", "(", ")", "||", "!", "FS", ".", "empty", "(", ")", ")", "{", "<FIXE>", "<FIXS>", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "sys", "::", "getHostCPUName", "(", ")", ";", "ParseSubtargetFeatures", "(", "FS", ",", "CPUName", ")", ";", "<FIXE>" ]

[ ",", "Is64Bit", "(", "is64Bit", ")", "{", "<BUGS>", "if", "(", "!", "FS", ".", "empty", "(", ")", ")", "{", "<BUGE>", "<BUGS>", "std", "::", "string", "CPU", "=", "sys", "::", "getHostCPUName", "(", ")", ";", "ParseSubtargetFeatures", "(", "FS", ",", "CPU", ")", ";", "<BUGE>", "if", "(", "HasAVX", ")" ]

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

[ "unsigned", "PPCRegisterInfo", "::", "getBaseRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "if", "(", "!", "hasBasePointer", "(", "MF", ")", ")", "return", "getFrameRegister" ]

[ "return", "CurDAG", "-", ">", "getTargetConstant", "(", "N", "-", ">", "getSExtValue", "(", ")", "&", "(", "-", "<NUM_LIT>", "<", "<", "<NUM_LIT>", ")", ",", "MVT", ":", ":", "i32", ")", ";" ]

[ "def", "maskSeven", ":", "SDNodeXForm", "<", "imm", ",", "[", "{", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "N", "-", ">", "getSExtValue", "(", ")", "&", "(", "-", "<NUM_LIT>", "<", "<", "<NUM_LIT>", ")", ",", "MVT", ":", ":", "i32", ")", ";", "}", "]", ">", ";", "def", "maskEight", ":", "SDNodeXForm", "<", "imm", ",", "[", "{", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "N", "-", ">", "getSExtValue", "(", ")", "&", "(", "-", "<NUM_LIT>", "<", "<", "<NUM_LIT>", ")", ",", "MVT", ":", ":", "i32", ")", ";", "}", "]", ">", ";", "def", "maskNine", ":", "SDNodeXForm", "<", "imm", ",", "[", "{" ]

[ "let", "Uses", "=", "!", "if", "(", "has_m0_read", ",", "[", "M0", ",", "EXEC", "]", ",", "[", "EXEC", "]", ")", ";" ]

[ "class", "DS_Pseudo", "<", "string", "opName", ",", "dag", "outs", ",", "dag", "ins", ",", "string", "asmOps", ",", "list", "<", "dag", ">", "pattern", "=", "[", "]", ">", ":", "InstSI", "<", "outs", ",", "ins", ",", "<STR_LIT>", ",", "pattern", ">", ",", "SIMCInstr", "<", "opName", ",", "SIEncodingFamily", ".", "NONE", ">", "{", "let", "SubtargetPredicate", "=", "isGCN", ";", "let", "LGKM_CNT", "=", "<NUM_LIT>", ";", "let", "DS", "=", "<NUM_LIT>", ";", "let", "Size", "=", "<NUM_LIT>", ";", "let", "UseNamedOperandTable", "=", "<NUM_LIT>", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "mayStore", "=", "<NUM_LIT>", ";", "let", "hasSideEffects", "=", "<NUM_LIT>", ";", "let", "SchedRW", "=", "[", "WriteLDS", "]", ";", "let", "isPseudo", "=", "<NUM_LIT>", ";", "let", "isCodeGenOnly", "=", "<NUM_LIT>", ";", "let", "AsmMatchConverter", "=", "<STR_LIT>", ";", "string", "Mnemonic", "=", "opName", ";", "string", "AsmOperands", "=", "asmOps", ";", "bits", "<", "<NUM_LIT>", ">", "has_vdst", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "has_addr", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "has_data0", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "has_data1", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "has_offset", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "has_offset0", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "has_offset1", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "has_gds", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "gdsValue", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "has_m0_read", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "getSTI", "(", ")", ",", "ProgInfo", ".", "NumSGPRsForWavesPerEU", ")", ";", "<FIXE>", "<FIXS>", "getSTI", "(", ")", ",", "ProgInfo", ".", "NumVGPRsForWavesPerEU", ")", ";", "<FIXE>" ]

[ "}", "ProgInfo", ".", "SGPRBlocks", "=", "IsaInfo", "::", "getNumSGPRBlocks", "(", "<BUGS>", "STM", ".", "getFeatureBits", "(", ")", ",", "ProgInfo", ".", "NumSGPRsForWavesPerEU", ")", ";", "<BUGE>", "ProgInfo", ".", "VGPRBlocks", "=", "IsaInfo", "::", "getNumVGPRBlocks", "(", "<BUGS>", "STM", ".", "getFeatureBits", "(", ")", ",", "ProgInfo", ".", "NumVGPRsForWavesPerEU", ")", ";", "<BUGE>" ]

[ "if", "(", "Reg1", "!=", "Reg2", ")", "return", "false", ";" ]

[ "const", "ReduceEntry", "&", "Entry", "=", "Arguments", "->", "Entry", ";", "MachineBasicBlock", "::", "instr_iterator", "&", "NextMII", "=", "Arguments", "->", "NextMII", ";", "const", "MachineBasicBlock", "::", "instr_iterator", "&", "E", "=", "Arguments", "->", "MI", "->", "getParent", "(", ")", "->", "instr_end", "(", ")", ";", "if", "(", "NextMII", "==", "E", ")", "return", "false", ";", "MachineInstr", "*", "MI1", "=", "Arguments", "->", "MI", ";", "MachineInstr", "*", "MI2", "=", "&", "*", "NextMII", ";", "bool", "ReduceToLwp", "=", "(", "MI1", "->", "getOpcode", "(", ")", "==", "Mips", "::", "LW", ")", "||", "(", "MI1", "->", "getOpcode", "(", ")", "==", "Mips", "::", "LW_MM", ")", "||", "(", "MI1", "->", "getOpcode", "(", ")", "==", "Mips", "::", "LW16_MM", ")", ";", "if", "(", "!", "CheckXWPInstr", "(", "MI1", ",", "ReduceToLwp", ",", "Entry", ")", ")", "return", "false", ";", "if", "(", "!", "CheckXWPInstr", "(", "MI2", ",", "ReduceToLwp", ",", "Entry", ")", ")", "return", "false", ";", "Register", "Reg1", "=", "MI1", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "Register", "Reg2", "=", "MI2", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m64", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "m_from_int", "(", "int", "_", "_", "i", ")", "{", "return", "_", "mm_cvtsi32_si64", "(", "_", "_", "i", ")", ";" ]

[ ";" ]

[ "auto", "Liveness", "=", "MBB", "->", "computeRegisterLiveness", "(", "TRI", ",", "AMDGPU", "::", "VCC", ",", "MI", ",", "<NUM_LIT>", ")", ";", "if", "(", "Liveness", "!=", "MachineBasicBlock", "::", "LQR_Dead", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Not shrinking ", "<STR_LIT>", "<<", "MI", "<<", "<STR_LIT>", " due to vcc liveness\\n", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "int", "Op32", "=", "Fold", ".", "ShrinkOpcode", ";", "MachineOperand", "&", "Dst0", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "MachineOperand", "&", "Dst1", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "assert", "(", "Dst0", ".", "isDef", "(", ")", "&&", "Dst1", ".", "isDef", "(", ")", ")", ";", "bool", "HaveNonDbgCarryUse", "=", "!", "MRI", "->", "use_nodbg_empty", "(", "Dst1", ".", "getReg", "(", ")", ")", ";", "const", "TargetRegisterClass", "*", "Dst0RC", "=", "MRI", "->", "getRegClass", "(", "Dst0", ".", "getReg", "(", ")", ")", ";", "Register", "NewReg0", "=", "MRI", "->", "createVirtualRegister", "(", "Dst0RC", ")", ";", "MachineInstr", "*", "Inst32", "=", "TII", "->", "buildShrunkInst", "(", "*", "MI", ",", "Op32", ")", ";", "if", "(", "HaveNonDbgCarryUse", ")", "{", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "COPY", ")", ",", "Dst1", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "AMDGPU", "::", "VCC", ",", "RegState", "::", "Kill", ")", ";", "}", "Dst0", ".", "setReg", "(", "NewReg0", ")", ";", "for", "(", "unsigned", "I", "=", "MI", "->", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ";", "I", ">", "<NUM_LIT>", ";", "--", "I", ")", "MI", "->", "removeOperand", "(", "I", ")", ";", "MI", "->", "setDesc", "(", "TII", "->", "get", "(", "AMDGPU", "::", "IMPLICIT_DEF", ")", ")", ";", "if", "(", "Fold", ".", "Commuted", ")", "TII", "->", "commuteInstruction", "(", "*", "Inst32", ",", "false", ")", ";", "return", "true", ";", "}", "assert", "(", "!", "Fold", ".", "needsShrink", "(", ")", "&&", "<STR_LIT>", "not handled", "<STR_LIT>", ")", ";", "if", "(", "Fold", ".", "isImm", "(", ")", ")", "{", "if", "(", "Old", ".", "isTied", "(", ")", ")", "{", "int", "NewMFMAOpc", "=", "AMDGPU", "::", "getMFMAEarlyClobberOp", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "if", "(", "NewMFMAOpc", "==", "-", "<NUM_LIT>", ")", "return", "false", ";", "MI", "->", "setDesc", "(", "TII", "->", "get", "(", "NewMFMAOpc", ")", ")", ";", "MI", "->", "untieRegOperand", "(", "<NUM_LIT>", ")", ";", "}", "Old", ".", "ChangeToImmediate", "(", "Fold", ".", "ImmToFold", ")", ";", "return", "true", ";", "}", "if", "(", "Fold", ".", "isGlobal", "(", ")", ")", "{", "Old", ".", "ChangeToGA", "(", "Fold", ".", "OpToFold", "->", "getGlobal", "(", ")", ",", "Fold", ".", "OpToFold", "->", "getOffset", "(", ")", ",", "Fold", ".", "OpToFold", "->", "getTargetFlags", "(", ")", ")", ";", "return", "true" ]

[ "<FIXS>", "if", "(", "!", "noImmForm", "&&", "(", "(", "isInt", "<NUM_LIT>", ">", "(", "Offset", ")", "&&", "(", "(", "Offset", "%", "offsetMinAlign", "(", "MI", ")", ")", "==", "<NUM_LIT>", ")", ")", "||", "<FIXE>" ]

[ "assert", "(", "OpC", "!=", "PPC", "::", "DBG_VALUE", "&&", "<STR_LIT>", "This should be handled in a target-independent way", "<STR_LIT>", ")", ";", "<BUGS>", "if", "(", "!", "noImmForm", "&&", "(", "(", "isInt", "<NUM_LIT>", ">", "(", "Offset", ")", "&&", "(", "!", "isIXAddr", "||", "(", "Offset", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", ")", "||", "<BUGE>", "OpC", "==", "TargetOpcode", "::", "STACKMAP", "||", "OpC", "==", "TargetOpcode", "::", "PATCHPOINT", ")", ")", "{", "MI", ".", "getOperand", "(", "OffsetOperandNo", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";" ]

[ "}" ]

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

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m512i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_mask_i32gather_epi32", "(", "_", "_", "m512i", "_", "_", "v1_old", ",", "_", "_", "mmask16", "_", "_", "mask", ",", "_", "_", "m512i", "_", "_", "index", ",", "int", "const", "*", "_", "_", "addr", ",", "int", "_", "_", "scale", ")", "{", "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_gathersiv16si", "(", "(", "_", "_", "v16si", ")", "_", "_", "v1_old", ",", "_", "_", "addr", ",", "(", "_", "_", "v16si", ")", "_", "_", "index", ",", "_", "_", "mask", ",", "_", "_", "scale", ")", ";" ]

[ "}" ]

[ "vfmad_lane_f64", "(", "float64_t", "_", "_", "a", ",", "float64_t", "_", "_", "b", ",", "float64x1_t", "_", "_", "c", ",", "const", "int", "_", "_", "lane", ")", "{", "return", "_", "_", "builtin_fma", "(", "_", "_", "b", ",", "_", "_", "c", "[", "<NUM_LIT>", "]", ",", "_", "_", "a", ")", ";" ]

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

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

[ "OutStreamer", "->", "EmitAssignment", "(", "S", ",", "MCConstantExpr", "::", "create", "(", "int64_t", "(", "<NUM_LIT>", ")", ",", "MMI", "->", "getContext", "(", ")", ")", ")", ";" ]

[ "sgxCallMagicReset", "(", ")", ";", "PrintModuleMacros", "(", "OutStreamer", ".", "get", "(", ")", ")", ";", "const", "Triple", "&", "TT", "=", "TM", ".", "getTargetTriple", "(", ")", ";", "if", "(", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", "OutStreamer", "->", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getTextSection", "(", ")", ")", ";", "if", "(", "TT", ".", "isOSBinFormatCOFF", "(", ")", ")", "{", "if", "(", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", ")", "{", "MCSymbol", "*", "S", "=", "MMI", "->", "getContext", "(", ")", ".", "getOrCreateSymbol", "(", "StringRef", "(", "<STR_LIT>", "@feat.00", "<STR_LIT>", ")", ")", ";", "OutStreamer", "->", "BeginCOFFSymbolDef", "(", "S", ")", ";", "OutStreamer", "->", "EmitCOFFSymbolStorageClass", "(", "COFF", "::", "IMAGE_SYM_CLASS_STATIC", ")", ";", "OutStreamer", "->", "EmitCOFFSymbolType", "(", "COFF", "::", "IMAGE_SYM_DTYPE_NULL", ")", ";", "OutStreamer", "->", "EndCOFFSymbolDef", "(", ")", ";", "OutStreamer", "->", "EmitSymbolAttribute", "(", "S", ",", "MCSA_Global", ")", ";" ]

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

[ "const", "ARM64Subtarget", "*", "getSubtargetImpl", "(", ")" ]

[ "Rm", ",", "dsub", ")", ",", "(", "UImmS1XForm", "$", "idx", ")", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v4i32", "(", "OpNodeLane", "(", "v4i32", "V128", ":", "$", "Rn", ")", ",", "(", "v2i32", "V64", ":", "$", "Rm", ")", ",", "VectorIndexD32b", ":", "$", "idx", ")", ")", ",", "(", "!", "cast", "<", "Instruction", ">", "(", "NAME", "#", "v4i32_indexed", ")", "$", "Rn", ",", "(", "SUBREG_TO_REG", "(", "i32", "<NUM_LIT>", ")", ",", "$" ]

[ "}" ]

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

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<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>", ";" ]

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

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

[ "<FIXS>", "(", "!", "cast", "Instruction", ">", "(", "NAME", ")", "PPR", ":", "$", "gp", ",", "GPR64sp", ":", "$", "base", ",", "ZPR", ":", "$", "offsets", ")", ">", ";", "<FIXE>" ]

[ "def", ":", "InstAlias", "asm", "#", "<STR_LIT>", ",", "(", "!", "cast", "Instruction", ">", "(", "NAME", "#", "_REAL", ")", "ZPR64", ":", "$", "Zt", ",", "PPR3bAny", ":", "$", "Pg", ",", "GPR64sp", ":", "$", "Rn", ",", "ZPR64ExtLSL8", ":", "$", "Zm", ")", ",", "<NUM_LIT>", ">", ";", "def", ":", "Pat", "(", "nxv2i64", "(", "op", "(", "nxv2i1", "PPR", ":", "$", "gp", ")", ",", "GPR64sp", ":", "$", "base", ",", "(", "nxv2i64", "ZPR", ":", "$", "offsets", ")", ",", "vt", ")", ")", ",", "<BUGS>", "(", "!", "cast", "Instruction", ">", "(", "NAME", "#", "_REAL", ")", "PPR", ":", "$", "gp", ",", "GPR64sp", ":", "$", "base", ",", "ZPR", ":", "$", "offsets", ")", ">", ";", "<BUGE>", "}", "class", "sve_mem_64b_gld_vi", "bits", "<NUM_LIT>", ">", "opc", ",", "string", "asm", ",", "Operand", "imm_ty", ">" ]

[ ";" ]

[ "addr_rtx", "=", "(", "XEXP", "(", "mem", ",", "<NUM_LIT>", ")", ")", ";", "if", "(", "GET_CODE", "(", "addr_rtx", ")", "==", "PRE_MODIFY", ")", "addr_rtx", "=", "XEXP", "(", "addr_rtx", ",", "<NUM_LIT>", ")", ";", "*", "offset", "=", "<NUM_LIT>", ";", "while", "(", "GET_CODE", "(", "addr_rtx", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "addr_rtx", ",", "<NUM_LIT>", ")", ")", ")", "{", "*", "offset", "+=", "INTVAL", "(", "XEXP", "(", "addr_rtx", ",", "<NUM_LIT>", ")", ")", ";", "addr_rtx", "=", "XEXP", "(", "addr_rtx", ",", "<NUM_LIT>", ")", ";", "}", "if", "(", "!", "REG_P", "(", "addr_rtx", ")", ")", "return", "false", ";", "*", "base", "=", "addr_rtx" ]

[ "SDValue", "AMDGPUTargetLowering", "::", "lowerFEXP10Unsafe", "(", "SDValue", "X", ",", "const", "SDLoc", "&", "SL", ",", "SelectionDAG", "&", "DAG", ",", "SDNodeFlags", "Flags", ")", "const", "{", "const", "EVT", "VT", "=", "X", ".", "getValueType", "(", ")", ";", "const", "unsigned", "Exp2Op", "=", "VT", "==", "MVT", "::", "f32", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "ISD", "::", "FEXP2", ";", "if", "(", "VT", "!=", "MVT", "::", "f32", "||", "!", "needsDenormHandlingF32", "(", "DAG", ",", "X", ",", "Flags", ")", ")", "{", "SDValue", "K0", "=", "DAG", ".", "getConstantFP", "(", "<NUM_LIT>", "p", "+", "<NUM_LIT>", ",", "SL", ",", "VT", ")", ";", "SDValue", "K1", "=", "DAG", ".", "getConstantFP", "(", "<NUM_LIT>", "p", "-", "<NUM_LIT>", ",", "SL", ",", "VT", ")", ";", "SDValue", "Mul0", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FMUL", ",", "SL", ",", "VT", ",", "X", ",", "K0", ",", "Flags", ")", ";", "SDValue", "Exp2_0", "=", "DAG", ".", "getNode", "(", "Exp2Op", ",", "SL", ",", "VT", ",", "Mul0", ",", "Flags", ")", ";", "SDValue", "Mul1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FMUL", ",", "SL", ",", "VT", ",", "X", ",", "K1", ",", "Flags", ")", ";", "SDValue", "Exp2_1", "=", "DAG", ".", "getNode", "(", "Exp2Op", ",", "SL", ",", "VT", ",", "Mul1", ",", "Flags", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "FMUL", ",", "SL", ",", "VT", ",", "Exp2_0", ",", "Exp2_1", ")", ";", "}", "EVT", "SetCCVT", "=", "getSetCCResultType", "(", "DAG", ".", "getDataLayout", "(", ")", ",", "*", "DAG", ".", "getContext", "(", ")", ",", "VT", ")", ";", "SDValue", "Threshold", "=", "DAG", ".", "getConstantFP", "(", "-", "<NUM_LIT>", "p", "+", "<NUM_LIT>", ",", "SL", ",", "VT", ")", ";", "SDValue", "NeedsScaling", "=", "DAG", ".", "getSetCC", "(", "SL", ",", "SetCCVT", ",", "X", ",", "Threshold", ",", "ISD", "::", "SETOLT", ")", ";", "SDValue", "ScaleOffset", "=", "DAG", ".", "getConstantFP", "(", "<NUM_LIT>", "p", "+", "<NUM_LIT>", ",", "SL", ",", "VT", ")", ";", "SDValue", "ScaledX", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FADD", ",", "SL", ",", "VT", ",", "X", ",", "ScaleOffset", ",", "Flags", ")", ";", "SDValue", "AdjustedX", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SELECT", ",", "SL", ",", "VT", ",", "NeedsScaling", ",", "ScaledX", ",", "X", ")", ";", "SDValue", "K0", "=", "DAG", ".", "getConstantFP", "(", "<NUM_LIT>", "p", "+", "<NUM_LIT>", ",", "SL", ",", "VT", ")", ";", "SDValue", "K1", "=", "DAG", ".", "getConstantFP", "(", "<NUM_LIT>", "p", "-", "<NUM_LIT>", ",", "SL", ",", "VT", ")", ";", "SDValue", "Mul0", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FMUL", ",", "SL", ",", "VT", ",", "AdjustedX", ",", "K0", ",", "Flags", ")", ";", "SDValue", "Exp2_0", "=", "DAG", ".", "getNode", "(", "Exp2Op", ",", "SL", ",", "VT", ",", "Mul0", ",", "Flags", ")", ";", "SDValue", "Mul1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FMUL", ",", "SL", ",", "VT", ",", "AdjustedX", ",", "K1", ",", "Flags", ")", ";", "SDValue", "Exp2_1", "=", "DAG", ".", "getNode", "(", "Exp2Op", ",", "SL", ",", "VT", ",", "Mul1", ",", "Flags", ")", ";", "SDValue", "MulExps", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FMUL", ",", "SL", ",", "VT", ",", "Exp2_0", ",", "Exp2_1", ",", "Flags", ")", ";", "SDValue", "ResultScaleFactor", "=", "DAG", ".", "getConstantFP", "(", "<NUM_LIT>", "p", "-", "<NUM_LIT>", ",", "SL", ",", "VT", ")", ";", "SDValue", "AdjustedResult", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FMUL", ",", "SL", ",", "VT", ",", "MulExps", ",", "ResultScaleFactor", ",", "Flags", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SELECT", ",", "SL", ",", "VT", ",", "NeedsScaling", ",", "AdjustedResult", ",", "MulExps", ",", "Flags", ")", ";", "}" ]

[ "Emit", "approx-funcs", "appropriate", "lowering", "for", "exp10", "." ]

[ "bit", "Src2IsImm", "=", "!", "isa", "<", "Operand", ">", "(", "Src2", ")", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "optype", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "op1", ";", "let", "SrcB", "=", "op2", ";", "let", "SrcC", "=", "op3", ";", "let", "SrcD", "=", "op4", ";", "let", "OperandType", "=", "optype", ";", "let", "Switches", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "hasSrcC", "=", "<NUM_LIT>", ";", "let", "hasSrcD", "=", "<NUM_LIT>", ";", "bit", "Src2IsVRF", "=", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Src2", ")", ",", "<STR_LIT>", ")", ";", "bit", "Src4IsVRF", "=", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Src4", ")", ",", "<STR_LIT>", ")", ";", "let", "isNotUsedInDisasm", "=", "!", "if", "(", "!", "and", "(", "Src2IsVRF", ",", "Src4IsVRF", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "imm6", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "U", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Qd", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "imm6", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Qd", "{" ]

[ "Reserved", ".", "set", "(", "Mips", "::", "S7_64", ")", ";" ]

[ "}", "for", "(", "MCPhysReg", "R", ":", "ReservedGPR64", ")", "Reserved", ".", "set", "(", "R", ")", ";", "if", "(", "!", "Subtarget", ".", "isABICalls", "(", ")", ")", "{", "Reserved", ".", "set", "(", "Mips", "::", "GP", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "GP_64", ")", ";", "}", "if", "(", "Subtarget", ".", "isFP64bit", "(", ")", ")", "{", "for", "(", "MCPhysReg", "Reg", ":", "Mips", "::", "AFGR64RegClass", ")", "Reserved", ".", "set", "(", "Reg", ")", ";", "}", "else", "{", "for", "(", "MCPhysReg", "Reg", ":", "Mips", "::", "FGR64RegClass", ")", "Reserved", ".", "set", "(", "Reg", ")", ";", "}", "if", "(", "Subtarget", ".", "getFrameLowering", "(", ")", "->", "hasFP", "(", "MF", ")", ")", "{", "if", "(", "Subtarget", ".", "inMips16Mode", "(", ")", ")", "Reserved", ".", "set", "(", "Mips", "::", "S0", ")", ";", "else", "{", "Reserved", ".", "set", "(", "Mips", "::", "FP", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "FP_64", ")", ";", "if", "(", "hasStackRealignment", "(", "MF", ")", "&&", "MF", ".", "getFrameInfo", "(", ")", ".", "hasVarSizedObjects", "(", ")", ")", "{", "Reserved", ".", "set", "(", "Mips", "::", "S7", ")", ";" ]

[ ";" ]

[ "break", ";", "case", "ISD", "::", "LOAD", ":", "{", "const", "LoadSDNode", "*", "L", "=", "cast", "<", "LoadSDNode", ">", "(", "N", ")", ";", "unsigned", "AS", "=", "L", "->", "getAddressSpace", "(", ")", ";", "return", "AS", "==", "AMDGPUAS", "::", "PRIVATE_ADDRESS", "||", "AS", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", ";", "}", "break", ";", "case", "ISD", "::", "CALLSEQ_END", ":", "return", "true", ";", "break", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "{", "}", "return", "AMDGPU", "::", "isIntrinsicSourceOfDivergence", "(", "cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "AMDGPU", "::", "isIntrinsicSourceOfDivergence", "(", "cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ")", ";", "}", "return", "false" ]

[ "(", "VLDL2DSXNCirl_v", "(", "LO7", "$", "I", ")", ",", "i64", ":", "$", "sz", ",", "i32", ":", "$", "vl", ",", "v256f64", ":", "$", "pt", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "int_ve_vl_vldl2dsxnc_vssvl", "simm7", ":", "$", "I", ",", "i64", ":", "$", "sz", ",", "v256f64", ":", "$", "pt", ",", "i32", ":", "$", "vl", ")", "," ]

[ "}", ")" ]

[ "mips_expand_vec_unpack", "(", "operands", ",", "false", ",", "true", ")", "DONE" ]

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

[ "if", "(", "(", "GVar", "->", "isConstant", "(", ")", "&&", "UnderlyingGV", "->", "isLocalLinkage", "(", "GV", "->", "getLinkage", "(", ")", ")", ")", "||", "(", "GVar", "->", "hasSection", "(", ")", "&&", "StringRef", "(", "GVar", "->", "getSection", "(", ")", ")", ".", "startswith", "(", "<STR_LIT>", ".cp.", "<STR_LIT>", ")", ")", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i32", ",", "GA", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i32", ",", "GA", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i32" ]

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

[ "def", "SBWriteResGroup4", ":", "SchedWriteRes", "<", "[", "SBPort05", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";" ]

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

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

[ "static", "void", "rs6000_function_arg_advance_1", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ",", "int", "depth", ")", "{", "machine_mode", "elt_mode", ";", "int", "n_elts", ";", "rs6000_discover_homogeneous_aggregate", "(", "mode", ",", "type", ",", "&", "elt_mode", ",", "&", "n_elts", ")", ";", "if", "(", "depth", "==", "<NUM_LIT>", ")", "cum", "->", "nargs_prototype", "--", ";", "if", "(", "TARGET_ELF", "&&", "(", "TARGET_64BIT", "||", "DEFAULT_ABI", "==", "ABI_V4", ")", "&&", "cum", "->", "escapes", ")", "{", "if", "(", "SCALAR_FLOAT_MODE_P", "(", "mode", ")", ")", "{", "rs6000_passes_float", "=", "true", ";", "if", "(", "(", "HAVE_LD_PPC_GNU_ATTR_LONG_DOUBLE", "||", "TARGET_64BIT", ")", "&&", "(", "FLOAT128_IBM_P", "(", "mode", ")", "||", "FLOAT128_IEEE_P", "(", "mode", ")", "||", "(", "type", "!=", "NULL", "&&", "TYPE_MAIN_VARIANT", "(", "type", ")", "==", "long_double_type_node", ")", ")", ")", "rs6000_passes_long_double", "=", "true", ";", "}", "if", "(", "named", "&&", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "mode", ")", ")", "rs6000_passes_vector", "=", "true", ";", "}", "if", "(", "TARGET_ALTIVEC_ABI", "&&", "(", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "elt_mode", ")", "||", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "int_size_in_bytes", "(", "type", ")", "==", "<NUM_LIT>", ")", ")", ")", "{", "bool", "stack", "=", "false", ";", "if", "(", "USE_ALTIVEC_FOR_ARG_P", "(", "cum", ",", "elt_mode", ",", "named", ")", ")", "{", "cum", "->", "vregno", "+=", "n_elts", ";", "if", "(", "!", "targetm", ".", "calls", ".", "split_complex_arg", "&&", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "COMPLEX_TYPE", "&&", "elt_mode", "==", "KCmode", ")", "cum", "->", "vregno", "++", ";", "if", "(", "!", "TARGET_ALTIVEC", ")", "error", "(", "<STR_LIT>", "cannot pass argument in vector register because", "<STR_LIT>", "<STR_LIT>", " altivec instructions are disabled, use %qs", "<STR_LIT>", "<STR_LIT>", " to enable them", "<STR_LIT>", ",", "<STR_LIT>", "-maltivec", "<STR_LIT>", ")", ";", "if", "(", "(", "(", "DEFAULT_ABI", "==", "ABI_AIX", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "&&", "TARGET_64BIT", ")", "||", "(", "cum", "->", "stdarg", "&&", "DEFAULT_ABI", "!=", "ABI_V4", ")", ")", "stack", "=", "true", ";", "}", "else", "stack", "=", "true", ";", "if", "(", "stack", ")", "{", "int", "align", ";", "if", "(", "TARGET_32BIT", ")", "align", "=", "-", "(", "rs6000_parm_offset", "(", ")", "+", "cum", "->", "words", ")", "&", "<NUM_LIT>", ";", "else", "align", "=", "cum", "->", "words", "&", "<NUM_LIT>", ";", "cum", "->", "words", "+=", "align", "+", "rs6000_arg_size", "(", "mode", ",", "type", ")", ";", "if", "(", "TARGET_DEBUG_ARG", ")", "{", "fprintf", "(", "stderr", ",", "<STR_LIT>", "function_adv: words = %2d, align=%d, ", "<STR_LIT>", ",", "cum", "->", "words", ",", "align", ")", ";", "fprintf", "(", "stderr", ",", "<STR_LIT>", "nargs = %4d, proto = %d, mode = %4s\\n", "<STR_LIT>", ",", "cum", "->", "nargs_prototype", ",", "cum", "->", "prototype", ",", "GET_MODE_NAME", "(", "mode", ")", ")", ";", "}", "}", "}", "else", "if", "(", "TARGET_MACHO", "&&", "rs6000_darwin64_struct_check_p", "(", "mode", ",", "type", ")", ")", "{", "int", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "TYPE_ALIGN", "(", "type", ")", ">=", "<NUM_LIT>", "*", "BITS_PER_WORD", "&&", "(", "cum", "->", "words", "%", "<NUM_LIT>", ")", "!=", "<NUM_LIT>", ")", "cum", "->", "words", "++", ";", "if", "(", "!", "named", ")", "cum", "->", "words", "+=", "(", "size", "+", "<NUM_LIT>", ")", "/", "<NUM_LIT>", ";", "else", "{", "cum", "->", "intoffset", "=", "<NUM_LIT>", ";", "cum", "->", "floats_in_gpr", "=", "<NUM_LIT>", ";", "rs6000_darwin64_record_arg_advance_recurse", "(", "cum", ",", "type", ",", "<NUM_LIT>", ")", ";", "rs6000_darwin64_record_arg_advance_flush", "(", "cum", ",", "size", "*", "BITS_PER_UNIT", ",", "<NUM_LIT>", ")", ";", "}", "if", "(", "TARGET_DEBUG_ARG", ")", "{", "fprintf", "(", "stderr", ",", "<STR_LIT>", "function_adv: words = %2d, align=%d, size=%d", "<STR_LIT>", ",", "cum", "->", "words", ",", "TYPE_ALIGN", "(", "type", ")", ",", "size", ")", ";", "fprintf", "(", "stderr", ",", "<STR_LIT>", "nargs = %4d, proto = %d, mode = %4s (darwin64 abi)\\n", "<STR_LIT>", ",", "cum", "->", "nargs_prototype", ",", "cum", "->", "prototype", ",", "GET_MODE_NAME", "(", "mode", ")", ")", ";", "}", "}", "else", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", ")", "{", "if", "(", "abi_v4_pass_in_fpr", "(", "mode", ",", "named", ")", ")", "{", "if", "(", "mode", "==", "TDmode", "&&", "(", "cum", "->", "fregno", "%", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "cum", "->", "fregno", "++", ";", "if", "(", "cum", "->", "fregno", "+", "(", "FLOAT128_2REG_P", "(", "mode", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", "<=", "FP_ARG_V4_MAX_REG", ")", "cum", "->", "fregno", "+=", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "else", "{", "cum", "->", "fregno", "=", "FP_ARG_V4_MAX_REG", "+", "<NUM_LIT>", ";", "if", "(", "mode", "==", "DFmode", "||", "FLOAT128_IBM_P", "(", "mode", ")", "||", "mode", "==", "DDmode", "||", "mode", "==", "TDmode", ")", "cum", "->", "words", "+=", "cum", "->", "words", "&", "<NUM_LIT>", ";", "cum", "->", "words", "+=", "rs6000_arg_size", "(", "mode", ",", "type", ")", ";", "}", "}", "else", "{", "int", "n_words", "=", "rs6000_arg_size", "(", "mode", ",", "type", ")", ";", "int", "gregno", "=", "cum", "->", "sysv_gregno", ";", "if", "(", "n_words", "==", "<NUM_LIT>", ")", "gregno", "+=", "(", "<NUM_LIT>", "-", "gregno", ")", "&", "<NUM_LIT>", ";", "if", "(", "gregno", "+", "n_words", "-", "<NUM_LIT>", ">", "GP_ARG_MAX_REG", ")", "{", "if", "(", "n_words", "==", "<NUM_LIT>", ")", "cum", "->", "words", "+=", "cum", "->", "words", "&", "<NUM_LIT>", ";", "cum", "->", "words", "+=", "n_words", ";", "}", "cum", "->", "sysv_gregno", "=", "gregno", "+", "n_words", ";", "}", "if", "(", "TARGET_DEBUG_ARG", ")", "{", "fprintf", "(", "stderr", ",", "<STR_LIT>", "function_adv: words = %2d, fregno = %2d, ", "<STR_LIT>", ",", "cum", "->", "words", ",", "cum", "->", "fregno", ")", ";", "fprintf", "(", "stderr", ",", "<STR_LIT>", "gregno = %2d, nargs = %4d, proto = %d, ", "<STR_LIT>", ",", "cum", "->", "sysv_gregno", ",", "cum", "->", "nargs_prototype", ",", "cum", "->", "prototype", ")", ";", "fprintf", "(", "stderr", ",", "<STR_LIT>", "mode = %4s, named = %d\\n", "<STR_LIT>", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "named", ")", ";", "}", "}", "else", "{", "int", "n_words", "=", "rs6000_arg_size", "(", "mode", ",", "type", ")", ";", "int", "start_words", "=", "cum", "->", "words", ";", "int", "align_words", "=", "rs6000_parm_start", "(", "mode", ",", "type", ",", "start_words", ")", ";", "cum", "->", "words", "=", "align_words", "+", "n_words", ";", "if", "(", "SCALAR_FLOAT_MODE_P", "(", "elt_mode", ")", "&&", "TARGET_HARD_FLOAT", ")", "{", "if", "(", "elt_mode", "==", "TDmode", "&&", "(", "cum", "->", "fregno", "%", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "cum", "->", "fregno", "++", ";", "cum", "->", "fregno", "+=", "n_elts", "*", "(", "(", "GET_MODE_SIZE", "(", "elt_mode", ")", "+", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ")", ";", "}", "if", "(", "TARGET_DEBUG_ARG", ")", "{", "fprintf", "(", "stderr", ",", "<STR_LIT>", "function_adv: words = %2d, fregno = %2d, ", "<STR_LIT>", ",", "cum", "->", "words", ",", "cum", "->", "fregno", ")", ";", "fprintf", "(", "stderr", ",", "<STR_LIT>", "nargs = %4d, proto = %d, mode = %4s, ", "<STR_LIT>", ",", "cum", "->", "nargs_prototype", ",", "cum", "->", "prototype", ",", "GET_MODE_NAME", "(", "mode", ")", ")", ";", "fprintf", "(", "stderr", ",", "<STR_LIT>", "named = %d, align = %d, depth = %d\\n", "<STR_LIT>", ",", "named", ",", "align_words", "-", "start_words", ",", "depth", ")", ";", "}", "}", "}" ]

[ "Update", "the", "data", "in", "CUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "(", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", ")", "Note", "that", "for", "args", "passed", "by", "reference", ",", "function_arg", "will", "be", "called", "with", "MODE", "and", "TYPE", "set", "to", "that", "of", "the", "pointer", "to", "the", "arg", ",", "not", "the", "arg", "itself", "." ]

[ "return", "AMDGPULowerModuleLDS", "(", "*", "TM", ")", ".", "runOnModule", "(", "M", ")", ";" ]

[ "bool", "runOnModule", "(", "Module", "&", "M", ")", "override", "{", "if", "(", "!", "TM", ")", "{", "auto", "&", "TPC", "=", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "TM", "=", "&", "TPC", ".", "getTM", "<", "AMDGPUTargetMachine", ">", "(", ")", ";", "}" ]

[ "}" ]

[ "MachineBasicBlock", "::", "const_instr_iterator", "II", "=", "MI", ";", "while", "(", "II", "->", "isBundledWithSucc", "(", ")", ")", "{", "++", "II", ";", "getPredicateOperands", "(", "&", "*", "II", ",", "Pred", ")", ";", "}", "return", "true", ";", "}", "if", "(", "!", "MI", "->", "getDesc", "(", ")", ".", "isPredicable", "(", ")", ")", "return", "false", ";", "unsigned", "Pos", "=", "MI", "->", "getDesc", "(", ")", ".", "getNumDefs", "(", ")", ";", "Pred", ".", "push_back", "(", "MI", "->", "getOperand", "(", "Pos", ")", ")", ";", "Pred", ".", "push_back", "(", "MI", "->", "getOperand", "(", "Pos", "+", "<NUM_LIT>", ")", ")", ";", "return", "true", ";" ]

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

[ "(", "define_cpu_unit" ]

[ "if", "(", "SDValue", "V", "=", "lowerVectorShuffleAsLanePermuteAndPermute", "(", "DL", ",", "MVT", "::", "v32i8", ",", "V1", ",", "V2", ",", "Mask", ",", "DAG", ",", "Subtarget", ")", ")", "return", "V", ";" ]

[ "if", "(", "SDValue", "Shift", "=", "lowerVectorShuffleAsShift", "(", "DL", ",", "MVT", "::", "v32i8", ",", "V1", ",", "V2", ",", "Mask", ",", "Zeroable", ",", "Subtarget", ",", "DAG", ")", ")", "return", "Shift", ";", "if", "(", "SDValue", "Rotate", "=", "lowerVectorShuffleAsByteRotate", "(", "DL", ",", "MVT", "::", "v32i8", ",", "V1", ",", "V2", ",", "Mask", ",", "Subtarget", ",", "DAG", ")", ")", "return", "Rotate", ";", "if", "(", "SDValue", "V", "=", "lowerShuffleAsRepeatedMaskAndLanePermute", "(", "DL", ",", "MVT", "::", "v32i8", ",", "V1", ",", "V2", ",", "Mask", ",", "Subtarget", ",", "DAG", ")", ")", "return", "V", ";", "if", "(", "V2", ".", "isUndef", "(", ")", "&&", "is128BitLaneCrossingShuffleMask", "(", "MVT", "::", "v32i8", ",", "Mask", ")", ")", "{", "if", "(", "SDValue", "V", "=", "lowerVectorShuffleAsLanePermuteAndPermute", "(", "DL", ",", "MVT", "::", "v32i8", ",", "V1", ",", "V2", ",", "Mask", ",", "DAG", ",", "Subtarget", ")", ")", "return", "V", ";", "return", "lowerVectorShuffleAsLanePermuteAndBlend", "(", "DL", ",", "MVT", "::", "v32i8", ",", "V1", ",", "V2", ",", "Mask", ",", "DAG", ",", "Subtarget", ")", ";", "}", "if", "(", "SDValue", "PSHUFB", "=", "lowerVectorShuffleWithPSHUFB", "(", "DL", ",", "MVT", "::", "v32i8", ",", "Mask", ",", "V1", ",", "V2", ",", "Zeroable", ",", "Subtarget", ",", "DAG", ")", ")", "return", "PSHUFB", ";", "if", "(", "Subtarget", ".", "hasVBMI", "(", ")", "&&", "Subtarget", ".", "hasVLX", "(", ")", ")", "return", "lowerVectorShuffleWithPERMV", "(", "DL", ",", "MVT", "::", "v32i8", ",", "Mask", ",", "V1", ",", "V2", ",", "DAG", ")", ";", "if", "(", "SDValue", "Result", "=", "lowerVectorShuffleByMerging128BitLanes", "(", "DL", ",", "MVT", "::", "v32i8", ",", "V1", ",", "V2", ",", "Mask", ",", "Subtarget", ",", "DAG", ")", ")", "return", "Result", ";" ]

[ "LPCC", "::", "CondCode", "CC", "=", "IntCondCCodeToICC", "(", "Cond", ",", "DL", ",", "RHS", ",", "DAG", ")", ";" ]

[ "SDValue", "LanaiTargetLowering", "::", "LowerSELECT_CC", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "LHS", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "RHS", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "TrueV", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "FalseV", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Cond", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDLoc", "DL", "(", "Op", ")", ";" ]

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

[ "class", "SpuInstConvertIntGen3", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "string", "asmstr", ",", "bit", "hasImm", ">", ":", "SpuInstConvertIntGen2", "<", "opc", ",", "asmstr", ",", "hasImm", ">", "{", "let", "isNotUsedInDisasm", "=", "!", "if", "(", "hasImm", ",", "<NUM_LIT>" ]

[ "<FIXS>", "const", "AMDGPU", "::", "IsaVersion", "ISA", ",", "<FIXE>", "<FIXS>", "unsigned", "(", "*", "encode", ")", "(", "const", "IsaVersion", "&", "Version", ",", "unsigned", ",", "unsigned", ")", ",", "unsigned", "(", "*", "decode", ")", "(", "const", "IsaVersion", "&", "Version", ",", "unsigned", ")", ")", "<FIXE>" ]

[ "static", "boolencodeCnt", "(", "<BUGS>", "const", "AMDGPU", "::", "IsaInfo", "::", "IsaVersion", "ISA", ",", "<BUGE>", "int64_t", "&", "IntVal", ",", "int64_t", "CntVal", ",", "bool", "Saturate", ",", "<BUGS>", "unsigned", "(", "*", "encode", ")", "(", "const", "IsaInfo", "::", "IsaVersion", "&", "Version", ",", "unsigned", ",", "unsigned", ")", ",", "unsigned", "(", "*", "decode", ")", "(", "const", "IsaInfo", "::", "IsaVersion", "&", "Version", ",", "unsigned", ")", ")", "<BUGE>", "{", "bool", "Failed", "=", "false", ";" ]

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

[ "def", "NEONvmullu", ":", "SDNode", "<" ]

[ "<FIXS>", "machine_mode", "mode", ")", "<FIXE>" ]

[ "rtxfunction_value", "(", "const_tree", "valtype", ",", "const_tree", "func", "ATTRIBUTE_UNUSED", ",", "<BUGS>", "enum", "machine_mode", "mode", ")", "<BUGE>", "{", "unsigned", "int", "regnum", ",", "dummy", "ATTRIBUTE_UNUSED", ";", "enum", "mode_class", "mclass", ";" ]

[ ")", "_", "<NUM_LIT>", ",", "(", "v8i16", ")", "_", "<NUM_LIT>", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "_", "m128i", "_", "_", "lsx_vhaddw_w_h", "(", "_", "_", "m128i", "_", "<NUM_LIT>", ",", "_", "_", "m128i", "_", "<NUM_LIT>", ")", "{", "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_lsx_vhaddw_w_h", "(", "(", "v8i16" ]

[ "break", ";" ]

[ "x", "=", "XEXP", "(", "XEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "value", "=", "INTVAL", "(", "x", ")", ";", "else", "{", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "==", "REG", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", ", %s", "<STR_LIT>", ",", "reg_names", "[", "REGNO", "(", "x", ")", "]", ")", ";", "return", ";", "}", "break", ";", "case", "POST_INC", ":", "value", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", ";", "break", ";", "case", "POST_DEC", ":", "value", "=", "-", "(", "HOST_WIDE_INT", ")", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", ";", "break", ";", "}", "fprintf", "(", "file", ",", "<STR_LIT>", ", ", "<STR_LIT>", "HOST_WIDE_INT_PRINT_DEC", ",", "value", ")", ";", "return", ";", "}", "case", "'", "Q", "'", ":", "if", "(", "MEM_VOLATILE_P", "(", "x", ")", ")", "fputs", "(", "<STR_LIT>", ".rel", "<STR_LIT>", ",", "file", ")", ";", "return", ";", "case", "'", "S", "'", ":", "fprintf", "(", "file", ",", "<STR_LIT>", "%d", "<STR_LIT>", ",", "exact_log2", "(", "INTVAL", "(", "x", ")", ")", ")", ";", "return", ";", "case", "'", "T", "'", ":", "if", "(", "!", "TARGET_GNU_AS", "&&", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "{", "fprintf", "(", "file", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "(", "int", ")", "INTVAL", "(", "x", ")", "&", "<NUM_LIT>", ")", ";", "return", ";", "}", "break", ";", "case", "'", "U", "'", ":", "if", "(", "!", "TARGET_GNU_AS", "&&", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "{", "const", "char", "*", "prefix", "=", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ";", "if", "(", "INTVAL", "(", "x", ")", "&", "<NUM_LIT>", ")", "{", "fprintf", "(", "file", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ")", ";", "prefix", "=", "<STR_LIT>", "<STR_LIT>", ";", "}", "fprintf", "(", "file", ",", "<STR_LIT>", "%s%x", "<STR_LIT>", ",", "prefix", ",", "(", "int", ")", "INTVAL", "(", "x", ")", "&", "<NUM_LIT>", ")", ";", "return", ";", "}", "break", ";", "case", "'", "X", "'", ":", "{", "unsigned", "int", "regno", "=", "REGNO", "(", "x", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "%s, %s", "<STR_LIT>", ",", "reg_names", "[", "regno", "]", ",", "reg_names", "[", "regno", "+", "<NUM_LIT>", "]", ")", ";", "}", "return", ";", "case", "'", "r", "'", ":", "if", "(", "GET_CODE", "(", "x", ")", "==", "REG", ")", "fputs", "(", "reg_names", "[", "REGNO", "(", "x", ")", "]", ",", "file", ")", ";", "else", "if", "(", "x", "==", "CONST0_RTX", "(", "GET_MODE", "(", "x", ")", ")", ")", "fputs", "(", "<STR_LIT>", "r0", "<STR_LIT>", ",", "file", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "output_addr_const", "(", "file", ",", "x", ")", ";", "else", "output_operand_lossage", "(", "<STR_LIT>", "invalid %%r value", "<STR_LIT>", ")", ";", "return", ";", "case", "'", "v", "'", ":", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "==", "CONST_VECTOR", ")", ";", "x", "=", "simplify_subreg", "(", "DImode", ",", "x", ",", "GET_MODE", "(", "x", ")", ",", "<NUM_LIT>", ")", ";", "break", ";", "case", "'", "+", "'", ":", "{", "const", "char", "*", "which", ";", "x", "=", "find_reg_note", "(", "current_output_insn", ",", "REG_BR_PROB", ",", "<NUM_LIT>", ")", ";", "if", "(", "x", ")", "{", "int", "pred_val", "=", "INTVAL", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ";", "if", "(", "pred_val", "<", "REG_BR_PROB_BASE", "/", "<NUM_LIT>", ")", "which", "=", "<STR_LIT>", ".spnt", "<STR_LIT>", ";", "else", "if", "(", "pred_val", "<", "REG_BR_PROB_BASE", "/", "<NUM_LIT>", ")", "which", "=", "<STR_LIT>", ".dpnt", "<STR_LIT>", ";", "else", "if", "(", "pred_val", "<", "REG_BR_PROB_BASE", "/", "<NUM_LIT>", "*", "<NUM_LIT>", ")", "which", "=", "<STR_LIT>", ".dptk", "<STR_LIT>", ";", "else", "which", "=", "<STR_LIT>", ".sptk", "<STR_LIT>", ";", "}", "else", "if", "(", "GET_CODE", "(", "current_output_insn", ")", "==", "CALL_INSN", ")", "which", "=", "<STR_LIT>", ".sptk", "<STR_LIT>", ";", "else", "which", "=", "<STR_LIT>", ".dptk", "<STR_LIT>", ";", "fputs", "(", "which", ",", "file", ")", ";", "return", ";", "}", "case", "'", ",", "'", ":", "x", "=", "current_insn_predicate", ";", "if", "(", "x", ")", "{", "unsigned", "int", "regno", "=", "REGNO", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "EQ", ")", "regno", "+=", "<NUM_LIT>", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "(%s) ", "<STR_LIT>", ",", "reg_names", "[", "regno", "]", ")", ";", "}", "return", ";", "default", ":", "output_operand_lossage", "(", "<STR_LIT>", "ia64_print_operand: unknown code", "<STR_LIT>", ")", ";", "return", ";", "}", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "POST_INC", ":", "case", "POST_DEC", ":", "case", "POST_MODIFY", ":", "x", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "case", "REG", ":", "fputs", "(", "reg_names", "[", "REGNO", "(", "x", ")", "]", ",", "file", ")", ";", "break", ";", "case", "MEM", ":", "{", "rtx", "addr", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_RTX_CLASS", "(", "GET_CODE", "(", "addr", ")", ")", "==", "RTX_AUTOINC", ")", "addr", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "[%s]", "<STR_LIT>", ",", "reg_names", "[", "REGNO", "(", "addr", ")", "]", ")", ";", "break", ";", "}", "default", ":", "output_addr_const", "(", "file", ",", "x", ")", ";" ]

[ "Error", "(", "ValueLoc", ",", "<STR_LIT>", "invalid value name ", "<STR_LIT>", "+", "ValueName", ")", ";" ]

[ "if", "(", "!", "skipToken", "(", "AsmToken", "::", "Identifier", ",", "<STR_LIT>", "expected a value name", "<STR_LIT>", ")", "||", "!", "skipToken", "(", "AsmToken", "::", "RParen", ",", "<STR_LIT>", "expected a right parenthesis", "<STR_LIT>", ")", ")", "return", "false", ";", "unsigned", "Shift", ";", "if", "(", "FieldName", "==", "<STR_LIT>", "instid0", "<STR_LIT>", ")", "{", "Shift", "=", "<NUM_LIT>", ";", "}", "else", "if", "(", "FieldName", "==", "<STR_LIT>", "instskip", "<STR_LIT>", ")", "{", "Shift", "=", "<NUM_LIT>", ";", "}", "else", "if", "(", "FieldName", "==", "<STR_LIT>", "instid1", "<STR_LIT>", ")", "{", "Shift", "=", "<NUM_LIT>", ";", "}", "else", "{", "Error", "(", "FieldLoc", ",", "<STR_LIT>", "invalid field name ", "<STR_LIT>", "+", "FieldName", ")", ";", "return", "false", ";", "}", "int", "Value", ";", "if", "(", "Shift", "==", "<NUM_LIT>", ")", "{", "Value", "=", "StringSwitch", "<", "int", ">", "(", "ValueName", ")", ".", "Case", "(", "<STR_LIT>", "SAME", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "NEXT", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "SKIP_1", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "SKIP_2", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "SKIP_3", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "SKIP_4", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Default", "(", "-", "<NUM_LIT>", ")", ";", "}", "else", "{", "Value", "=", "StringSwitch", "<", "int", ">", "(", "ValueName", ")", ".", "Case", "(", "<STR_LIT>", "NO_DEP", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "VALU_DEP_1", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "VALU_DEP_2", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "VALU_DEP_3", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "VALU_DEP_4", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "TRANS32_DEP_1", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "TRANS32_DEP_2", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "TRANS32_DEP_3", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "FMA_ACCUM_CYCLE_1", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "SALU_CYCLE_1", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "SALU_CYCLE_2", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "SALU_CYCLE_3", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Default", "(", "-", "<NUM_LIT>", ")", ";", "}", "if", "(", "Value", "<", "<NUM_LIT>", ")", "{" ]

[ "else", "if", "(", "TT", ".", "isOSIAMCU", "(", ")", ")", "Ret", "+=", "<STR_LIT>", "-i64:32-f64:32", "<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", ".", "isX32", "(", ")", "||", "TT", ".", "isOSNaCl", "(", ")", ")", "Ret", "+=", "<STR_LIT>", "-p:32:32", "<STR_LIT>", ";", "Ret", "+=", "<STR_LIT>", "-p270:32:32-p271:32:32-p272:64:64", "<STR_LIT>", ";", "if", "(", "TT", ".", "isArch64Bit", "(", ")", "||", "TT", ".", "isOSWindows", "(", ")", "||", "TT", ".", "isOSNaCl", "(", ")", ")", "Ret", "+=", "<STR_LIT>", "-i64:64", "<STR_LIT>", ";" ]

[ "void", "ARMOperand", "::", "dump", "(", "raw_ostream", "&", "OS", ")", "const", "{", "switch", "(", "Kind", ")", "{", "case", "CondCode", ":", "OS", "<<", "<STR_LIT>", "<ARMCC::", "<STR_LIT>", "<<", "ARMCondCodeToString", "(", "getCondCode", "(", ")", ")", "<<", "<STR_LIT>", ">", "<STR_LIT>", ";", "break", ";", "case", "CCOut", ":", "OS", "<<", "<STR_LIT>", "<ccout ", "<STR_LIT>", "<<", "getReg", "(", ")", "<<", "<STR_LIT>", ">", "<STR_LIT>", ";", "break", ";", "case", "CoprocNum", ":", "OS", "<<", "<STR_LIT>", "<coprocessor number: ", "<STR_LIT>", "<<", "getCoproc", "(", ")", "<<", "<STR_LIT>", ">", "<STR_LIT>", ";", "break", ";", "case", "CoprocReg", ":", "OS", "<<", "<STR_LIT>", "<coprocessor register: ", "<STR_LIT>", "<<", "getCoproc", "(", ")", "<<", "<STR_LIT>", ">", "<STR_LIT>", ";", "break", ";", "case", "MSRMask", ":", "OS", "<<", "<STR_LIT>", "<mask: ", "<STR_LIT>", "<<", "getMSRMask", "(", ")", "<<", "<STR_LIT>", ">", "<STR_LIT>", ";", "break", ";", "case", "Immediate", ":", "getImm", "(", ")", "->", "print", "(", "OS", ")", ";", "break", ";", "case", "MemBarrierOpt", ":", "OS", "<<", "<STR_LIT>", "<ARM_MB::", "<STR_LIT>", "<<", "MemBOptToString", "(", "getMemBarrierOpt", "(", ")", ")", "<<", "<STR_LIT>", ">", "<STR_LIT>", ";", "break", ";", "case", "Memory", ":", "OS", "<<", "<STR_LIT>", "<memory ", "<STR_LIT>", "<<", "<STR_LIT>", "base:", "<STR_LIT>", "<<", "getMemBaseRegNum", "(", ")", ";", "if", "(", "getMemOffsetIsReg", "(", ")", ")", "{", "OS", "<<", "<STR_LIT>", " offset:<register ", "<STR_LIT>", "<<", "getMemOffsetRegNum", "(", ")", ";", "if", "(", "getMemOffsetRegShifted", "(", ")", ")", "{", "OS", "<<", "<STR_LIT>", " offset-shift-type:", "<STR_LIT>", "<<", "getMemShiftType", "(", ")", ";", "OS", "<<", "<STR_LIT>", " offset-shift-amount:", "<STR_LIT>", "<<", "*", "getMemShiftAmount", "(", ")", ";", "}", "}", "else", "{", "OS", "<<", "<STR_LIT>", " offset:", "<STR_LIT>", "<<", "*", "getMemOffset", "(", ")", ";", "}", "if", "(", "getMemOffsetIsReg", "(", ")", ")", "OS", "<<", "<STR_LIT>", " (offset-is-reg)", "<STR_LIT>", ";", "if", "(", "getMemPreindexed", "(", ")", ")", "OS", "<<", "<STR_LIT>", " (pre-indexed)", "<STR_LIT>", ";", "if", "(", "getMemPostindexed", "(", ")", ")", "OS", "<<", "<STR_LIT>", " (post-indexed)", "<STR_LIT>", ";", "if", "(", "getMemNegative", "(", ")", ")", "OS", "<<", "<STR_LIT>", " (negative)", "<STR_LIT>", ";", "if", "(", "getMemWriteback", "(", ")", ")", "OS", "<<", "<STR_LIT>", " (writeback)", "<STR_LIT>", ";", "OS", "<<", "<STR_LIT>", ">", "<STR_LIT>", ";", "break", ";", "case", "ProcIFlags", ":", "{", "OS", "<<", "<STR_LIT>", "<ARM_PROC::", "<STR_LIT>", ";", "unsigned", "IFlags", "=", "getProcIFlags", "(", ")", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", ">=", "<NUM_LIT>", ";", "--", "i", ")", "if", "(", "IFlags", "&", "(", "<NUM_LIT>", "<<", "i", ")", ")", "OS", "<<", "<STR_LIT>", "::", "<STR_LIT>", "(", "<NUM_LIT>", "<<", "i", ")", ";", "OS", "<<", "<STR_LIT>", ">", "<STR_LIT>", ";", "break", ";", "}", "case", "Register", ":", "OS", "<<", "<STR_LIT>", "<register ", "<STR_LIT>", "<<", "getReg", "(", ")", "<<", "<STR_LIT>", ">", "<STR_LIT>", ";", "break", ";", "case", "Shifter", ":", "OS", "<<", "<STR_LIT>", "<shifter ", "<STR_LIT>", "<<", "getShiftOpcStr", "(", "Shift", ".", "ShiftTy", ")", "<<", "<STR_LIT>", ">", "<STR_LIT>", ";", "break", ";", "case", "RegisterList", ":", "case", "DPRRegisterList", ":", "case", "SPRRegisterList", ":", "{", "OS", "<<", "<STR_LIT>", "<register_list ", "<STR_LIT>", ";", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "RegList", "=", "getRegList", "(", ")", ";", "for", "(", "SmallVectorImpl", "<", "unsigned", ">", "::", "const_iterator", "I", "=", "RegList", ".", "begin", "(", ")", ",", "E", "=", "RegList", ".", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "OS", "<<", "*", "I", ";", "if", "(", "++", "I", "<", "E", ")", "OS", "<<", "<STR_LIT>", ", ", "<STR_LIT>", ";", "}", "OS", "<<", "<STR_LIT>", ">", "<STR_LIT>", ";", "break", ";", "}", "case", "Token", ":", "OS", "<<", "<STR_LIT>", "'", "<STR_LIT>", "<<", "getToken", "(", ")", "<<", "<STR_LIT>", "'", "<STR_LIT>", ";", "break", ";", "}", "}" ]

[ "Dump", "the", "plan", "to", "stderr", "(", "for", "debugging", ")", "." ]

[ ";" ]

[ "let", "Namespace", "=", "<STR_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "Opcode", "=", "opcod", ";", "Format", "Form", "=", "f", ";", "bits", "<", "<NUM_LIT>", ">", "FormBits", "=", "Form", ".", "Value", ";", "ImmType", "ImmT", "=", "i", ";", "dag", "OutOperandList", "=", "outs", ";", "dag", "InOperandList", "=", "ins", ";", "string", "AsmString", "=", "AsmStr", ";", "let", "isCodeGenOnly", "=", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "f", ")", ",", "<STR_LIT>", ")", ";", "let", "Itinerary", "=", "itin", ";", "bit", "ForceDisassemble", "=", "<NUM_LIT>", ";", "OperandSize", "OpSize", "=", "OpSizeFixed", ";", "bits", "<", "<NUM_LIT>", ">", "OpSizeBits", "=", "OpSize", ".", "Value", ";", "bit", "hasAdSizePrefix", "=", "<NUM_LIT>", ";", "Prefix", "OpPrefix", "=", "NoPrfx", ";", "bits", "<", "<NUM_LIT>", ">", "OpPrefixBits", "=", "OpPrefix", ".", "Value", ";", "Map", "OpMap", "=", "OB", ";", "bits", "<", "<NUM_LIT>", ">", "OpMapBits", "=", "OpMap", ".", "Value", ";", "bit", "hasREX_WPrefix", "=", "<NUM_LIT>", ";", "FPFormat", "FPForm", "=", "NotFP", ";", "bit", "hasLockPrefix", "=", "<NUM_LIT>", ";", "Domain", "ExeDomain", "=", "d", ";", "bit", "hasREPPrefix", "=", "<NUM_LIT>", ";", "Encoding", "OpEnc", "=", "EncNormal", ";", "bits", "<", "<NUM_LIT>", ">", "OpEncBits", "=", "OpEnc", ".", "Value", ";", "bit", "hasVEX_WPrefix", "=", "<NUM_LIT>", ";", "bit", "hasVEX_4V", "=", "<NUM_LIT>", ";", "bit", "hasVEX_4VOp3", "=", "<NUM_LIT>", ";", "bit", "hasVEX_i8ImmReg", "=", "<NUM_LIT>", ";", "bit", "hasVEX_L", "=", "<NUM_LIT>", ";", "bit", "ignoresVEX_L", "=", "<NUM_LIT>", ";", "bit", "hasEVEX_K", "=", "<NUM_LIT>", ";", "bit", "hasEVEX_Z", "=", "<NUM_LIT>", ";", "bit", "hasEVEX_L2", "=", "<NUM_LIT>", ";", "bit", "hasEVEX_B", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "CD8_Form", "=", "<NUM_LIT>", ";", "int", "CD8_EltSize", "=", "<NUM_LIT>", ";", "bit", "has3DNow0F0FOpcode", "=", "<NUM_LIT>", ";", "bit", "hasMemOp4Prefix", "=", "<NUM_LIT>", ";", "bit", "hasEVEX_RC", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "EVEX_LL", ";", "let", "EVEX_LL", "{", "<NUM_LIT>", "}", "=", "hasVEX_L", ";", "let", "EVEX_LL", "{", "<NUM_LIT>", "}", "=", "hasEVEX_L2", ";", "bits", "<", "<NUM_LIT>", ">", "VectSize", "=", "!", "shl", "(", "<NUM_LIT>", ",", "EVEX_LL", ")", ";", "bits", "<", "<NUM_LIT>", ">", "CD8_Scale", "=", "!", "if", "(", "!", "eq", "(", "OpEnc", ".", "Value", ",", "EncEVEX", ".", "Value", ")", ",", "!", "if", "(", "CD8_Form", "{", "<NUM_LIT>", "}", ",", "!", "shl", "(", "CD8_EltSize", ",", "CD8_Form", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ")", ",", "!", "if", "(", "hasEVEX_B", ",", "CD8_EltSize", ",", "!", "srl", "(", "VectSize", ",", "CD8_Form", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ")", ")", ")", ",", "<NUM_LIT>", ")", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "FormBits", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "OpSizeBits", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "hasAdSizePrefix", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "OpPrefixBits", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "OpMapBits", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "hasREX_WPrefix", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "ImmT", ".", "Value", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "FPForm", ".", "Value", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "hasLockPrefix", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "hasREPPrefix", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "ExeDomain", ".", "Value", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "OpEncBits", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Opcode", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "hasVEX_WPrefix", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "hasVEX_4V", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "hasVEX_4VOp3", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "hasVEX_i8ImmReg", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "hasVEX_L", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "ignoresVEX_L", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "hasEVEX_K", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "hasEVEX_Z", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "hasEVEX_L2", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "hasEVEX_B", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "CD8_Scale", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "has3DNow0F0FOpcode", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "hasMemOp4Prefix" ]

[ "<STR_LIT>" ]

[ "(", "unspec", ":", "V8HI", "[", "(", "match_operand", ":", "V8SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_VCVTPS2PH", ")", ")", "]", "<STR_LIT>" ]

[ "unsigned", "Align", "=", "GV", "->", "getAlignment", "(", ")", "?", "GV", "->", "getAlignment", "(", ")", ":", "DL", ".", "getPreferredAlignment", "(", "GV", ")", ";" ]

[ "ValidateGV", "(", "GV", ")", ";", "MCSymbolXCOFF", "*", "GVSym", "=", "cast", "<", "MCSymbolXCOFF", ">", "(", "getSymbol", "(", "GV", ")", ")", ";", "GVSym", "->", "setStorageClass", "(", "TargetLoweringObjectFileXCOFF", "::", "getStorageClassForGlobal", "(", "GV", ")", ")", ";", "SectionKind", "GVKind", ";", "MCSectionXCOFF", "*", "Csect", "=", "cast", "<", "MCSectionXCOFF", ">", "(", "GV", "->", "isDeclaration", "(", ")", "?", "getObjFileLowering", "(", ")", ".", "getSectionForExternalReference", "(", "GV", ",", "TM", ")", ":", "getObjFileLowering", "(", ")", ".", "SectionForGlobal", "(", "GV", ",", "GVKind", "=", "getObjFileLowering", "(", ")", ".", "getKindForGlobal", "(", "GV", ",", "TM", ")", ",", "TM", ")", ")", ";", "GVSym", "->", "setContainingCsect", "(", "Csect", ")", ";", "if", "(", "GV", "->", "isDeclaration", "(", ")", ")", "return", ";", "if", "(", "(", "!", "GVKind", ".", "isGlobalWriteableData", "(", ")", "&&", "!", "GVKind", ".", "isReadOnly", "(", ")", ")", "||", "GVKind", ".", "isMergeable2ByteCString", "(", ")", "||", "GVKind", ".", "isMergeable4ByteCString", "(", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "Encountered a global variable kind that is ", "<STR_LIT>", "<STR_LIT>", "not supported yet.", "<STR_LIT>", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "Csect", ")", ";", "const", "DataLayout", "&", "DL", "=", "GV", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "if", "(", "GVKind", ".", "isCommon", "(", ")", "||", "GVKind", ".", "isBSSLocal", "(", ")", ")", "{" ]

[ "}" ]

[ "ExternalVarDecls", ".", "push_back", "(", "I", ")", ";", "continue", ";", "}", "if", "(", "I", "->", "hasExternalLinkage", "(", ")", "||", "I", "->", "hasCommonLinkage", "(", ")", ")", "{", "ExternalVarDefs", ".", "push_back", "(", "I", ")", ";", "}", "if", "(", "!", "I", "->", "hasAvailableExternallyLinkage", "(", ")", ")", "{", "const", "MCSection", "*", "S", "=", "getObjFileLowering", "(", ")", ".", "SectionForGlobal", "(", "I", ",", "Mang", ",", "TM", ")", ";", "I", "->", "setSection", "(", "(", "(", "const", "PIC16Section", "*", ")", "S", ")", "->", "getName", "(", ")", ")", ";", "}", "}", "DbgInfo", ".", "BeginModule", "(", "M", ")", ";", "EmitFunctionDecls", "(", "M", ")", ";", "EmitUndefinedVars", "(", "M", ")", ";", "EmitDefinedVars", "(", "M", ")", ";", "EmitIData", "(", "M", ")", ";", "EmitUData", "(", "M", ")", ";", "EmitRomData", "(", "M", ")", ";", "EmitSharedUdata", "(", "M", ")", ";", "EmitUserSections", "(", "M", ")", ";", "return", "Result", ";" ]

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

[ "CCState", "CCByValInfo", "(", "CallConv", ",", "isVarArg", ",", "MF", ",", "ByValArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCByValInfo", ".", "AllocateStack", "(", "CCInfo", ".", "getNextStackOffset", "(", ")", ",", "PtrByteSize", ")", ";", "CCByValInfo", ".", "AnalyzeCallOperands", "(", "Outs", ",", "CC_PPC32_SVR4_ByVal", ")", ";", "unsigned", "NumBytes", "=", "CCByValInfo", ".", "getNextStackOffset", "(", ")", ";", "int", "SPDiff", "=", "CalculateTailCallSPDiff", "(", "DAG", ",", "isTailCall", ",", "NumBytes", ")", ";", "Chain", "=", "DAG", ".", "getCALLSEQ_START", "(", "Chain", ",", "NumBytes", ",", "<NUM_LIT>", ",", "dl", ")", ";", "SDValue", "CallSeqStart", "=", "Chain", ";", "SDValue", "LROp", ",", "FPOp", ";", "Chain", "=", "EmitTailCallLoadFPAndRetAddr", "(", "DAG", ",", "SPDiff", ",", "Chain", ",", "LROp", ",", "FPOp", ",", "dl", ")", ";", "SDValue", "StackPtr", "=", "DAG", ".", "getRegister", "(", "PPC", "::", "R1", ",", "MVT", "::", "i32", ")", ";", "SmallVector", "<", "std", "::", "pair", "<", "unsigned", ",", "SDValue", ">", ",", "<NUM_LIT>", ">", "RegsToPass", ";", "SmallVector", "<", "TailCallArgumentInfo", ",", "<NUM_LIT>", ">", "TailCallArguments", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "MemOpChains", ";", "bool", "seenFloatArg", "=", "false", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "j", "=", "<NUM_LIT>", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "SDValue", "Arg", "=", "OutVals", "[", "i", "]", ";", "ISD", "::", "ArgFlagsTy", "Flags", "=", "Outs", "[", "i", "]", ".", "Flags", ";", "if", "(", "Flags", ".", "isByVal", "(", ")", ")", "{", "assert", "(", "(", "j", "<", "ByValArgLocs", ".", "size", "(", ")", ")", "&&", "<STR_LIT>", "Index out of bounds!", "<STR_LIT>", ")", ";", "CCValAssign", "&", "ByValVA", "=", "ByValArgLocs", "[", "j", "++", "]", ";", "assert", "(", "(", "VA", ".", "getValNo", "(", ")", "==", "ByValVA", ".", "getValNo", "(", ")", ")", "&&", "<STR_LIT>", "ValNo mismatch!", "<STR_LIT>", ")", ";", "unsigned", "LocMemOffset", "=", "ByValVA", ".", "getLocMemOffset", "(", ")", ";", "SDValue", "PtrOff", "=", "DAG", ".", "getIntPtrConstant", "(", "LocMemOffset", ",", "dl", ")", ";", "PtrOff", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "getPointerTy", "(", "MF", ".", "getDataLayout", "(", ")", ")", ",", "StackPtr", ",", "PtrOff", ")", ";", "SDValue", "MemcpyCall", "=", "CreateCopyOfByValArgument", "(", "Arg", ",", "PtrOff", ",", "CallSeqStart", ".", "getNode", "(", ")", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Flags", ",", "DAG", ",", "dl", ")", ";", "SDValue", "NewCallSeqStart", "=", "DAG", ".", "getCALLSEQ_START", "(", "MemcpyCall", ",", "NumBytes", ",", "<NUM_LIT>", ",", "SDLoc", "(", "MemcpyCall", ")", ")", ";", "DAG", ".", "ReplaceAllUsesWith", "(", "CallSeqStart", ".", "getNode", "(", ")", ",", "NewCallSeqStart", ".", "getNode", "(", ")", ")", ";", "Chain", "=", "CallSeqStart", "=", "NewCallSeqStart", ";", "Arg", "=", "PtrOff", ";", "}", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "if", "(", "Arg", ".", "getValueType", "(", ")", "==", "MVT", "::", "i1", ")", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "MVT", "::", "i32" ]

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

[ "static", "int", "getMemScale", "(", "const", "MachineInstr", "&", "MI", ")", "{", "return", "getMemScale", "(", "MI", "." ]

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

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

[ "}" ]

[ "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "base_regno", ")", ";", "if", "(", "update_base_reg_p", ")", "{", "*", "update_base_reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "return", "gen_unaligned_load_update_base_w", "(", "*", "update_base_reg", ",", "reg", ",", "base_addr", ")", ";", "}", "else", "return", "gen_unaligned_load_w", "(", "reg", ",", "gen_rtx_MEM", "(", "SImode", ",", "base_addr", ")", ")", ";", "}", "if", "(", "update_base_reg_p", ")", "{", "result", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "count", "+", "<NUM_LIT>", ")", ")", ";", "start_idx", "=", "<NUM_LIT>", ";", "}", "else", "{", "result", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "count", ")", ")", ";", "start_idx", "=", "<NUM_LIT>", ";", "}", "if", "(", "update_base_reg_p", ")", "{", "offset", "=", "count", "*", "<NUM_LIT>", ";", "new", "_", "addr", "=", "plus_constant", "(", "Pmode", ",", "base_addr", ",", "offset", ")", ";", "*", "update_base_reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "XVECEXP", "(", "result", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "=", "gen_rtx_SET", "(", "*", "update_base_reg", ",", "new", "_", "addr", ")", ";", "}", "for", "(", "par_index", "=", "<NUM_LIT>", ";", "par_index", "<", "count", ";", "par_index", "++", ")", "{", "offset", "=", "par_index", "*", "<NUM_LIT>", ";", "new", "_", "addr", "=", "plus_constant", "(", "Pmode", ",", "base_addr", ",", "offset", ")", ";", "mem", "=", "adjust_automodify_address_nv", "(", "basemem", ",", "SImode", ",", "new", "_", "addr", ",", "offset", ")", ";", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "base_regno", "+", "par_index", ")", ";", "XVECEXP", "(", "result", ",", "<NUM_LIT>", ",", "(", "par_index", "+", "start_idx", ")", ")", "=", "gen_rtx_SET", "(", "reg", ",", "mem", ")", ";", "}", "return", "result", ";" ]

[ "(", "lshiftrt", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]" ]

[ "<STR_LIT>", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "ior", ":", "DI", "(", "zero_extend", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "ashift", ":", "DI", "(", "zero_extend", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")" ]

[ "static", "void", "emit_frame_store_1", "(", "rtx", "value", ",", "rtx", "base_reg", ",", "HOST_WIDE_INT", "frame_bias", ",", "HOST_WIDE_INT", "base_ofs", ",", "rtx", "frame_reg", ")", "{", "rtx", "addr", ",", "mem", ";", "rtx_insn", "*", "insn", ";", "addr", "=", "plus_constant", "(", "Pmode", ",", "base_reg", ",", "base_ofs", ")", ";", "mem", "=", "gen_frame_mem", "(", "DImode", ",", "addr", ")", ";", "insn", "=", "emit_move_insn", "(", "mem", ",", "value", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "if", "(", "frame_bias", "||", "value", "!=", "frame_reg", ")", "{", "if", "(", "frame_bias", ")", "{", "addr", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "frame_bias", "+", "base_ofs", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "DImode", ",", "addr", ")", ";", "}", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "mem", ",", "frame_reg", ")", ")", ";", "}", "}" ]

[ "Generates", "a", "store", "with", "the", "proper", "unwind", "info", "attached", ".", "VALUE", "is", "stored", "at", "BASE_REG+BASE_OFS", ".", "If", "FRAME_BIAS", "is", "nonzero", ",", "then", "BASE_REG", "contains", "SP+FRAME_BIAS", ",", "and", "that", "is", "the", "unwind", "info", "that", "should", "be", "generated", ".", "If", "FRAME_REG", "!", "=", "VALUE", ",", "then", "VALUE", "is", "being", "stored", "on", "behalf", "of", "FRAME_REG", ",", "and", "FRAME_REG", "should", "be", "present", "in", "the", "unwind", "." ]

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

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

[ "return", "AsmPrinter", "::", "runOnMachineFunction", "(", "F", ")", ";" ]

[ "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "override", "{", "AArch64FI", "=", "F", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "STI", "=", "static_cast", "<", "const", "AArch64Subtarget", "*", ">", "(", "&", "F", ".", "getSubtarget", "(", ")", ")", ";" ]

[ ";" ]

[ "bool", "HexagonFrameLowering", "::", "expandLoadInt", "(", "MachineBasicBlock", "&", "B", ",", "MachineBasicBlock", "::", "iterator", "It", ",", "MachineRegisterInfo", "&", "MRI", ",", "const", "HexagonInstrInfo", "&", "HII", ",", "SmallVectorImpl", "<", "Register", ">", "&", "NewRegs", ")", "const", "{", "MachineInstr", "*", "MI", "=", "&", "*", "It", ";", "if", "(", "!", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isFI", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "Register", "DstR", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "int", "FI", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ";", "Register", "TmpR", "=", "MRI", ".", "createVirtualRegister", "(", "&", "Hexagon", "::", "IntRegsRegClass", ")", ";", "BuildMI", "(", "B", ",", "It", ",", "DL", ",", "HII", ".", "get", "(", "Hexagon", "::", "L2_loadri_io", ")", ",", "TmpR", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "cloneMemRefs", "(", "*", "MI", ")", ";", "unsigned", "TfrOpc", "=", "(", "Opc", "==", "Hexagon", "::", "LDriw_pred", ")", "?", "Hexagon", "::", "C2_tfrrp", ":", "Hexagon", "::", "A2_tfrrcr", ";", "BuildMI", "(", "B", ",", "It", ",", "DL", ",", "HII", ".", "get", "(", "TfrOpc", ")", ",", "DstR", ")", ".", "addReg", "(", "TmpR", ",", "RegState", "::", "Kill", ")", ";", "NewRegs", ".", "push_back", "(", "TmpR", ")", ";", "B", ".", "erase", "(", "It", ")", ";", "return", "true" ]

[ ",", "_", "_", "hint", ")", ";" ]

[ "_", "_", "builtin_ia32_scatterpfqps", "(", "_", "_", "mask", ",", "(", "_", "_", "v8di", ")", "_", "_", "index", ",", "_", "_", "addr", ",", "_", "_", "scale" ]

[ "<FIXS>", "void", "HexagonInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "<FIXE>" ]

[ "}", "}", "<BUGS>", "void", "HexagonInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "<BUGE>", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "I", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";" ]

[ "<FIXS>", "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<FIXE>", "<FIXS>", "[", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "<FIXE>", "<FIXS>", "(", "clobber", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]", "<FIXE>" ]

[ "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "<BUGS>", "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<BUGS>", "[", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "<BUGE>", "(", "mult", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "clobber", "(", "match_dup", "<NUM_LIT>", ")", ")", "<BUGS>", "(", "clobber", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]", "<BUGE>", "<STR_LIT>", ")" ]

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

[ "class", "PrefetchLiteral", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "bit", "V", ",", "string", "asm", ",", "list", "<", "dag", ">", "pat", ">", ":", "I", "<", "(", "outs", ")", ",", "(", "ins", "prfop", ":", "$", "Rt", ",", "am_ldrlit", ":", "$", "label", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "pat", ">", ",", "Sched", "<", "[", "WriteLD", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rt", ";", "bits", "<", "<NUM_LIT>", ">", "label", ";" ]

[ "void", "rs6000_expand_vector_extract", "(", "rtx", "target", ",", "rtx", "vec", ",", "rtx", "elt", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "vec", ")", ";", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "rtx", "mem", ";", "if", "(", "VECTOR_MEM_VSX_P", "(", "mode", ")", "&&", "CONST_INT_P", "(", "elt", ")", ")", "{", "switch", "(", "mode", ")", "{", "default", ":", "break", ";", "case", "E_V1TImode", ":", "gcc_assert", "(", "INTVAL", "(", "elt", ")", "==", "<NUM_LIT>", "&&", "inner_mode", "==", "TImode", ")", ";", "emit_move_insn", "(", "target", ",", "gen_lowpart", "(", "TImode", ",", "vec", ")", ")", ";", "break", ";", "case", "E_V2DFmode", ":", "emit_insn", "(", "gen_vsx_extract_v2df", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "E_V2DImode", ":", "emit_insn", "(", "gen_vsx_extract_v2di", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "E_V4SFmode", ":", "emit_insn", "(", "gen_vsx_extract_v4sf", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "E_V16QImode", ":", "if", "(", "TARGET_DIRECT_MOVE_64BIT", ")", "{", "emit_insn", "(", "gen_vsx_extract_v16qi", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "}", "else", "break", ";", "case", "E_V8HImode", ":", "if", "(", "TARGET_DIRECT_MOVE_64BIT", ")", "{", "emit_insn", "(", "gen_vsx_extract_v8hi", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "}", "else", "break", ";", "case", "E_V4SImode", ":", "if", "(", "TARGET_DIRECT_MOVE_64BIT", ")", "{", "emit_insn", "(", "gen_vsx_extract_v4si", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "}", "break", ";", "}", "}", "else", "if", "(", "VECTOR_MEM_VSX_P", "(", "mode", ")", "&&", "!", "CONST_INT_P", "(", "elt", ")", "&&", "TARGET_DIRECT_MOVE_64BIT", ")", "{", "if", "(", "GET_MODE", "(", "elt", ")", "!=", "DImode", ")", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "convert_move", "(", "tmp", ",", "elt", ",", "<NUM_LIT>", ")", ";", "elt", "=", "tmp", ";", "}", "else", "if", "(", "!", "REG_P", "(", "elt", ")", ")", "elt", "=", "force_reg", "(", "DImode", ",", "elt", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_V2DFmode", ":", "emit_insn", "(", "gen_vsx_extract_v2df_var", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "E_V2DImode", ":", "emit_insn", "(", "gen_vsx_extract_v2di_var", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "E_V4SFmode", ":", "emit_insn", "(", "gen_vsx_extract_v4sf_var", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "E_V4SImode", ":", "emit_insn", "(", "gen_vsx_extract_v4si_var", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "E_V8HImode", ":", "emit_insn", "(", "gen_vsx_extract_v8hi_var", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "E_V16QImode", ":", "emit_insn", "(", "gen_vsx_extract_v16qi_var", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "gcc_assert", "(", "CONST_INT_P", "(", "elt", ")", ")", ";", "mem", "=", "assign_stack_temp", "(", "mode", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "emit_move_insn", "(", "mem", ",", "vec", ")", ";", "mem", "=", "adjust_address_nv", "(", "mem", ",", "inner_mode", ",", "INTVAL", "(", "elt", ")", "*", "GET_MODE_SIZE", "(", "inner_mode", ")", ")", ";", "emit_move_insn", "(", "target", ",", "adjust_address_nv", "(", "mem", ",", "inner_mode", ",", "<NUM_LIT>", ")", ")", ";", "}" ]

[ "Extract", "field", "ELT", "from", "VEC", "into", "TARGET", "." ]

[ "VReg_32", ">", ";" ]

[ "def", "DS_DEC_U32", ":", "DS_1A1D_NORET", "<", "<NUM_LIT>", ",", "<STR_LIT>", "," ]

[ "}" ]

[ "size_t", "HexagonAbsoluteStub", "::", "size", "(", ")", "const", "{", "return", "m_Size", ";" ]

[ "if", "(", "Opc", "==", "ISD", "::", "BITCAST", ")", "return", "isFoldableUseOfShuffle", "(", "U", ")", ";" ]

[ "for", "(", "auto", "*", "U", ":", "N", "->", "uses", "(", ")", ")", "{", "unsigned", "Opc", "=", "U", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "U", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", "==", "N", ")", "return", "false", ";", "if", "(", "Opc", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "U", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", "==", "N", ")", "return", "false", ";", "if", "(", "isTargetShuffle", "(", "Opc", ")", ")", "return", "true", ";" ]

[ "$", "Rn", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "f32", "(", "int_aarch64_neon_frecpx", "(", "f32", "FPR32", ":", "$", "Rn", ")", ")", ")", ",", "(", "FRECPXv1i32", "FPR32", ":" ]

[ "unsigned", "Register", "=", "AArch64MCRegisterClasses", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", ".", "getRegister", "(", "RegNo", ")", ";" ]

[ "static", "DecodeStatus", "DecodeZPR4RegisterClass", "(", "MCInst", "&", "Inst", ",", "unsigned", "RegNo", ",", "uint64_t", "Address", ",", "const", "void", "*", "Decoder", ")", "{", "if", "(", "RegNo", ">", "<NUM_LIT>", ")", "return", "Fail", ";" ]

[ "if", "(", "IsNested", ")", "return", "Primary", "?", "X86", "::", "EDX", ":", "X86", "::", "EAX", ";" ]

[ "}", "bool", "IsNested", "=", "HasNestArgument", "(", "&", "MF", ")", ";", "if", "(", "CallingConvention", "==", "CallingConv", "::", "X86_FastCall", "||", "CallingConvention", "==", "CallingConv", "::", "Fast", ")", "{", "if", "(", "IsNested", ")", "report_fatal_error", "(", "<STR_LIT>", "Segmented stacks does not support fastcall with ", "<STR_LIT>", "<STR_LIT>", "nested function.", "<STR_LIT>", ")", ";", "return", "Primary", "?", "X86", "::", "EAX", ":", "X86", "::", "ECX", ";", "}" ]