Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

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

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

[ "MCInst", "HexagonInstrInfo", "::", "getNop", "(", ")", "const", "{", "static", "const", "MCInst", "Nop", "=", "MCInstBuilder", "(", "Hexagon", "::", "A2_nop", ")", ";", "return", "MCInstBuilder", "(", "Hexagon", "::", "BUNDLE", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addInst", "(", "&", "Nop", ")", ";", "}" ]

[ "Return", "the", "noop", "instruction", "to", "use", "for", "a", "noop", "." ]

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

[ "return", "(", "int8x16_t", ")", "_", "_", "builtin_neon_vreinterpretv16qiv16qi", "(", "(", "int8x16_t", ")", "_" ]

[ ")" ]

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

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

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

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

[ "case", "TargetOpcode", "::", "KILL", ":", "NumBytes", "=", "<NUM_LIT>", ";", "break", ";", "case", "TargetOpcode", "::", "STACKMAP", ":", "NumBytes", "=", "StackMapOpers", "(", "&", "MI", ")", ".", "getNumPatchBytes", "(", ")", ";", "assert", "(", "NumBytes", "%", "<NUM_LIT>", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Invalid number of NOP bytes requested!", "<STR_LIT>", ")", ";", "break", ";", "case", "TargetOpcode", "::", "PATCHPOINT", ":", "NumBytes", "=", "PatchPointOpers", "(", "&", "MI", ")", ".", "getNumPatchBytes", "(", ")", ";", "assert", "(", "NumBytes", "%", "<NUM_LIT>", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Invalid number of NOP bytes requested!", "<STR_LIT>", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":" ]

[ "<FIXS>", "ARM_FUSE_NOTHING", ",", "-", "<NUM_LIT>", "<FIXE>" ]

[ "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ",", "<BUGS>", "ARM_FUSE_NOTHING", "<BUGE>", "}", ";", "const", "struct", "tune_params", "arm_cortex_a8_tune", "=" ]

[ "<STR_LIT>" ]

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

[ "<STR_LIT>", ":" ]

[ "SrcReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "Register", "(", ")", ";", "CmpMask", "=", "~", "<NUM_LIT>", ";", "CmpValue", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "case", "<STR_LIT>", "::" ]

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

[ "return", "CheckImmRange", "(", "<NUM_LIT>", "+", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "false", ",", "true" ]

[ "bool", "is31", "=", "needsFP", "(", "*", "MF", ")", ";" ]

[ "++", "NumPEReloadVSR", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "MFVSRD", ")", ",", "VSRContainingGPRs", "[", "Dst", "]", ".", "first", ")", ".", "addReg", "(", "TRI", "->", "getSubReg", "(", "Dst", ",", "PPC", "::", "sub_64", ")", ",", "getKillRegState", "(", "true", ")", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "<STR_LIT>", "More than two GPRs spilled to a VSR!", "<STR_LIT>", ")", ";", "}", "Restored", ".", "set", "(", "Dst", ")", ";", "}", "else", "{", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "if", "(", "Subtarget", ".", "needsSwapsForVSXMemOps", "(", ")", "&&", "!", "MF", "->", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "NoUnwind", ")", ")", "TII", ".", "loadRegFromStackSlotNoUpd", "(", "MBB", ",", "I", ",", "Reg", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "else", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "I", ",", "Reg", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "assert", "(", "I", "!=", "MBB", ".", "begin", "(", ")", "&&", "<STR_LIT>", "loadRegFromStackSlot didn't insert any code!", "<STR_LIT>", ")", ";", "}", "}", "if", "(", "AtStart", ")", "I", "=", "MBB", ".", "begin", "(", ")", ";", "else", "{", "I", "=", "BeforeI", ";", "++", "I", ";", "}", "}", "if", "(", "CR2Spilled", "||", "CR3Spilled", "||", "CR4Spilled", ")", "{", "assert", "(", "Subtarget", ".", "is32BitELFABI", "(", ")", "&&", "<STR_LIT>", "Only set CR[2|3|4]Spilled on 32-bit SVR4.", "<STR_LIT>", ")", ";" ]

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

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

[ ")", ";" ]

[ "HOST_WIDE_INT", "off_val_1", ",", "off_val_3", ",", "base_off", ",", "new", "_", "off_1", ",", "new", "_", "off_3", ",", "stp_off_upper_limit", ",", "stp_off_lower_limit", ",", "msize", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "temp_operands", "[", "i", "]", "=", "operands", "[", "i", "]", ";", "qsort", "(", "temp_operands", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "*", "sizeof", "(", "rtx", "*", ")", ",", "aarch64_ldrstr_offset_compare", ")", ";", "if", "(", "load", ")", "{", "mem_1", "=", "temp_operands", "[", "<NUM_LIT>", "]", ";", "mem_2", "=", "temp_operands", "[", "<NUM_LIT>", "]", ";", "mem_3", "=", "temp_operands", "[", "<NUM_LIT>", "]", ";", "mem_4", "=", "temp_operands", "[", "<NUM_LIT>", "]", ";", "}", "else", "{", "mem_1", "=", "temp_operands", "[", "<NUM_LIT>", "]", ";", "mem_2", "=", "temp_operands", "[", "<NUM_LIT>", "]", ";", "mem_3", "=", "temp_operands", "[", "<NUM_LIT>", "]", ";", "mem_4", "=", "temp_operands", "[", "<NUM_LIT>", "]", ";", "gcc_assert", "(", "code", "==", "UNKNOWN", ")", ";", "}", "extract_base_offset_in_addr", "(", "mem_1", ",", "&", "base", ",", "&", "offset_1", ")", ";", "extract_base_offset_in_addr", "(", "mem_3", ",", "&", "base", ",", "&", "offset_3", ")", ";", "gcc_assert", "(", "base", "!=", "NULL_RTX", "&&", "offset_1", "!=", "NULL_RTX", "&&", "offset_3", "!=", "NULL_RTX", ")", ";", "msize", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "stp_off_upper_limit", "=", "msize", "*", "(", "<NUM_LIT>", "-", "<NUM_LIT>", ")", ";", "stp_off_lower_limit", "=", "-", "msize", "*", "<NUM_LIT>", ";", "off_val_1", "=", "INTVAL", "(", "offset_1", ")", ";", "off_val_3", "=", "INTVAL", "(", "offset_3", ")", ";", "if", "(", "msize", "<=", "<NUM_LIT>", ")", "base_off", "=", "(", "off_val_1", "+", "off_val_3", ")", "/", "<NUM_LIT>", ";", "else", "base_off", "=", "off_val_1", ";", "if", "(", "base_off", "%", "msize", "!=", "off_val_1", "%", "msize", ")", "base_off", "+=", "(", "(", "(", "base_off", "%", "msize", ")", "-", "(", "off_val_1", "%", "msize", ")", ")", "+", "msize", ")", "%", "msize", ";", "else", "if", "(", "msize", "<=", "<NUM_LIT>", ")", "base_off", "+=", "msize", ";", "if", "(", "base_off", ">=", "<NUM_LIT>", ")", "{", "base_off", "=", "<NUM_LIT>", "-", "<NUM_LIT>", ";", "base_off", "-=", "(", "(", "(", "base_off", "%", "msize", ")", "-", "(", "off_val_1", "%", "msize", ")", ")", "+", "msize", ")", "%", "msize", ";", "}", "if", "(", "base_off", "<=", "-", "<NUM_LIT>", ")", "{", "base_off", "=", "-", "<NUM_LIT>", "+", "<NUM_LIT>", ";", "base_off", "+=", "(", "(", "(", "base_off", "%", "msize", ")", "-", "(", "off_val_1", "%", "msize", ")", ")", "+", "msize", ")", "%", "msize", ";", "}", "new", "_", "off_1", "=", "off_val_1", "-", "base_off", ";", "new", "_", "off_3", "=", "off_val_3", "-", "base_off", ";", "if", "(", "new", "_", "off_1", ">", "stp_off_upper_limit", "||", "new", "_", "off_1", "<", "stp_off_lower_limit", "||", "new", "_", "off_3", ">", "stp_off_upper_limit", "||", "new", "_", "off_3", "<", "stp_off_lower_limit", ")", "return", "false", ";", "replace_equiv_address_nv", "(", "mem_1", ",", "plus_constant", "(", "Pmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "new", "_", "off_1", ")", ",", "true", ")", ";", "replace_equiv_address_nv", "(", "mem_2", ",", "plus_constant", "(", "Pmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "new", "_", "off_1", "+", "msize", ")", ",", "true", ")", ";", "replace_equiv_address_nv", "(", "mem_3", ",", "plus_constant", "(", "Pmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "new", "_", "off_3", ")", ",", "true", ")", ";", "replace_equiv_address_nv", "(", "mem_4", ",", "plus_constant", "(", "Pmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "new", "_", "off_3", "+", "msize", ")", ",", "true", ")", ";", "if", "(", "!", "aarch64_mem_pair_operand", "(", "mem_1", ",", "mode", ")", "||", "!", "aarch64_mem_pair_operand", "(", "mem_3", ",", "mode", ")", ")", "return", "false", ";", "if", "(", "code", "==", "ZERO_EXTEND", ")", "{", "mem_1", "=", "gen_rtx_ZERO_EXTEND", "(", "DImode", ",", "mem_1", ")", ";", "mem_2", "=", "gen_rtx_ZERO_EXTEND", "(", "DImode", ",", "mem_2", ")", ";", "mem_3", "=", "gen_rtx_ZERO_EXTEND", "(", "DImode", ",", "mem_3", ")", ";", "mem_4", "=", "gen_rtx_ZERO_EXTEND", "(", "DImode", ",", "mem_4", ")", ";", "}", "else", "if", "(", "code", "==", "SIGN_EXTEND", ")", "{", "mem_1", "=", "gen_rtx_SIGN_EXTEND", "(", "DImode", ",", "mem_1", ")", ";", "mem_2", "=", "gen_rtx_SIGN_EXTEND", "(", "DImode", ",", "mem_2", ")", ";", "mem_3", "=", "gen_rtx_SIGN_EXTEND", "(", "DImode", ",", "mem_3" ]

[ "imm", ",", "(", "_", "_", "v8sf", ")", "_", "mm256_setzero_ps", "(", ")", ",", "(", "_", "_", "mmask8", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "return", "(", "_", "_", "m256", ")", "_", "_", "builtin_ia32_shuf_f32x4_256_mask", "(", "(", "_", "_", "v8sf", ")", "_", "_", "A", ",", "(", "_", "_", "v8sf", ")", "_", "_", "B", ",", "_", "_" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "return", "<STR_LIT>", "\t", "\t", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "<STR_LIT>", "<STR_LIT>", "}", "<FIXE>" ]

[ "(", "clobber", "(", "reg", ":", "SI", "R0_REG", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "R1_REG", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_expand", "<STR_LIT>" ]

[ ")" ]

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

[ "}" ]

[ "assert", "(", "Opc", "&&", "<STR_LIT>", "Register class not handled!", "<STR_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "Offset", ")", ".", "addMemOperand", "(", "MMO", ")", ";" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m512h", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_maskz_rsqrt_ph", "(", "_", "_", "mmask32", "_", "_", "A", ",", "_", "_", "m512h", "_", "_", "B", ")", "{", "return", "_", "_", "builtin_ia32_rsqrtph512_mask", "(", "_", "_", "B", ",", "_", "mm512_setzero_ph", "(", ")", ",", "_", "_", "A", ")", ";" ]

[ ">", ";" ]

[ "def", ":", "Neon_Scalar3Same_cmp_V1_D_size_patterns", "<", "SETGE", ",", "FCMGEddd" ]

[ "dslots_number_nops", "=", "num_nops", ";" ]

[ "const", "char", "*", "iq2000_fill_delay_slot", "(", "const", "char", "*", "ret", ",", "enum", "delay_type", "type", ",", "rtx", "operands", "[", "]", ",", "rtx_insn", "*", "cur_insn", ")", "{", "rtx", "set_reg", ";", "machine_mode", "mode", ";", "rtx_insn", "*", "next_insn", "=", "cur_insn", "?", "NEXT_INSN", "(", "cur_insn", ")", ":", "NULL", ";", "int", "num_nops", ";", "if", "(", "type", "==", "DELAY_LOAD", "||", "type", "==", "DELAY_FCMP", ")", "num_nops", "=", "<NUM_LIT>", ";", "else", "num_nops", "=", "<NUM_LIT>", ";", "next_insn", "=", "NEXT_INSN", "(", "cur_insn", ")", ";", "while", "(", "next_insn", "!=", "<NUM_LIT>", "&&", "(", "NOTE_P", "(", "next_insn", ")", "||", "LABEL_P", "(", "next_insn", ")", ")", ")", "next_insn", "=", "NEXT_INSN", "(", "next_insn", ")", ";", "dslots_load_total", "+=", "num_nops", ";", "if", "(", "TARGET_DEBUG_C_MODE", "||", "type", "==", "DELAY_NONE", "||", "operands", "==", "<NUM_LIT>", "||", "cur_insn", "==", "<NUM_LIT>", "||", "next_insn", "==", "<NUM_LIT>", "||", "LABEL_P", "(", "next_insn", ")", "||", "(", "set_reg", "=", "operands", "[", "<NUM_LIT>", "]", ")", "==", "<NUM_LIT>", ")", "{", "dslots_number_nops", "=", "<NUM_LIT>", ";", "iq2000_load_reg", "=", "<NUM_LIT>", ";", "iq2000_load_reg2", "=", "<NUM_LIT>", ";", "iq2000_load_reg3", "=", "<NUM_LIT>", ";", "iq2000_load_reg4", "=", "<NUM_LIT>", ";", "return", "ret", ";", "}", "set_reg", "=", "operands", "[", "<NUM_LIT>", "]", ";", "if", "(", "set_reg", "==", "<NUM_LIT>", ")", "return", "ret", ";", "while", "(", "GET_CODE", "(", "set_reg", ")", "==", "SUBREG", ")", "set_reg", "=", "SUBREG_REG", "(", "set_reg", ")", ";", "mode", "=", "GET_MODE", "(", "set_reg", ")", ";" ]

[ "<STR_LIT>", ")" ]

[ "(", "mult", ":", "SF", "(", "neg", ":", "SF", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "SF", "\t", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>" ]

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

[ "if", "(", "mode", "==", "DImode", "||", "mode", "==", "DFmode", ")", "{", "if", "(", "code", "==", "CONST_INT", ")", "{", "HOST_WIDE_INT", "val", "=", "INTVAL", "(", "index", ")", ";", "if", "(", "TARGET_LDRD", ")", "return", "IN_RANGE", "(", "val", ",", "-", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "&&", "(", "val", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ";", "else", "return", "IN_RANGE", "(", "val", ",", "-", "<NUM_LIT>", ",", "<NUM_LIT>", "-", "<NUM_LIT>", ")", ";", "}", "else", "return", "<NUM_LIT>", ";", "}", "if", "(", "code", "==", "MULT", ")", "{", "rtx", "xiop0", "=", "XEXP", "(", "index", ",", "<NUM_LIT>", ")", ";", "rtx", "xiop1", "=", "XEXP", "(", "index", ",", "<NUM_LIT>", ")", ";", "return", "(", "(", "arm_address_register_rtx_p", "(", "xiop0", ",", "strict_p", ")", "&&", "thumb2_index_mul_operand", "(", "xiop1", ")", ")", "||", "(", "arm_address_register_rtx_p", "(", "xiop1", ",", "strict_p", ")", "&&", "thumb2_index_mul_operand", "(", "xiop0", ")", ")", ")", ";", "}", "else", "if", "(", "code", "==", "ASHIFT", ")", "{", "rtx", "op", "=", "XEXP", "(", "index", ",", "<NUM_LIT>", ")", ";", "return", "(", "arm_address_register_rtx_p", "(", "XEXP", "(", "index", ",", "<NUM_LIT>", ")", ",", "strict_p", ")", "&&", "CONST_INT_P", "(", "op", ")", "&&", "INTVAL", "(", "op", ")", ">", "<NUM_LIT>", "&&", "INTVAL", "(", "op", ")", "<=", "<NUM_LIT>", ")", ";", "}", "return", "(", "code", "==", "CONST_INT", "&&", "INTVAL", "(", "index", ")", "<", "<NUM_LIT>", "&&", "INTVAL", "(", "index", ")", ">", "-" ]

[ ":" ]

[ "case", "ELF", "::", "R_MICROMIPS_HI16", ":", "case", "ELF", "::", "R_MIPS_LO16", ":", "case", "ELF", "::", "R_MIPS16_LO16", ":", "case", "ELF", "::", "R_MICROMIPS_LO16", ":", "return", "true", ";", "case", "ELF", "::", "R_MIPS_32", ":", "if", "(", "cast", "<", "MCSymbolELF", ">", "(", "Sym", ")", ".", "getOther", "(", ")", "&", "ELF", "::", "STO_MIPS_MICROMIPS", ")", "return", "true", ";", "case", "ELF", "::", "R_MIPS_26", ":", "case", "ELF", "::", "R_MIPS_64" ]

[ "return", "(", "(", "F", ">>", "<STR_LIT>", "::", "<STR_LIT>", ")", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "==", "OperandNum", ";" ]

[ "bool", "HexagonInstrInfo", "::", "isOperandExtended", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "OperandNum", ")", "const", "{", "const", "uint64_t", "F", "=", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", ";" ]

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

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

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m512i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_cvt_roundps_epu64", "(", "_", "_", "m256", "_", "_", "A", ",", "const", "int", "_", "_", "R", ")", "{", "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_cvtps2uqq512_mask", "(", "(", "_", "_", "v8sf", ")", "_", "_", "A", ",", "(", "_", "_", "v8di", ")", "_", "mm512_setzero_si512", "(", ")", ",", "(", "_", "_", "mmask8", ")", "-", "<NUM_LIT>", ",", "_", "_", "R", ")", ";" ]

[ "A", ",", "(", "_", "_", "v4sf", ")", "_", "_", "B", ",", "_", "_", "R", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m128", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_fnmadd_round_ss", "(", "_", "_", "m128", "_", "_", "W", ",", "_", "_", "m128", "_", "_", "A", ",", "_", "_", "m128", "_", "_", "B", ",", "const", "int", "_", "_", "R", ")", "{", "return", "(", "_", "_", "m128", ")", "_", "_", "builtin_ia32_vfmaddss3_round", "(", "(", "_", "_", "v4sf", ")", "_", "_", "W", ",", "-", "(", "_", "_", "v4sf", ")", "_", "_" ]

[ "static", "void", "mips_autovectorize_vector_sizes", "(", "vector_sizes", "*", "sizes", ")", "{", "if", "(", "ISA_HAS_MSA", ")", "sizes", "->", "safe_push", "(", "<NUM_LIT>", ")", ";", "}" ]

[ "Implement", "TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES", "." ]

[ ")", ";" ]

[ "setAttributeItem", "(", "THUMB_ISA_use", ",", "Allowed", ",", "false", ")", ";", "setAttributeItem", "(", "Virtualization_use", ",", "AllowTZ", ",", "false", ")", ";", "break", ";", "case", "ARM", "::", "ArchKind", "::", "ARMV6M", ":", "setAttributeItem", "(", "THUMB_ISA_use", ",", "Allowed", ",", "false", ")", ";", "break", ";", "case", "ARM", "::", "ArchKind", "::", "ARMV7A", ":", "setAttributeItem", "(", "CPU_arch_profile", ",", "ApplicationProfile", ",", "false", ")", ";", "setAttributeItem", "(", "ARM_ISA_use", ",", "Allowed", ",", "false", ")", ";", "setAttributeItem", "(", "THUMB_ISA_use", ",", "AllowThumb32", ",", "false", ")", ";", "break", ";", "case", "ARM", "::", "ArchKind", "::", "ARMV7R", ":", "setAttributeItem", "(", "CPU_arch_profile", ",", "RealTimeProfile", ",", "false", ")", ";", "setAttributeItem", "(", "ARM_ISA_use", ",", "Allowed", ",", "false", ")", ";", "setAttributeItem", "(", "THUMB_ISA_use", ",", "AllowThumb32", ",", "false", ")", ";", "break", ";", "case", "ARM", "::", "ArchKind", "::", "ARMV7EM", ":", "case", "ARM", "::", "ArchKind", "::", "ARMV7M", ":", "setAttributeItem", "(", "CPU_arch_profile", ",", "MicroControllerProfile", ",", "false", ")", ";", "setAttributeItem", "(", "THUMB_ISA_use", ",", "AllowThumb32", ",", "false", ")", ";", "break", ";", "case", "ARM", "::", "ArchKind", "::", "ARMV8A", ":", "case", "ARM", "::", "ArchKind", "::", "ARMV8_1A", ":", "case", "ARM", "::", "ArchKind", "::", "ARMV8_2A", ":", "setAttributeItem", "(", "CPU_arch_profile", ",", "ApplicationProfile", ",", "false", ")", ";", "setAttributeItem", "(", "ARM_ISA_use", ",", "Allowed", ",", "false", ")", ";", "setAttributeItem", "(", "THUMB_ISA_use", ",", "AllowThumb32", ",", "false", ")", ";", "setAttributeItem", "(", "MPextension_use", ",", "Allowed", ",", "false", ")", ";", "setAttributeItem", "(", "Virtualization_use", ",", "AllowTZVirtualization", ",", "false", ")", ";", "break", ";", "case", "ARM", "::", "ArchKind", "::", "ARMV8MBaseline", ":", "case", "ARM", "::", "ArchKind", "::", "ARMV8MMainline", ":", "setAttributeItem", "(", "THUMB_ISA_use", ",", "AllowThumbDerived", ",", "false", ")", ";", "setAttributeItem", "(", "CPU_arch_profile", ",", "MicroControllerProfile", ",", "false" ]

[ "->", "getStartLoc", "(", ")", ";" ]

[ "break", ";", "case", "Match_Success", ":", "{", "if", "(", "processInstruction", "(", "Inst", ",", "IDLoc", ",", "Instructions", ")", ")", "return", "true", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "Instructions", ".", "size", "(", ")", ";", "i", "++", ")", "Out", ".", "EmitInstruction", "(", "Instructions", "[", "i", "]", ")", ";", "return", "false", ";", "}", "case", "Match_MissingFeature", ":", "Error", "(", "IDLoc", ",", "<STR_LIT>", "instruction requires a CPU feature not currently enabled", "<STR_LIT>", ")", ";", "return", "true", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "<NUM_LIT>", "U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "too few operands for instruction", "<STR_LIT>", ")", ";", "ErrorLoc", "=", "(", "(", "MipsOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "CC", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec_volatile", ":", "CC", "[", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPECV_HTM_TSR", ")", ")", "(", "set", "(", "match_operand", ":", "BLK", "<NUM_LIT>", ")", "(", "unspec", ":", "BLK", "[", "(", "match_dup", "<NUM_LIT>", ")", "]", "UNSPEC_HTM_FENCE", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

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

[ "(", "set", "(", "match_operand", ":", "MVE_2", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "MVE_2", "[", "(", "match_operand", ":", "MVE_2", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "MVE_2", "<NUM_LIT>" ]

[ "enum", "aarch64_symbol_type", "aarch64_classify_symbol", "(", "rtx", "x", ",", "rtx", "offset", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "{", "switch", "(", "aarch64_cmodel", ")", "{", "case", "AARCH64_CMODEL_LARGE", ":", "return", "SYMBOL_FORCE_TO_MEM", ";", "case", "AARCH64_CMODEL_TINY_PIC", ":", "case", "AARCH64_CMODEL_TINY", ":", "return", "SYMBOL_TINY_ABSOLUTE", ";", "case", "AARCH64_CMODEL_SMALL_SPIC", ":", "case", "AARCH64_CMODEL_SMALL_PIC", ":", "case", "AARCH64_CMODEL_SMALL", ":", "return", "SYMBOL_SMALL_ABSOLUTE", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", "{", "if", "(", "aarch64_cmodel", "==", "AARCH64_CMODEL_LARGE", ")", "{", "if", "(", "nopcrelative_literal_loads", "&&", "CONSTANT_POOL_ADDRESS_P", "(", "x", ")", ")", "return", "SYMBOL_SMALL_ABSOLUTE", ";", "else", "return", "SYMBOL_FORCE_TO_MEM", ";", "}", "if", "(", "aarch64_tls_symbol_p", "(", "x", ")", ")", "return", "aarch64_classify_tls_symbol", "(", "x", ")", ";", "switch", "(", "aarch64_cmodel", ")", "{", "case", "AARCH64_CMODEL_TINY", ":", "if", "(", "SYMBOL_REF_WEAK", "(", "x", ")", "||", "INTVAL", "(", "offset", ")", "<", "-", "<NUM_LIT>", "||", "INTVAL", "(", "offset", ")", ">", "<NUM_LIT>", ")", "return", "SYMBOL_FORCE_TO_MEM", ";", "return", "SYMBOL_TINY_ABSOLUTE", ";", "case", "AARCH64_CMODEL_SMALL", ":", "if", "(", "SYMBOL_REF_WEAK", "(", "x", ")", "||", "!", "IN_RANGE", "(", "INTVAL", "(", "offset", ")", ",", "HOST_WIDE_INT_C", "(", "-", "<NUM_LIT>", ")", ",", "HOST_WIDE_INT_C", "(", "<NUM_LIT>", ")", ")", ")", "return", "SYMBOL_FORCE_TO_MEM", ";", "return", "SYMBOL_SMALL_ABSOLUTE", ";", "case", "AARCH64_CMODEL_TINY_PIC", ":", "if", "(", "!", "aarch64_symbol_binds_local_p", "(", "x", ")", ")", "return", "SYMBOL_TINY_GOT", ";", "return", "SYMBOL_TINY_ABSOLUTE", ";", "case", "AARCH64_CMODEL_SMALL_SPIC", ":", "case", "AARCH64_CMODEL_SMALL_PIC", ":", "if", "(", "!", "aarch64_symbol_binds_local_p", "(", "x", ")", ")", "return", "(", "aarch64_cmodel", "==", "AARCH64_CMODEL_SMALL_SPIC", "?", "SYMBOL_SMALL_GOT_28K", ":", "SYMBOL_SMALL_GOT_4G", ")", ";", "return", "SYMBOL_SMALL_ABSOLUTE", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "return", "SYMBOL_FORCE_TO_MEM", ";", "}" ]

[ "Return", "the", "method", "that", "should", "be", "used", "to", "access", "SYMBOL_REF", "or", "LABEL_REF", "X", "." ]

[ ";" ]

[ "class", "MemRegQOffsetAsmOperand", "<", "int", "shift", ">", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", "#", "shift", "#", "<STR_LIT>", ";", "let", "PredicateMethod", "=", "<STR_LIT>", "#", "shift", "#", "<STR_LIT>", ";", "let", "RenderMethod", "=", "<STR_LIT>" ]

[ "return", "BaseT", "::", "getUserCost", "(", "U", ",", "Operands", ")", ";" ]

[ "const", "LoadInst", "*", "LI", "=", "dyn_cast", "<", "const", "LoadInst", ">", "(", "CI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "return", "LI", "&&", "LI", "->", "hasOneUse", "(", ")", ";", "}", ";", "if", "(", "const", "CastInst", "*", "CI", "=", "dyn_cast", "<", "const", "CastInst", ">", "(", "U", ")", ")", "if", "(", "isCastFoldedIntoLoad", "(", "CI", ")", ")", "return", "TargetTransformInfo", "::", "TCC_Free", ";" ]

[ "<FIXS>", "[", "(", "set", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<FIXE>" ]

[ "}", "<STR_LIT>", "*", "movdf_internal", "<STR_LIT>", "nonimmediate_operand", "<STR_LIT>", "=", "f", ",", "f", ",", "m", ",", "*", "r", ",", "f", ",", "*", "r", ",", "*", "r", ",", "m", "<STR_LIT>", "general_operand", "<STR_LIT>", "fG", ",", "m", ",", "fG", ",", "fG", ",", "*", "r", ",", "*", "r", ",", "m", ",", "*", "r", "<STR_LIT>", "!", "memory_operand", "(", "operands", "[", "<NUM_LIT>", "]", ",", "DFmode", ")", "|", "|", "!", "memory_operand", "(", "operands", "[", "<NUM_LIT>", "]", ",", "DFmode", ")", "<STR_LIT>", "@" ]

[ "rtx", "str2", "=", "gen_rtx_REG", "(", "SImode", ",", "<NUM_LIT>", ")" ]

[ "(", "match_operand", ":", "BLK", "<NUM_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_CMPSTRN", ")", ")", "(", "use", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "]", "<STR_LIT>", "{", "rtx", "str1", "=", "gen_rtx_REG", "(", "SImode", ",", "<NUM_LIT>", ")" ]

[ "FOR_EACH_VEC_SAFE_ELT", "(", "branch_islands", ",", "ix", ",", "bi", ")", "if", "(", "function_name", "==", "bi", "->", "function_name", ")", "return", "<NUM_LIT>", ";" ]

[ "static", "int", "no_previous_def", "(", "tree", "function_name", ")", "{", "branch_island", "*", "bi", ";", "unsigned", "ix", ";" ]

[ "if", "(", "REG_P", "(", "x", ")", "&&", "(", "REX_INT_REGNO_P", "(", "REGNO", "(", "x", ")", ")", "||", "REX_SSE_REGNO_P", "(", "REGNO", "(", "x", ")", ")", "||", "REX2_INT_REGNO_P", "(", "REGNO", "(", "x", ")", ")", ")", ")", "return", "true", ";" ]

[ "bool", "x86_extended_reg_mentioned_p", "(", "rtx", "insn", ")", "{", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "INSN_P", "(", "insn", ")", "?", "PATTERN", "(", "insn", ")", ":", "insn", ",", "NONCONST", ")", "{", "const_rtx", "x", "=", "*", "iter", ";" ]

[ ")", ";" ]

[ "MachineBasicBlock", "::", "iterator", "I", ",", "NextI", ",", "NonPHI", "=", "B", "->", "getFirstNonPHI", "(", ")", ";", "for", "(", "I", "=", "B", "->", "begin", "(", ")", ";", "I", "!=", "NonPHI", ";", "I", "=", "NextI", ")", "{", "NextI", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "*", "PN", "=", "&", "*", "I", ";", "assert", "(", "PN", "->", "getNumOperands", "(", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Invalid phi node", "<STR_LIT>", ")", ";", "MachineOperand", "&", "UO", "=", "PN", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "unsigned", "UseR", "=", "UO", ".", "getReg", "(", ")", ",", "UseSR", "=", "UO", ".", "getSubReg", "(", ")", ";", "unsigned", "DefR", "=", "PN", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "NewR", "=", "UseR", ";", "if", "(", "UseSR", ")", "{", "const", "DebugLoc", "&", "DL", "=", "PN", "->", "getDebugLoc", "(" ]

[ "if", "(", "type", "==", "s390_builtin_types", "[", "BT_BV8HI", "]", ")", "return", "<STR_LIT>", "U6__bools", "<STR_LIT>", ";" ]

[ "type", "=", "TYPE_MAIN_VARIANT", "(", "type", ")", ";", "if", "(", "TREE_CODE", "(", "type", ")", "!=", "VOID_TYPE", "&&", "TREE_CODE", "(", "type", ")", "!=", "BOOLEAN_TYPE", "&&", "TREE_CODE", "(", "type", ")", "!=", "INTEGER_TYPE", "&&", "TREE_CODE", "(", "type", ")", "!=", "REAL_TYPE", ")", "return", "NULL", ";", "if", "(", "type", "==", "s390_builtin_types", "[", "BT_BV16QI", "]", ")", "return", "<STR_LIT>", "U6__boolc", "<STR_LIT>", ";" ]

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

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

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

[ "static", "bool", "r10k_protected_bb_p", "(", "basic_block", "bb", ",", "sbitmap", "protected_bbs", ")", "{", "edge_iterator", "ei", ";", "edge", "e", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "bb", "->", "preds", ")", "if", "(", "!", "single_succ_p", "(", "e", "->", "src", ")", "||", "!", "bitmap_bit_p", "(", "protected_bbs", ",", "e", "->", "src", "->", "index", ")", "||", "(", "e", "->", "flags", "&", "EDGE_COMPLEX", ")", "!=", "<NUM_LIT>", ")", "return", "false", ";" ]

[ "<STR_LIT>", ")" ]

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

[ "OW", "->", "WriteZeros", "(", "Count", "%", "<NUM_LIT>", ")", ";" ]

[ "uint64_t", "NumNops", "=", "Count", "/", "<NUM_LIT>", ";", "for", "(", "uint64_t", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumNops", ";", "++", "i", ")", "OW", "->", "write32", "(", "<NUM_LIT>", ")", ";" ]

[ "}" ]

[ "const", "<STR_LIT>", "::", "<STR_LIT>", "*", "Reg", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", "Val", ")", ";", "if", "(", "Reg", "&&", "Reg", "->", "Writeable", "&&", "Reg", "->", "haveFeatures", "(", "STI", ".", "getFeatureBits", "(", ")", ")", ")", "O", "<<", "Reg", "->", "Name", ";", "else", "O", "<<", "<STR_LIT>", "::", "<STR_LIT>", "(", "Val", ")", ";" ]

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

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

[ "Scale", ",", "SDValue", "&", "Index", ",", "SDValue", "&", "Disp", ",", "SDValue", "&", "Segment", ")", "{" ]

[ "bool", "X86DAGToDAGISel", "::", "TryFoldLoad", "(", "SDNode", "*", "P", ",", "SDValue", "N", ",", "SDValue", "&", "Base", ",", "SDValue", "&" ]

[ "return", "type", ";" ]

[ "unsigned", "long", "type", "=", "ARM_FT_UNKNOWN", ";", "tree", "a", ";", "tree", "attr", ";", "gcc_assert", "(", "TREE_CODE", "(", "current_function_decl", ")", "==", "FUNCTION_DECL", ")", ";", "if", "(", "optimize", ">", "<NUM_LIT>", "&&", "(", "TREE_NOTHROW", "(", "current_function_decl", ")", "||", "!", "(", "flag_unwind_tables", "||", "(", "flag_exceptions", "&&", "arm_except_unwind_info", "(", "&", "global_options", ")", "!=", "UI_SJLJ", ")", ")", ")", "&&", "TREE_THIS_VOLATILE", "(", "current_function_decl", ")", ")", "type", "|=", "ARM_FT_VOLATILE", ";", "if", "(", "cfun", "->", "static_chain_decl", "!=", "NULL", ")", "type", "|=", "ARM_FT_NESTED", ";", "attr", "=", "DECL_ATTRIBUTES", "(", "current_function_decl", ")", ";", "a", "=", "lookup_attribute", "(", "<STR_LIT>", "naked", "<STR_LIT>", ",", "attr", ")", ";", "if", "(", "a", "!=", "NULL_TREE", ")", "type", "|=", "ARM_FT_NAKED", ";", "a", "=", "lookup_attribute", "(", "<STR_LIT>", "isr", "<STR_LIT>", ",", "attr", ")", ";", "if", "(", "a", "==", "NULL_TREE", ")", "a", "=", "lookup_attribute", "(", "<STR_LIT>", "interrupt", "<STR_LIT>", ",", "attr", ")", ";", "if", "(", "a", "==", "NULL_TREE", ")", "type", "|=", "TARGET_INTERWORK", "?", "ARM_FT_INTERWORKED", ":", "ARM_FT_NORMAL", ";", "else", "type", "|=", "arm_isr_value", "(", "TREE_VALUE", "(", "a", ")", ")", ";", "if", "(", "lookup_attribute", "(", "<STR_LIT>", "cmse_nonsecure_entry", "<STR_LIT>", ",", "attr", ")", ")", "type", "|=", "ARM_FT_CMSE_ENTRY", ";" ]

[ "}", "else", "{" ]

[ "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "Hexagon", "::", "ADJCALLSTACKDOWN", ")", "{", "}", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "Hexagon", "::", "ADJCALLSTACKUP", ")", "{" ]

[ "<FIXS>", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "<FIXE>", "<FIXS>", "MCSymbol", "*", "Sym", "=", "OutContext", ".", "GetOrCreateSymbol", "(", "Name", ".", "str", "(", ")", ")", ";", "FnStubs", ".", "insert", "(", "Sym", ")", ";", "return", "Sym", ";", "}", "<FIXE>" ]

[ "Name", "+=", "<STR_LIT>", "$non_lazy_ptr", "<STR_LIT>", ";", "HiddenGVStubs", "[", "Name", ".", "str", "(", ")", "]", "=", "StringRef", "(", "Name", ".", "data", "(", ")", ",", "Name", ".", "size", "(", ")", "-", "<NUM_LIT>", ")", ";", "break", ";", "<BUGS>", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "<BUGE>", "Name", "+=", "<STR_LIT>", "$stub", "<STR_LIT>", ";", "<BUGS>", "FnStubs", "[", "Name", ".", "str", "(", ")", "]", "=", "StringRef", "(", "Name", ".", "data", "(", ")", ",", "Name", ".", "size", "(", ")", "-", "<NUM_LIT>", ")", ";", "break", ";", "<BUGE>", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "Name", "+=", "<STR_LIT>", "@TLSGD", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "Name", "+=", "<STR_LIT>", "@GOTTPOFF", "<STR_LIT>", ";", "break", ";" ]

[ "}" ]

[ "def", "VLD3LNq16", ":", "VLD3LN", "<", "<NUM_LIT>", ",", "{", "?", ",", "?", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "<STR_LIT>", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "lane", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

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

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

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

[ "[", "(", "const_int", "<NUM_LIT>", ")", "]", "{", "visium_split_cbranch", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ",", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ",", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ",", "operands", "[" ]

[ "}" ]

[ "Regs", "[", "R", "]", "=", "true", ";", "}", "int", "F", "=", "Regs", ".", "find_first", "(", ")", ";", "if", "(", "F", "!=", "Hexagon", "::", "D8", ")", "return", "true", ";", "while", "(", "F", ">=", "<NUM_LIT>", ")", "{", "int", "N", "=", "Regs", ".", "find_next", "(", "F", ")", ";", "if", "(", "N", ">=", "<NUM_LIT>", "&&", "N", "!=", "F", "+", "<NUM_LIT>", ")", "return", "true", ";", "F", "=", "N", ";", "}", "return", "false", ";" ]

[ ";" ]

[ "Set", ".", "erase", "(", "V", ")", ";", "return", "V" ]

[ "<STR_LIT>", ")" ]

[ "(", "and", "(", "match_code" ]

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

[ "PM", ".", "add", "(", "createARMISelDag", "(", "*", "this" ]

[ "}" ]

[ "SDValue", "SrcPtr", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "const", "Value", "*", "DstSV", "=", "cast", "<", "SrcValueSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getValue", "(", ")", ";", "const", "Value", "*", "SrcSV", "=", "cast", "<", "SrcValueSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getValue", "(", ")", ";", "SDLoc", "DL", "(", "Op", ")", ";", "return", "DAG", ".", "getMemcpy", "(", "Chain", ",", "DL", ",", "DstPtr", ",", "SrcPtr", ",", "DAG", ".", "getIntPtrConstant", "(", "Subtarget", "->", "has64BitPointers", "(", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ",", "Subtarget", "->", "has64BitPointers", "(", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ",", "false", ",", "false", ",", "false", ",", "MachinePointerInfo", "(", "DstSV", ")", ",", "MachinePointerInfo", "(", "SrcSV", ")", ")", ";" ]

[ "EmitLinkage", "(", "GV", ",", "GVSym", ")", ";" ]

[ "GVSym", "->", "redefineIfPossible", "(", ")", ";", "if", "(", "GVSym", "->", "isDefined", "(", ")", "||", "GVSym", "->", "isVariable", "(", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "symbol '", "<STR_LIT>", "+", "Twine", "(", "GVSym", "->", "getName", "(", ")", ")", "+", "<STR_LIT>", "' is already defined", "<STR_LIT>", ")", ";", "const", "DataLayout", "&", "DL", "=", "GV", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "uint64_t", "Size", "=", "DL", ".", "getTypeAllocSize", "(", "GV", "->", "getValueType", "(", ")", ")", ";", "unsigned", "Align", "=", "GV", "->", "getAlignment", "(", ")", ";", "if", "(", "!", "Align", ")", "Align", "=", "<NUM_LIT>", ";", "EmitVisibility", "(", "GVSym", ",", "GV", "->", "getVisibility", "(", ")", ",", "!", "GV", "->", "isDeclaration", "(", ")", ")", ";" ]

[ "context", "*", "ctxt", ")", "{" ]

[ "rtl_opt_pass", "*", "make_pass_analyze_swaps", "(", "gcc", "::" ]

[ ")", "==", "Triple", "::", "mips64", ")", ")", "{" ]

[ "if", "(", "(", "TheTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "mips", ")", "||", "(", "TheTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "mips64", ")", ")", "IsLittleEndian", "=", "false", ";", "if", "(", "(", "TheTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "mips64el", ")", "||", "(", "TheTriple", ".", "getArch", "(" ]

[ "static", "bool", "pru_valid_const_ubyte_offset", "(", "machine_mode", "mode", ",", "HOST_WIDE_INT", "offset", ")", "{", "bool", "valid", "=", "UBYTE_INT", "(", "offset", ")", ";", "if", "(", "valid", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "GET_MODE_SIZE", "(", "SImode", ")", ")", "valid", "=", "UBYTE_INT", "(", "offset", "+", "GET_MODE_SIZE", "(", "mode", ")", "-", "<NUM_LIT>", ")", ";", "return", "valid", ";", "}" ]

[ "Return", "true", "if", "given", "xbbo", "constant", "OFFSET", "is", "valid", "." ]

[ "default", ":" ]

[ "case", "E_DImode", ":", "return", "gen_loadwb_pairdi_di", "(", "base", ",", "base", ",", "reg", ",", "reg2", ",", "GEN_INT", "(", "adjustment", ")", ",", "GEN_INT", "(", "UNITS_PER_WORD", ")", ")", ";", "case", "E_DFmode", ":", "return", "gen_loadwb_pairdf_di", "(", "base", ",", "base", ",", "reg", ",", "reg2", ",", "GEN_INT", "(", "adjustment", ")", ",", "GEN_INT", "(", "UNITS_PER_WORD", ")", ")", ";", "case", "E_TFmode", ":", "return", "gen_loadwb_pairtf_di", "(", "base", ",", "base", ",", "reg", ",", "reg2", ",", "GEN_INT", "(", "adjustment", ")", ",", "GEN_INT", "(", "UNITS_PER_VREG", ")", ")", ";" ]

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

[ "}", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "ExitingMBBs", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "mergeLoopbreakBlock", "(", "ExitingMBBs", "[", "i", "]", ",", "ExitBlk", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "LatchBlks", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "settleLoopcontBlock", "(", "LatchBlks", "[", "i", "]", ",", "LoopHeader", ")", ";", "int", "Match", "=", "<NUM_LIT>", ";", "do", "{", "Match", "=", "<NUM_LIT>", ";", "Match", "+=", "serialPatternMatch", "(", "LoopHeader", ")", ";", "Match", "+=", "ifPatternMatch", "(", "LoopHeader", ")", ";", "}", "while", "(", "Match", ">", "<NUM_LIT>", ")", ";", "mergeLooplandBlock", "(", "LoopHeader", ",", "ExitBlk", ")", ";", "MachineLoop", "*", "ParentLoop", "=", "LoopRep", "->", "getParentLoop", "(", ")", ";", "if", "(", "ParentLoop", ")", "MLI", "->", "changeLoopFor", "(", "LoopHeader", ",", "ParentLoop", ")", ";", "else", "MLI", "->", "removeBlock", "(", "LoopHeader", ")", ";", "Visited", "[", "LoopRep", "]", "=", "true", ";" ]

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

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

[ "<FIXS>", "MachinePointerInfo", "::", "getFixedStack", "(", "DAG", ".", "getMachineFunction", "(", ")", ",", "FI", ")", ")", ";", "<FIXE>" ]

[ "SDValue", "FIN", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getLoad", "(", "ValVT", ",", "dl", ",", "Chain", ",", "FIN", ",", "<BUGS>", "MachinePointerInfo", "::", "getFixedStack", "(", "DAG", ".", "getMachineFunction", "(", ")", ",", "FI", ")", ",", "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "<BUGE>", "return", "ExtendedInMem", "?", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ":", "Val", ";", "}" ]

[ ";" ]

[ "def", "LITERAL", ":", "InstFlag", "<", "<STR_LIT>", ">" ]

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

[ "[", "(", "parallel", "[", "(", "set", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "call", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "}" ]

[ "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ ")", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "plus", ":", "DI", "(", "plus", ":", "DI", "(", "mult", ":", "DI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ ";" ]

[ "def", "Xrx64", ":", "BaseAddSubEReg64", "<", "isSub", ",", "<NUM_LIT>", ",", "GPR64", ",", "GPR64sp", ",", "GPR64", ",", "arith_extendlsl64", ",", "mnemonic", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>" ]

[ "if", "(", "ACI", "&&", "isAMXCast", "(", "ACI", ")", ")", "{" ]

[ "Instruction", "*", "ACI", "=", "dyn_cast", "<", "Instruction", ">", "(", "V", ")", ";", "if", "(", "ACI", "&&", "isAMXCast", "(", "ACI", ")", ")", "{", "Type", "*", "TyB", "=", "ACI", "->", "getOperand", "(", "<NUM_LIT>", ")", "->", "getType", "(", ")", ";", "Type", "*", "TyA", "=", "ACI", "->", "getType", "(", ")", ";", "if", "(", "TyA", "!=", "DestTy", "||", "TyB", "!=", "SrcTy", ")", "return", "false", ";", "}", "else", "if", "(", "auto", "*", "PHI", "=", "dyn_cast", "<", "PHINode", ">", "(", "V", ")", ")", "{", "if", "(", "OldPhiNodes", ".", "count", "(", "PHI", ")", "==", "<NUM_LIT>", ")", "return", "false", ";", "}", "else", "return", "false", ";", "}", "}", "SmallDenseMap", "<", "PHINode", "*", ",", "PHINode", "*", ">", "NewPNodes", ";", "for", "(", "auto", "*", "OldPN", ":", "OldPhiNodes", ")", "{", "Builder", ".", "SetInsertPoint", "(", "OldPN", ")", ";", "PHINode", "*", "NewPN", "=", "Builder", ".", "CreatePHI", "(", "DestTy", ",", "OldPN", "->", "getNumOperands", "(", ")", ")", ";", "NewPNodes", "[", "OldPN", "]", "=", "NewPN", ";", "}", "for", "(", "auto", "*", "OldPN", ":", "OldPhiNodes", ")", "{", "PHINode", "*", "NewPN", "=", "NewPNodes", "[", "OldPN", "]", ";", "for", "(", "unsigned", "j", "=", "<NUM_LIT>", ",", "e", "=", "OldPN", "->", "getNumOperands", "(", ")", ";", "j", "!=", "e", ";", "++", "j", ")", "{", "Value", "*", "V", "=", "OldPN", "->", "getOperand", "(", "j", ")", ";", "Value", "*", "NewV", "=", "nullptr", ";", "Instruction", "*", "ACI", "=", "dyn_cast", "<", "Instruction", ">", "(", "V", ")", ";", "if", "(", "ACI", "&&", "isAMXCast", "(", "ACI", ")", ")", "NewV", "=", "ACI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "else", "if", "(", "auto", "*", "PrevPN", "=", "dyn_cast", "<", "PHINode", ">", "(", "V", ")", ")", "NewV", "=", "NewPNodes", "[", "PrevPN", "]", ";", "assert", "(", "NewV", ")", ";", "NewPN", "->", "addIncoming", "(", "NewV", ",", "OldPN", "->", "getIncomingBlock", "(", "j", ")", ")", ";", "}", "}", "for", "(", "auto", "*", "OldPN", ":", "OldPhiNodes", ")", "{", "PHINode", "*", "NewPN", "=", "NewPNodes", "[", "OldPN", "]", ";", "for", "(", "User", "*", "V", ":", "make_early_inc_range", "(", "OldPN", "->", "users", "(", ")", ")", ")", "{", "Instruction", "*", "ACI", "=", "dyn_cast", "<", "Instruction", ">", "(", "V", ")", ";" ]

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

[ "def", "SWSri", ":", "BaseIntegerToFP", "<", "isUnsigned", ",", "GPR32", ",", "FPR32", ",", "fixedpoint_f32_i32", ",", "asm", ",", "[", "(", "set", "FPR32", ":", "$", "Rd", ",", "(", "fdiv", "(", "node", "GPR32", ":", "$", "Rn", ")", ",", "fixedpoint_f32_i32", ":", "$", "scale", ")", ")", "]", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ ")", "||", "isSymbolRef", "(", ")", ";" ]

[ "return", "(", "isConstantImm", "(", ")", "&&", "isUInt", "<", "<NUM_LIT>", ">", "(", "getConstantImm", "(", ")", ")" ]

[ "gen_reg_rtx", "(", "SImode", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "UHA", "<NUM_LIT>", "<STR_LIT>", ")", "(", "mult", ":", "UHA", "(", "match_operand", ":", "UHA", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "UHA", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{", "rtx", "tmp1", "=" ]

[ "::", "f80", ";" ]

[ "}", "else", "{", "bool", "ValIsKill", "=", "hasTrivialKill", "(", "ArgVal", ")", ";", "if", "(", "!", "X86FastEmitStore", "(", "ArgVT", ",", "ArgReg", ",", "ValIsKill", ",", "AM", ",", "MMO", ")", ")", "return", "false", ";", "}", "}", "}", "if", "(", "Subtarget", "->", "isPICStyleGOT", "(", ")", ")", "{", "unsigned", "Base", "=", "getInstrInfo", "(", ")", "->", "getGlobalBaseReg", "(", "FuncInfo", ".", "MF", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "X86", "::", "EBX", ")", ".", "addReg", "(", "Base", ")", ";", "}", "if", "(", "Is64Bit", "&&", "IsVarArg", "&&", "!", "IsWin64", ")", "{", "static", "const", "MCPhysReg", "XMMArgRegs", "[", "]", "=", "{", "X86", "::", "XMM0", ",", "X86", "::", "XMM1", ",", "X86", "::", "XMM2", ",", "X86", "::", "XMM3", ",", "X86", "::", "XMM4", ",", "X86", "::", "XMM5", ",", "X86", "::", "XMM6", ",", "X86", "::", "XMM7", "}", ";", "unsigned", "NumXMMRegs", "=", "CCInfo", ".", "getFirstUnallocated", "(", "XMMArgRegs", ")", ";", "assert", "(", "(", "Subtarget", "->", "hasSSE1", "(", ")", "||", "!", "NumXMMRegs", ")", "&&", "<STR_LIT>", "SSE registers cannot be used when SSE is disabled", "<STR_LIT>", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "X86", "::", "MOV8ri", ")", ",", "X86", "::", "AL", ")", ".", "addImm", "(", "NumXMMRegs", ")", ";", "}", "X86AddressMode", "CalleeAM", ";", "if", "(", "!", "X86SelectCallAddress", "(", "Callee", ",", "CalleeAM", ")", ")", "return", "false", ";", "unsigned", "CalleeOp", "=", "<NUM_LIT>", ";", "const", "GlobalValue", "*", "GV", "=", "nullptr", ";", "if", "(", "CalleeAM", ".", "GV", "!=", "nullptr", ")", "{", "GV", "=", "CalleeAM", ".", "GV", ";", "}", "else", "if", "(", "CalleeAM", ".", "Base", ".", "Reg", "!=", "<NUM_LIT>", ")", "{", "CalleeOp", "=", "CalleeAM", ".", "Base", ".", "Reg", ";", "}", "else", "return", "false", ";", "MachineInstrBuilder", "MIB", ";", "if", "(", "CalleeOp", ")", "{", "unsigned", "CallOpc", "=", "Is64Bit", "?", "X86", "::", "CALL64r", ":", "X86", "::", "CALL32r", ";", "MIB", "=", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "CallOpc", ")", ")", ".", "addReg", "(", "CalleeOp", ")", ";", "}", "else", "{", "assert", "(", "GV", "&&", "<STR_LIT>", "Not a direct call", "<STR_LIT>", ")", ";", "unsigned", "char", "OpFlags", "=", "Subtarget", "->", "classifyGlobalFunctionReference", "(", "GV", ")", ";", "bool", "NeedLoad", "=", "OpFlags", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "OpFlags", "==", "<STR_LIT>", "::", "<STR_LIT>", ";", "unsigned", "CallOpc", "=", "NeedLoad", "?", "(", "Is64Bit", "?", "X86", "::", "CALL64m", ":", "X86", "::", "CALL32m", ")", ":", "(", "Is64Bit", "?", "X86", "::", "CALL64pcrel32", ":", "X86", "::", "CALLpcrel32", ")", ";", "MIB", "=", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "CallOpc", ")", ")", ";", "if", "(", "NeedLoad", ")", "MIB", ".", "addReg", "(", "Is64Bit", "?", "X86", "::", "RIP", ":", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ";", "if", "(", "Symbol", ")", "MIB", ".", "addSym", "(", "Symbol", ",", "OpFlags", ")", ";", "else", "MIB", ".", "addGlobalAddress", "(", "GV", ",", "<NUM_LIT>", ",", "OpFlags", ")", ";", "if", "(", "NeedLoad", ")", "MIB", ".", "addReg", "(", "<NUM_LIT>", ")", ";", "}", "MIB", ".", "addRegMask", "(", "TRI", ".", "getCallPreservedMask", "(", "*", "FuncInfo", ".", "MF", ",", "CC", ")", ")", ";", "if", "(", "Subtarget", "->", "isPICStyleGOT", "(", ")", ")", "MIB", ".", "addReg", "(", "X86", "::", "EBX", ",", "RegState", "::", "Implicit", ")", ";", "if", "(", "Is64Bit", "&&", "IsVarArg", "&&", "!", "IsWin64", ")", "MIB", ".", "addReg", "(", "X86", "::", "AL", ",", "RegState", "::", "Implicit", ")", ";", "for", "(", "auto", "Reg", ":", "OutRegs", ")", "MIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Implicit", ")", ";", "unsigned", "NumBytesForCalleeToPop", "=", "X86", "::", "isCalleePop", "(", "CC", ",", "Subtarget", "->", "is64Bit", "(", ")", ",", "IsVarArg", ",", "TM", ".", "Options", ".", "GuaranteedTailCallOpt", ")", "?", "NumBytes", ":", "computeBytesPoppedByCalleeForSRet", "(", "Subtarget", ",", "CC", ",", "CLI", ".", "CS", ")", ";", "unsigned", "AdjStackUp", "=", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "AdjStackUp", ")", ")", ".", "addImm", "(", "NumBytes", ")", ".", "addImm", "(", "NumBytesForCalleeToPop", ")", ";", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "RVLocs", ";", "CCState", "CCRetInfo", "(", "CC", ",", "IsVarArg", ",", "*", "FuncInfo", ".", "MF", ",", "RVLocs", ",", "CLI", ".", "RetTy", "->", "getContext", "(", ")", ")", ";", "CCRetInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_X86", ")", ";", "unsigned", "ResultReg", "=", "FuncInfo", ".", "CreateRegs", "(", "CLI", ".", "RetTy", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "EVT", "CopyVT", "=", "VA", ".", "getValVT", "(", ")", ";", "unsigned", "CopyReg", "=", "ResultReg", "+", "i", ";", "unsigned", "SrcReg", "=", "VA", ".", "getLocReg", "(", ")", ";", "if", "(", "(", "CopyVT", "==", "MVT", "::", "f32", "||", "CopyVT", "==", "MVT", "::", "f64", ")", "&&", "(", "(", "Is64Bit", "||", "Ins", "[", "i", "]", ".", "Flags", ".", "isInReg", "(", ")", ")", "&&", "!", "Subtarget", "->", "hasSSE1", "(", ")", ")", ")", "{", "report_fatal_error", "(", "<STR_LIT>", "SSE register return with SSE disabled", "<STR_LIT>", ")", ";", "}", "if", "(", "(", "SrcReg", "==", "X86", "::", "FP0", "||", "SrcReg", "==", "X86", "::", "FP1", ")", "&&", "isScalarFPTypeInSSEReg", "(", "VA", ".", "getValVT", "(", ")", ")", ")", "{", "CopyVT", "=", "MVT" ]

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

[ "def", "STPXpre", ":", "StorePairPreIdx", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "GPR64z" ]

[ "if", "(", "isThumbTwo", "(", ")", "&&", "Mnemonic", "==", "<STR_LIT>", "mul", "<STR_LIT>", "&&", "Operands", ".", "size", "(", ")", "==", "<NUM_LIT>", "&&", "static_cast", "<", "ARMOperand", "*", ">", "(", "Operands", "[", "<NUM_LIT>", "]", ")", "->", "getReg", "(", ")", "==", "<NUM_LIT>", "&&", "static_cast", "<", "ARMOperand", "*", ">", "(", "Operands", "[", "<NUM_LIT>", "]", ")", "->", "isReg", "(", ")", "&&", "static_cast", "<", "ARMOperand", "*", ">", "(", "Operands", "[", "<NUM_LIT>", "]", ")", "->", "isReg", "(", ")", "&&", "(", "!", "isARMLowRegister", "(", "static_cast", "<", "ARMOperand", "*", ">", "(", "Operands", "[", "<NUM_LIT>", "]", ")", "->", "getReg", "(", ")", ")", "||", "!", "isARMLowRegister", "(", "static_cast", "<", "ARMOperand", "*", ">", "(", "Operands", "[", "<NUM_LIT>", "]", ")", "->", "getReg", "(", ")", ")", "||", "!", "inITBlock", "(", ")", ")", ")", "return", "true", ";" ]

[ "}", "if", "(", "isThumbTwo", "(", ")", "&&", "Mnemonic", "==", "<STR_LIT>", "mul", "<STR_LIT>", "&&", "Operands", ".", "size", "(", ")", "==", "<NUM_LIT>", "&&", "static_cast", "<", "ARMOperand", "*", ">", "(", "Operands", "[", "<NUM_LIT>", "]", ")", "->", "getReg", "(", ")", "==", "<NUM_LIT>", "&&", "static_cast", "<", "ARMOperand", "*", ">", "(", "Operands", "[", "<NUM_LIT>", "]", ")", "->", "isReg", "(", ")", "&&", "static_cast", "<", "ARMOperand", "*", ">", "(", "Operands", "[", "<NUM_LIT>", "]", ")", "->", "isReg", "(", ")", "&&", "static_cast", "<", "ARMOperand", "*", ">", "(", "Operands", "[", "<NUM_LIT>", "]", ")", "->", "isReg", "(", ")", "&&", "(", "!", "isARMLowRegister", "(", "static_cast", "<", "ARMOperand", "*", ">", "(", "Operands", "[", "<NUM_LIT>", "]", ")", "->", "getReg", "(", ")", ")", "||", "!", "isARMLowRegister", "(", "static_cast", "<", "ARMOperand", "*", ">", "(", "Operands", "[", "<NUM_LIT>", "]", ")", "->", "getReg", "(", ")", ")", "||", "!", "isARMLowRegister", "(", "static_cast", "<", "ARMOperand", "*", ">", "(", "Operands", "[", "<NUM_LIT>", "]", ")", "->", "getReg", "(", ")", ")", "||", "!", "inITBlock", "(", ")", "||", "(", "static_cast", "<", "ARMOperand", "*", ">", "(", "Operands", "[", "<NUM_LIT>", "]", ")", "->", "getReg", "(", ")", "!=", "static_cast", "<", "ARMOperand", "*", ">", "(", "Operands", "[", "<NUM_LIT>", "]", ")", "->", "getReg", "(", ")", "&&", "static_cast", "<", "ARMOperand", "*", ">", "(", "Operands", "[", "<NUM_LIT>", "]", ")", "->", "getReg", "(", ")", "!=", "static_cast", "<", "ARMOperand", "*", ">", "(", "Operands", "[", "<NUM_LIT>", "]", ")", "->", "getReg", "(", ")", ")", ")", ")", "return", "true", ";" ]

[ ",", "Options", ",", "false", ")", ";" ]

[ "return", "createARMAsmBackend", "(", "T", ",", "MRI", ",", "TT", ",", "CPU" ]

[ ";" ]

[ "emit_move_insn", "(", "arg", ",", "ti", ")", ";", "fn", "=", "gen_rtx_MEM", "(", "QImode", ",", "nios2_tls_symbol", ")", ";", "insn", "=", "emit_call_insn", "(", "gen_call_value", "(", "ret", ",", "fn", ",", "const0_rtx", ")", ")", ";", "RTL_CONST_CALL_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ",", "ret", ")", ";", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ",", "arg", ")", ";", "return", "ret" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "imm", "{", "<NUM_LIT>", "}", ";", "}", "def", "_S", ":", "sve2_int_bin_shift_imm_narrow_bottom", "{", "<NUM_LIT>", ",", "?", ",", "?", "}", ",", "opc", ",", "asm", ",", "ZPR32", ",", "ZPR64", ",", "<BUGS>", "vecshiftR32", ">", "{", "<BUGE>", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "imm", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "}", "def", ":", "SVE_2_Op_Imm_Pat", "nxv16i8", ",", "op", ",", "nxv8i16", ",", "i32", ",", "tvecshiftR8", ",", "!", "cast", "Instruction", ">", "(", "NAME", "#", "_B", ")", ">", ";" ]

[ "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ")", ";" ]

[ "MCInst", "MovX0Op0", "=", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "MCInst", "MovX1Op1", "=", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "bool", "MachO", "=", "TM", ".", "getTargetTriple", "(", ")", ".", "isOSBinFormatMachO", "(", ")", ";", "auto", "*", "Sym", "=", "MCSymbolRefExpr", "::", "create", "(", "OutContext", ".", "getOrCreateSymbol", "(", "Twine", "(", "MachO", "?", "<STR_LIT>", "_", "<STR_LIT>", ":", "<STR_LIT>", "<STR_LIT>", ")", "+", "(", "Typed", "?", "<STR_LIT>", "__xray_TypedEvent", "<STR_LIT>", ":", "<STR_LIT>", "__xray_CustomEvent", "<STR_LIT>", ")", ")", ",", "OutContext", ")", ";", "if", "(", "Typed", ")", "{", "O", ".", "AddComment", "(", "<STR_LIT>", "Begin XRay typed event", "<STR_LIT>", ")", ";", "EmitToStreamer", "(", "O", ",", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ")", ";", "EmitToStreamer", "(", "O", ",", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "-", "<NUM_LIT>", ")", ")", ";", "EmitToStreamer", "(", "O", ",", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ")", ";", "EmitToStreamer", "(", "O", ",", "MovX0Op0", ")", ";", "EmitToStreamer", "(", "O", ",", "MovX1Op1", ")", ";", "EmitToStreamer", "(", "O", ",", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ")", ";", "EmitToStreamer", "(", "O", ",", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addExpr", "(", "Sym", ")", ")", ";", "EmitToStreamer", "(", "O", ",", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ")", ";", "O", ".", "AddComment", "(", "<STR_LIT>", "End XRay typed event", "<STR_LIT>", ")", ";", "EmitToStreamer", "(", "O", ",", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ")", ";", "recordSled", "(", "CurSled", ",", "MI", ",", "SledKind", "::", "TYPED_EVENT", ",", "<NUM_LIT>", ")", ";", "}", "else", "{", "O", ".", "AddComment", "(", "<STR_LIT>", "Begin XRay custom event", "<STR_LIT>", ")", ";", "EmitToStreamer", "(", "O", ",", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ")", ";", "EmitToStreamer", "(", "O", ",", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "-", "<NUM_LIT>", ")", ")", ";", "EmitToStreamer", "(", "O", ",", "MovX0Op0", ")", ";", "EmitToStreamer", "(", "O", ",", "MovX1Op1", ")", ";", "EmitToStreamer", "(", "O", ",", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addExpr", "(", "Sym", ")", ")", ";", "O", ".", "AddComment", "(", "<STR_LIT>", "End XRay custom event", "<STR_LIT>", ")", ";", "EmitToStreamer", "(", "O", ",", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(" ]

[ "}" ]

[ "class", "VLD2DUP", "<", "bits", "<", "<NUM_LIT>", ">", "op7_4", ",", "string", "Dt", ",", "RegisterOperand", "VdTy", ",", "Operand", "AddrMode", ">", ":", "NLdSt", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "op7_4", ",", "(", "outs", "VdTy", ":", "$", "Vd", ")", ",", "(", "ins", "AddrMode", ":", "$", "Rn", ")", ",", "IIC_VLD2dup", ",", "<STR_LIT>", ",", "Dt", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", "{", "let", "Rm", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Rn", "{", "<NUM_LIT>", "}", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

[ "InstrItinClass", "Itinerary", "=", "itin", ";" ]

[ "string", "AsmString", "=", "!", "strconcat", "(", "instr_asm", ",", "<STR_LIT>", ")", ";", "list", "<", "dag", ">", "Pattern", "=", "[", "(", "set", "ROWD", ":", "$", "wd", ",", "(", "OpNode", "ROWS", ":", "$", "ws", ",", "ROWT", ":", "$", "wt", ")", ")", "]", ";" ]

[ ")", "return", "E", ";" ]

[ "int", "MIUnscaledOffset", "=", "getLdStOffsetOp", "(", "MemMI", ")", ".", "getImm", "(", ")", "*", "getMemScale", "(", "MemMI", ")", ";", "if", "(", "MIUnscaledOffset", "!=", "UnscaledOffset", ")", "return", "E", ";", "if", "(", "!", "isTagStore", "(", "MemMI", ")", "&&", "MemMI", ".", "getOpcode", "(", ")", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "bool", "IsPairedInsn", "=", "isPairedLdSt", "(", "MemMI", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "IsPairedInsn", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "Register", "DestReg", "=", "getLdStRegOp", "(", "MemMI", ",", "i", ")", ".", "getReg", "(", ")", ";", "if", "(", "DestReg", "==", "BaseReg", "||", "TRI", "->", "isSubRegister", "(", "BaseReg", ",", "DestReg", ")" ]

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

[ "def", ":", "Pat", "<", "(", "v1f64", "(", "AArch64NvCast", "(", "f64", "FPR64", ":", "$", "src", ")", ")", ")", ",", "(", "v1f64", "FPR64", ":" ]

[ "TypeCR", ">", ",", "Enc_9ac432", "{" ]

[ "def", "C4_and_or", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "PredRegs", ":", "$", "Ps4", ",", "PredRegs", ":", "$", "Pt4", ",", "PredRegs", ":", "$", "Pu4", ")", ",", "<STR_LIT>", ",", "tc_b31c2e97", "," ]

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

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

[ "case", "AsmToken", "::", "Integer", ":" ]

[ "return", "false", ";", "case", "AsmToken", "::", "Identifier", ":", "case", "AsmToken", "::", "LParen", ":", "case", "AsmToken", "::", "Plus", ":", "case", "AsmToken", "::", "Minus", ":", "case", "AsmToken", "::", "Integer", ":", "case", "AsmToken", "::", "Dot", ":", "case", "AsmToken", "::", "Dollar", ":", "case", "AsmToken", "::", "Exclaim", ":", "case", "AsmToken", "::", "Tilde", ":", "case", "AsmToken", "::", "String", ":", "if", "(", "isDarwin", "(", ")", ")", "{", "unsigned", "RegNo", ";", "int64_t", "IntVal", ";", "if", "(", "!", "MatchRegisterName", "(", "RegNo", ",", "IntVal", ")", ")", "{", "Operands", ".", "push_back", "(", "PPCOperand", "::", "CreateImm", "(", "IntVal", ",", "S", ",", "E", ",", "isPPC64", "(", ")", ")", ")", ";", "return", "false", ";", "}", "}", "if", "(", "!", "ParseExpression", "(", "EVal", ")", ")", "break", ";", "LLVM_FALLTHROUGH", ";", "default", ":", "return", "Error", "(", "S", ",", "<STR_LIT>", "unknown operand", "<STR_LIT>", ")", ";", "}", "Operands", ".", "push_back", "(", "PPCOperand", "::", "CreateFromMCExpr", "(", "EVal", ",", "S", ",", "E", ",", "isPPC64", "(", ")", ")", ")", ";", "bool", "TLSCall", "=", "false", ";", "if", "(", "const", "MCSymbolRefExpr", "*", "Ref", "=", "dyn_cast", "<", "MCSymbolRefExpr", ">", "(", "EVal", ")", ")", "TLSCall", "=", "Ref", "->", "getSymbol", "(", ")", ".", "getName", "(", ")", "==", "<STR_LIT>", "__tls_get_addr", "<STR_LIT>", ";", "if", "(", "TLSCall", "&&", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "LParen", ")", ")", "{", "const", "MCExpr", "*", "TLSSym", ";", "Parser", ".", "Lex", "(", ")", ";", "S", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "if", "(", "ParseExpression", "(", "TLSSym", ")", ")", "return", "Error", "(", "S", ",", "<STR_LIT>", "invalid TLS call expression", "<STR_LIT>", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "RParen", ")", ")", "return", "Error", "(", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ",", "<STR_LIT>", "missing ')'", "<STR_LIT>", ")", ";", "E", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "Operands", ".", "push_back", "(", "PPCOperand", "::", "CreateFromMCExpr", "(", "TLSSym", ",", "S", ",", "E", ",", "isPPC64", "(", ")", ")", ")", ";", "}", "if", "(", "!", "TLSCall", "&&", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "LParen", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "S", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "int64_t", "IntVal", ";", "switch", "(", "getLexer", "(", ")", ".", "getKind", "(", ")", ")", "{", "case", "AsmToken", "::", "Percent", ":", "Parser", ".", "Lex", "(", ")", ";", "unsigned", "RegNo", ";", "if", "(", "MatchRegisterName", "(", "RegNo", ",", "IntVal", ")", ")", "return", "Error", "(", "S", ",", "<STR_LIT>", "invalid register name", "<STR_LIT>", ")", ";", "break", ";" ]

[ "static", "void", "frv_output_dwarf_dtprel", "(", "FILE", "*", "file", ",", "int", "size", ",", "rtx", "x", ")", "{", "gcc_assert", "(", "size", "==", "<NUM_LIT>", ")", ";", "fputs", "(", "<STR_LIT>", "\\t.picptr\\ttlsmoff(", "<STR_LIT>", ",", "file", ")", ";", "output_addr_const", "(", "file", ",", "plus_constant", "(", "x", ",", "TLS_BIAS", ")", ")", ";", "fputs", "(", "<STR_LIT>", ")", "<STR_LIT>", ",", "file", ")", ";", "}" ]

[ "This", "is", "called", "from", "dwarf2out.cc", "via", "TARGET_ASM_OUTPUT_DWARF_DTPREL", ".", "We", "need", "to", "emit", "DTP-relative", "relocations", "." ]

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

[ "(", "define_peephole", "[", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "plus", ":", "SI", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "const_int", "-", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "zero_extend", ":", "HI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>" ]

[ ")", ")" ]

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

[ "}" ]

[ "static", "DecodeStatus", "DecodeCCRRegisterClass", "(", "MCInst", "&", "Inst", ",", "unsigned", "RegNo", ",", "uint64_t", "Address", ",", "const", "void", "*", "Decoder", ")", "{", "if", "(", "RegNo", ">", "<NUM_LIT>", ")", "return", "MCDisassembler", "::", "Fail", ";", "unsigned", "Reg", "=", "getReg", "(", "Decoder", ",", "Mips", "::", "CCRRegClassID", ",", "RegNo", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "Reg", ")", ")", ";", "return", "MCDisassembler", "::", "Success", ";" ]

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

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

[ "<STR_LIT>", ";" ]

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

[ "}" ]

[ "class", "NeonI_LDVList", "<", "bit", "q", ",", "bits", "<", "<NUM_LIT>", ">", "opcode", ",", "bits", "<", "<NUM_LIT>", ">", "size", ",", "RegisterOperand", "VecList", ",", "string", "asmop", ">", ":", "NeonI_LdStMult", "<", "q", ",", "<NUM_LIT>", ",", "opcode", ",", "size", ",", "(", "outs", "VecList", ":", "$", "Rt", ")", ",", "(", "ins", "GPR64xsp", ":", "$", "Rn", ")", ",", "asmop", "#", "<STR_LIT>", ",", "[", "]", ",", "NoItinerary", ">", "{", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "neverHasSideEffects", "=", "<NUM_LIT>", ";" ]

[ ")", ")" ]

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

[ "return", "Mov", ";" ]

[ "MachineInstrBuilder", "Mov", "=", "buildDefaultInstruction", "(", "*", "MBB", ",", "I", ",", "AMDGPU", "::", "MOV", ",", "AddrReg", ",", "ValueReg", ")", ".", "addReg", "(", "AMDGPU", "::", "AR_X", ",", "RegState", "::", "Implicit", "|", "RegState", "::", "Kill", ")", ";", "setImmOperand", "(", "Mov", ",", "AMDGPU", "::", "OpName", "::", "dst_rel", ",", "<NUM_LIT>", ")", ";" ]

[ ";" ]

[ "bool", "isMClass", "(", ")", "const", "{", "return", "IsMClass" ]