Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

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

[ "static", "void", "buildCluster", "(", "ArrayRef", "<", "SUnit", "*", ">", "Exports", ",", "ScheduleDAGInstrs", "*", "DAG", ")", "{", "SUnit", "*", "ChainHead", "=", "Exports", ".", "front", "(", ")", ";", "for", "(", "unsigned", "Idx", "=", "<NUM_LIT>", ",", "End", "=", "Exports", ".", "size", "(", ")", "-", "<NUM_LIT>", ";", "Idx", "<", "End", ";", "++", "Idx", ")", "{", "SUnit", "*", "SUa", "=", "Exports", "[", "Idx", "]", ";", "SUnit", "*", "SUb", "=", "Exports", "[", "Idx", "+", "<NUM_LIT>", "]", ";", "for", "(", "const", "SDep", "&", "Pred", ":", "SUb", "->", "Preds", ")", "{", "SUnit", "*", "PredSU", "=", "Pred", ".", "getSUnit" ]

[ "<FIXS>", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "<FIXE>" ]

[ "voidix86_expand_vector_init", "(", "bool", "mmx_ok", ",", "rtx", "target", ",", "rtx", "vals", ")", "{", "<BUGS>", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "enum", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "<BUGE>", "int", "n_elts", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "int", "n_var", "=", "<NUM_LIT>", ",", "one_var", "=", "-", "<NUM_LIT>", ";", "bool", "all_same", "=", "true", ",", "all_const_zero", "=", "true", ";" ]

[ "assert", "(", "MI", ".", "getOpcode", "(", ")", "==", "Z80", "::", "LD16ri", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "Z80", "::", "HL", "&&", "<STR_LIT>", "Constraints: EliminateFI", "<STR_LIT>", ")", ";" ]

[ "unsigned", "OpNo", "=", "FIOperandNum", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "int", "MinCSFI", "=", "<NUM_LIT>", ";", "int", "MaxCSFI", "=", "-", "<NUM_LIT>", ";", "if", "(", "CSI", ".", "size", "(", ")", ")", "{", "MinCSFI", "=", "CSI", "[", "<NUM_LIT>", "]", ".", "getFrameIdx", "(", ")", ";", "MaxCSFI", "=", "CSI", "[", "CSI", ".", "size", "(", ")", "-", "<NUM_LIT>", "]", ".", "getFrameIdx", "(", ")", ";", "}", "unsigned", "FrameReg", ";", "FrameReg", "=", "Z80", "::", "SP", ";", "int64_t", "Offset", ";", "bool", "IsKill", "=", "false", ";", "Offset", "=", "SPOffset", "+", "(", "int64_t", ")", "StackSize", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Offset : ", "<STR_LIT>", "<<", "Offset", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", "<<", "<STR_LIT>", "<--------->\\n", "<STR_LIT>", ")", ";", "const", "Z80InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "Z80InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MI", ".", "getOperand", "(", "OpNo", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";" ]

[ "<FIXS>", "return", "pa_output_bvb", "(", "operands", ",", "<NUM_LIT>", ",", "insn", ",", "<NUM_LIT>", ")", "<FIXE>" ]

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

[ "<FIXS>", "gcc_unreachable", "(", ")", ";", "<FIXE>" ]

[ "return", "offsets", "->", "saved_regs", "-", "offsets", "->", "saved_args", ";", "default", ":", "<BUGS>", "abort", "(", ")", ";", "<BUGE>", "}", "break", ";" ]

[ "?", "ParseField", "::", "end", ":", "ParseField", "::", "last0", ";" ]

[ "unsigned", "const", "ParseFieldOffset", "=", "<NUM_LIT>", ";", "ParseField", "Field", "=", "HexagonMCInstrInfo", "::", "isPacketEnd", "(", "HMI", ")" ]

[ "addOperandsForVFMK", "(", "Bl", ",", "MI", ",", "false", ")", ";" ]

[ "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "}", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "}", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "}", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "}", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "}", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "}", "}", ",", "}", ";", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "auto", "*", "Found", "=", "llvm", "::", "find_if", "(", "VFMKMap", ",", "[", "&", "]", "(", "auto", "P", ")", "{", "return", "P", ".", "first", "==", "Opcode", ";", "}", ")", ";", "if", "(", "Found", "==", "std", "::", "end", "(", "VFMKMap", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "unexpected opcode for pseudo vfmk", "<STR_LIT>", ")", ";", "unsigned", "OpcodeUpper", "=", "(", "*", "Found", ")", ".", "second", ".", "first", ";", "unsigned", "OpcodeLower", "=", "(", "*", "Found", ")", ".", "second", ".", "second", ";", "MachineBasicBlock", "*", "MBB", "=", "MI", ".", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "MachineInstrBuilder", "Bu", "=", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TI", ".", "get", "(", "OpcodeUpper", ")", ")", ";", "addOperandsForVFMK", "(", "Bu", ",", "MI", ",", "true", ")", ";", "MachineInstrBuilder", "Bl", "=", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TI", ".", "get", "(", "OpcodeLower", ")", ")", ";" ]

[ "case", "Intrinsic", "::", "dx_lerp", ":" ]

[ "case", "Intrinsic", "::", "exp", ":", "return", "expandExpIntrinsic", "(", "Orig", ")", ";", "case", "Intrinsic", "::", "log", ":", "return", "expandLogIntrinsic", "(", "Orig", ")", ";", "case", "Intrinsic", "::", "log10", ":", "return", "expandLog10Intrinsic", "(", "Orig", ")", ";", "case", "Intrinsic", "::", "pow", ":", "return", "expandPowIntrinsic", "(", "Orig", ")", ";", "case", "Intrinsic", "::", "dx_any", ":", "return", "expandAnyIntrinsic", "(", "Orig", ")", ";", "case", "Intrinsic", "::", "dx_uclamp", ":", "case", "Intrinsic", "::", "dx_clamp", ":", "return", "expandClampIntrinsic", "(", "Orig", ",", "F", ".", "getIntrinsicID", "(", ")", ")", ";" ]

[ "operands", "[", "<NUM_LIT>", "]", "=", "gen_reg_rtx", "(", "SImode", ")" ]

[ "(", "ashiftrt", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "CC_REGNUM", ")", ")", "]", ")", "]", "<STR_LIT>", "{", "operands", "[", "<NUM_LIT>", "]", "=", "gen_lowpart", "(", "SImode", ",", "operands", "[", "<NUM_LIT>", "]", ")" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m128d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_maskz_permute_pd", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m128d", "_", "_", "X", ",", "const", "int", "_", "_", "C", ")", "{", "return", "(", "_", "_", "m128d", ")", "_", "_", "builtin_ia32_vpermilpd_mask", "(", "(", "_", "_", "v2df", ")", "_", "_", "X", ",", "_", "_", "C", ",", "(", "_", "_", "v2df", ")", "_", "mm_avx512_setzero_pd", "(", ")", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

[ ";" ]

[ "while", "(", "rs", "<", "<NUM_LIT>", "&&", "call_used_regs", "[", "PR_REG", "(", "rs", ")", "]", ")", "rs", "++", ";", "if", "(", "rs", ">=", "<NUM_LIT>", ")", "break", ";", "for", "(", "re", "=", "rs", "+", "<NUM_LIT>", ";", "re", "<", "<NUM_LIT>", "&&", "!", "call_used_regs", "[", "PR_REG", "(", "re", ")", "]", ";", "re", "++", ")", "continue", ";", "if", "(", "out_state", "==", "<NUM_LIT>", ")", "{", "fputs", "(", "<STR_LIT>", "\\t.pred.safe_across_calls ", "<STR_LIT>", ",", "asm_out_file", ")", ";", "out_state", "=", "<NUM_LIT>" ]

[ "int", "frv_emit_movsi", "(", "rtx", "dest", ",", "rtx", "src", ")", "{", "int", "base_regno", "=", "-", "<NUM_LIT>", ";", "int", "unspec", "=", "<NUM_LIT>", ";", "rtx", "sym", "=", "src", ";", "struct", "frv_unspec", "old_unspec", ";", "if", "(", "!", "reload_in_progress", "&&", "!", "reload_completed", "&&", "!", "register_operand", "(", "dest", ",", "SImode", ")", "&&", "(", "!", "reg_or_0_operand", "(", "src", ",", "SImode", ")", "||", "(", "GET_CODE", "(", "src", ")", "==", "REG", "&&", "IN_RANGE", "(", "REGNO", "(", "src", ")", ",", "FIRST_VIRTUAL_REGISTER", ",", "LAST_VIRTUAL_POINTER_REGISTER", ")", ")", ")", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "copy_to_mode_reg", "(", "SImode", ",", "src", ")", ")", ")", ";", "return", "TRUE", ";", "}", "switch", "(", "GET_CODE", "(", "src", ")", ")", "{", "default", ":", "break", ";", "case", "LABEL_REF", ":", "handle_label", ":", "if", "(", "TARGET_FDPIC", ")", "{", "if", "(", "TARGET_GPREL_RO", ")", "unspec", "=", "R_FRV_GPREL12", ";", "else", "unspec", "=", "R_FRV_GOT12", ";", "}", "else", "if", "(", "flag_pic", ")", "base_regno", "=", "PIC_REGNO", ";", "break", ";", "case", "CONST", ":", "if", "(", "frv_const_unspec_p", "(", "src", ",", "&", "old_unspec", ")", ")", "break", ";", "if", "(", "TARGET_FDPIC", "&&", "frv_function_symbol_referenced_p", "(", "XEXP", "(", "src", ",", "<NUM_LIT>", ")", ")", ")", "{", "handle_whatever", ":", "src", "=", "force_reg", "(", "GET_MODE", "(", "XEXP", "(", "src", ",", "<NUM_LIT>", ")", ")", ",", "XEXP", "(", "src", ",", "<NUM_LIT>", ")", ")", ";", "emit_move_insn", "(", "dest", ",", "src", ")", ";", "return", "TRUE", ";", "}", "else", "{", "sym", "=", "XEXP", "(", "sym", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "sym", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "sym", ",", "<NUM_LIT>", ")", ")", "==", "SYMBOL_REF", "&&", "GET_CODE", "(", "XEXP", "(", "sym", ",", "<NUM_LIT>", ")", ")", "==", "CONST_INT", ")", "sym", "=", "XEXP", "(", "sym", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "sym", ")", "==", "SYMBOL_REF", ")", "goto", "handle_sym", ";", "else", "if", "(", "GET_CODE", "(", "sym", ")", "==", "LABEL_REF", ")", "goto", "handle_label", ";", "else", "goto", "handle_whatever", ";", "}", "break", ";", "case", "SYMBOL_REF", ":", "handle_sym", ":", "if", "(", "TARGET_FDPIC", ")", "{", "enum", "tls_model", "model", "=", "SYMBOL_REF_TLS_MODEL", "(", "sym", ")", ";", "if", "(", "model", "!=", "<NUM_LIT>", ")", "{", "src", "=", "frv_legitimize_tls_address", "(", "src", ",", "model", ")", ";", "emit_move_insn", "(", "dest", ",", "src", ")", ";", "return", "TRUE", ";", "}", "if", "(", "SYMBOL_REF_FUNCTION_P", "(", "sym", ")", ")", "{", "if", "(", "frv_local_funcdesc_p", "(", "sym", ")", ")", "unspec", "=", "R_FRV_FUNCDESC_GOTOFF12", ";", "else", "unspec", "=", "R_FRV_FUNCDESC_GOT12", ";", "}", "else", "{", "if", "(", "CONSTANT_POOL_ADDRESS_P", "(", "sym", ")", ")", "switch", "(", "GET_CODE", "(", "get_pool_constant", "(", "sym", ")", ")", ")", "{", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "if", "(", "flag_pic", ")", "{", "unspec", "=", "R_FRV_GOTOFF12", ";", "break", ";", "}", "default", ":", "if", "(", "TARGET_GPREL_RO", ")", "unspec", "=", "R_FRV_GPREL12", ";", "else", "unspec", "=", "R_FRV_GOT12", ";", "break", ";", "}", "else", "if", "(", "SYMBOL_REF_LOCAL_P", "(", "sym", ")", "&&", "!", "SYMBOL_REF_EXTERNAL_P", "(", "sym", ")", "&&", "SYMBOL_REF_DECL", "(", "sym", ")", "&&", "(", "!", "DECL_P", "(", "SYMBOL_REF_DECL", "(", "sym", ")", ")", "||", "!", "DECL_COMMON", "(", "SYMBOL_REF_DECL", "(", "sym", ")", ")", ")", ")", "{", "tree", "decl", "=", "SYMBOL_REF_DECL", "(", "sym", ")", ";", "tree", "init", "=", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "?", "DECL_INITIAL", "(", "decl", ")", ":", "TREE_CODE", "(", "decl", ")", "==", "CONSTRUCTOR", "?", "decl", ":", "<NUM_LIT>", ";", "int", "reloc", "=", "<NUM_LIT>", ";", "bool", "named_section", ",", "readonly", ";", "if", "(", "init", "&&", "init", "!=", "error_mark_node", ")", "reloc", "=", "compute_reloc_for_constant", "(", "init", ")", ";", "named_section", "=", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "lookup_attribute", "(", "<STR_LIT>", "section", "<STR_LIT>", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ";", "readonly", "=", "decl_readonly_section", "(", "decl", ",", "reloc", ")", ";", "if", "(", "named_section", ")", "unspec", "=", "R_FRV_GOT12", ";", "else", "if", "(", "!", "readonly", ")", "unspec", "=", "R_FRV_GOTOFF12", ";", "else", "if", "(", "readonly", "&&", "TARGET_GPREL_RO", ")", "unspec", "=", "R_FRV_GPREL12", ";", "else", "unspec", "=", "R_FRV_GOT12", ";", "}", "else", "unspec", "=", "R_FRV_GOT12", ";", "}", "}", "else", "if", "(", "SYMBOL_REF_SMALL_P", "(", "sym", ")", ")", "base_regno", "=", "SDA_BASE_REG", ";", "else", "if", "(", "flag_pic", ")", "base_regno", "=", "PIC_REGNO", ";", "break", ";", "}", "if", "(", "base_regno", ">=", "<NUM_LIT>", ")", "{", "if", "(", "GET_CODE", "(", "sym", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_SMALL_P", "(", "sym", ")", ")", "emit_insn", "(", "gen_symGOTOFF2reg", "(", "dest", ",", "src", ",", "gen_rtx_REG", "(", "Pmode", ",", "base_regno", ")", ",", "GEN_INT", "(", "R_FRV_GPREL12", ")", ")", ")", ";", "else", "emit_insn", "(", "gen_symGOTOFF2reg_hilo", "(", "dest", ",", "src", ",", "gen_rtx_REG", "(", "Pmode", ",", "base_regno", ")", ",", "GEN_INT", "(", "R_FRV_GPREL12", ")", ")", ")", ";", "if", "(", "base_regno", "==", "PIC_REGNO", ")", "crtl", "->", "uses_pic_offset_table", "=", "TRUE", ";", "return", "TRUE", ";", "}", "if", "(", "unspec", ")", "{", "rtx", "x", ";", "gcc_assert", "(", "!", "reload_in_progress", "&&", "!", "reload_completed", ")", ";", "switch", "(", "unspec", ")", "{", "case", "R_FRV_GOTOFF12", ":", "if", "(", "!", "frv_small_data_reloc_p", "(", "sym", ",", "unspec", ")", ")", "x", "=", "gen_symGOTOFF2reg_hilo", "(", "dest", ",", "src", ",", "OUR_FDPIC_REG", ",", "GEN_INT", "(", "unspec", ")", ")", ";", "else", "x", "=", "gen_symGOTOFF2reg", "(", "dest", ",", "src", ",", "OUR_FDPIC_REG", ",", "GEN_INT", "(", "unspec", ")", ")", ";", "break", ";", "case", "R_FRV_GPREL12", ":", "if", "(", "!", "frv_small_data_reloc_p", "(", "sym", ",", "unspec", ")", ")", "x", "=", "gen_symGPREL2reg_hilo", "(", "dest", ",", "src", ",", "OUR_FDPIC_REG", ",", "GEN_INT", "(", "unspec", ")", ")", ";", "else", "x", "=", "gen_symGPREL2reg", "(", "dest", ",", "src", ",", "OUR_FDPIC_REG", ",", "GEN_INT", "(", "unspec", ")", ")", ";", "break", ";", "case", "R_FRV_FUNCDESC_GOTOFF12", ":", "if", "(", "flag_pic", "!=", "<NUM_LIT>", ")", "x", "=", "gen_symGOTOFF2reg_hilo", "(", "dest", ",", "src", ",", "OUR_FDPIC_REG", ",", "GEN_INT", "(", "unspec", ")", ")", ";", "else", "x", "=", "gen_symGOTOFF2reg", "(", "dest", ",", "src", ",", "OUR_FDPIC_REG", ",", "GEN_INT", "(", "unspec", ")", ")", ";", "break", ";", "default", ":", "if", "(", "flag_pic", "!=", "<NUM_LIT>", ")", "x", "=", "gen_symGOT2reg_hilo", "(", "dest", ",", "src", ",", "OUR_FDPIC_REG", ",", "GEN_INT", "(", "unspec", ")", ")", ";", "else", "x", "=", "gen_symGOT2reg", "(", "dest", ",", "src", ",", "OUR_FDPIC_REG", ",", "GEN_INT", "(", "unspec", ")", ")", ";", "break", ";", "}", "emit_insn", "(", "x", ")", ";", "crtl", "->", "uses_pic_offset_table", "=", "TRUE", ";", "return", "TRUE", ";", "}", "return", "FALSE", ";", "}" ]

[ "Emit", "code", "to", "handle", "a", "MOVSI", ",", "adding", "in", "the", "small", "data", "register", "or", "pic", "register", "if", "needed", "to", "load", "up", "addresses", ".", "Return", "TRUE", "if", "the", "appropriate", "instructions", "are", "emitted", "." ]

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

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

[ "RC", ")", ")", "{" ]

[ "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "IsKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "}", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(" ]

[ "return", "*", "RM", ";" ]

[ "if", "(", "*", "RM", "==", "Reloc", "::", "ROPI", "||", "*", "RM", "==", "Reloc", "::", "RWPI", "||", "*", "RM", "==", "Reloc", "::", "ROPI_RWPI", ")", "assert", "(", "TT", ".", "isOSBinFormatELF", "(", ")", "&&", "<STR_LIT>", "ROPI/RWPI currently only supported for ELF", "<STR_LIT>", ")", ";", "if", "(", "*", "RM", "==", "Reloc", "::", "DynamicNoPIC", "&&", "!", "TT", ".", "isOSDarwin", "(", ")", ")", "return", "Reloc", "::", "Static", ";" ]

[ "<FIXS>", "setOperationAction", "(", "ShiftOp", ",", "MVT", "::", "i32", ",", "ShiftDoubleAction", ")", ";", "<FIXE>", "<FIXS>", "setOperationAction", "(", "ShiftOp", ",", "MVT", "::", "i64", ",", "ShiftDoubleAction", ")", ";", "<FIXE>" ]

[ "for", "(", "auto", "ShiftOp", ":", "{", "ISD", "::", "FSHL", ",", "ISD", "::", "FSHR", "}", ")", "{", "setOperationAction", "(", "ShiftOp", ",", "MVT", "::", "i16", ",", "Custom", ")", ";", "<BUGS>", "setOperationAction", "(", "ShiftOp", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "<BUGE>", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "<BUGS>", "setOperationAction", "(", "ShiftOp", ",", "MVT", "::", "i64", ",", "Custom", ")", ";", "<BUGE>", "}", "if", "(", "!", "Subtarget", ".", "useSoftFloat", "(", ")", ")", "{" ]

[ "}", "x", ";" ]

[ "union", "{", "qword", "q", ";", "double", "d", "[", "<NUM_LIT>", "]", ";" ]

[ "}" ]

[ "SS", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ";", "break", ";", "}", "}", "if", "(", "SS", "!=", "INT_MAX", ")", "break", ";", "}", "unsigned", "ConstPos", "=", "<NUM_LIT>", ";", "MachineInstr", "*", "ConstMI", "=", "nullptr", ";", "for", "(", "MachineInstr", "&", "MI", ":", "MF", ".", "front", "(", ")", ")", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "X86", "::", "MOV8mi", "&&", "SS", "==", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ")", "{", "ConstMI", "=", "&", "MI", ";", "break", ";", "}", "++", "ConstPos", ";", "}", "assert", "(", "ConstMI", "&&", "<STR_LIT>", "Cannot find an insertion point", "<STR_LIT>", ")", ";", "unsigned", "AMXRegNum", "=", "TRI", "->", "getRegClass", "(", "X86", "::", "TILERegClassID", ")", "->", "getNumRegs", "(", ")", ";", "SmallVector", "<", "Register", ",", "<NUM_LIT>", ">", "Phys2Virt", "(", "AMXRegNum", ",", "<NUM_LIT>", ")", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "MRI", ".", "getNumVirtRegs", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Register", "VirtReg", "=", "Register", "::", "index2VirtReg", "(", "I", ")", ";", "if", "(", "MRI", ".", "reg_nodbg_empty", "(", "VirtReg", ")", ")", "continue", ";", "if", "(", "MRI", ".", "getRegClass", "(", "VirtReg", ")", "->", "getID", "(", ")", "!=", "X86", "::", "TILERegClassID", ")", "continue", ";", "unsigned", "Index", "=", "VRM", ".", "getPhys", "(", "VirtReg", ")", "-", "X86", "::", "TMM0", ";", "if", "(", "!", "Phys2Virt", "[", "Index", "]", ")", "Phys2Virt", "[", "Index", "]", "=", "VirtReg", ";", "}", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ";", "I", "<", "AMXRegNum", ";", "++", "I", ")", "{", "if", "(", "!", "Phys2Virt", "[", "I", "]", ")", "continue", ";", "DebugLoc", "DL", ";", "bool", "IsRow", "=", "true", ";", "MachineInstr", "*", "NewMI", "=", "nullptr", ";", "ShapeT", "Shape", "=", "VRM", ".", "getShape", "(", "Phys2Virt", "[", "I", "]", ")", ";", "for", "(", "auto", "&", "R", ":", "{", "Shape", ".", "getRow", "(", ")", "->", "getReg", "(", ")", ",", "Shape", ".", "getCol", "(", ")", "->", "getReg", "(", ")", "}", ")", "{", "int64_t", "Imm", "=", "INT64_MAX", ";", "int", "Offset", "=", "IsRow", "?", "<NUM_LIT>", "+", "I", ":", "<NUM_LIT>", "+", "I", "*", "<NUM_LIT>", ";", "for", "(", "auto", "&", "DefMI", ":", "MRI", ".", "def_instructions", "(", "R", ")", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "DefMI", ".", "getParent", "(", ")", ";", "if", "(", "DefMI", ".", "isMoveImmediate", "(", ")", ")", "{", "if", "(", "Imm", "!=", "INT64_MAX", ")", "{", "assert", "(", "Imm", "==", "DefMI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "&&", "<STR_LIT>", "Cannot initialize with different shapes", "<STR_LIT>", ")", ";", "continue", ";", "}", "Imm", "=", "DefMI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "NewMI", "=", "addFrameReference", "(", "BuildMI", "(", "MF", ".", "front", "(", ")", ",", "++", "ConstMI", "->", "getIterator", "(", ")", ",", "DL", ",", "TII", "->", "get", "(", "IsRow", "?", "X86", "::", "MOV8mi", ":", "X86", "::", "MOV16mi", ")", ")", ",", "SS", ",", "Offset", ")", ".", "addImm", "(", "Imm", ")", ";", "ConstMI", "=", "NewMI", ";", "LIS", ".", "InsertMachineInstrInMaps", "(", "*", "NewMI", ")", ";", "}", "else", "{", "unsigned", "SubIdx", "=", "IsRow", "?", "X86", "::", "sub_8bit", ":", "X86", "::", "sub_16bit", ";", "unsigned", "RegSize", "=", "TRI", "->", "getRegSizeInBits", "(", "*", "MRI", ".", "getRegClass", "(", "R", ")", ")", ";", "if", "(", "(", "IsRow", "&&", "RegSize", "==", "<NUM_LIT>", ")", "||", "(", "!", "IsRow", "&&", "RegSize", "==", "<NUM_LIT>", ")", ")", "SubIdx", "=", "<NUM_LIT>", ";", "auto", "Iter", "=", "DefMI", ".", "getIterator", "(", ")", ";", "if", "(", "&", "MBB", "==", "&", "MF", ".", "front", "(", ")", "&&", "(", "unsigned", ")", "std", "::", "distance", "(", "MBB", ".", "instr_begin", "(", ")", ",", "Iter", ")", "<", "ConstPos", ")", "Iter", "=", "ConstMI", "->", "getIterator", "(", ")", ";", "NewMI", "=", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "++", "Iter", ",", "DL", ",", "TII", "->", "get", "(", "IsRow", "?", "X86", "::", "MOV8mr", ":", "X86", "::", "MOV16mr", ")", ")", ",", "SS", ",", "Offset", ")", ".", "addReg", "(", "R", ",", "<NUM_LIT>", ",", "SubIdx", ")", ";", "SlotIndex", "SIdx", "=", "LIS", ".", "InsertMachineInstrInMaps", "(", "*", "NewMI", ")", ";", "LIS", ".", "extendToIndices", "(", "LIS", ".", "getInterval", "(", "R", ")", ",", "{", "SIdx", ".", "getRegSlot", "(", ")", "}", ")", ";", "}" ]

[ ")", "{" ]

[ "bool", "Reg1IsKill", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isKill", "(", ")", ";", "bool", "Reg2IsKill", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isKill", "(", ")", ";", "bool", "ChangeReg0", "=", "false", ";", "if", "(", "Reg0", "==", "Reg1", ")", "{", "assert", "(", "MI", ".", "getDesc", "(", ")", ".", "getOperandConstraint", "(", "<NUM_LIT>", ",", "MCOI", "::", "TIED_TO", ")", "&&", "<STR_LIT>", "Expecting a two-address instruction!", "<STR_LIT>", ")", ";", "assert", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getSubReg", "(", ")", "==", "SubReg1", "&&", "<STR_LIT>", "Tied subreg mismatch", "<STR_LIT>", ")", ";", "Reg2IsKill", "=", "false", ";", "ChangeReg0", "=", "true", ";", "}", "unsigned", "MB", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "unsigned", "ME", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "if", "(", "MB", "==", "<NUM_LIT>", "&&", "ME", "==", "<NUM_LIT>", ")", "return", "nullptr", ";", "if", "(", "NewMI", ")", "{", "unsigned", "Reg0", "=", "ChangeReg0", "?", "Reg2", ":", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "bool", "Reg0IsDead", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isDead", "(", ")", ";", "return", "BuildMI", "(", "MF", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "MI", ".", "getDesc", "(", ")", ")", ".", "addReg", "(", "Reg0", ",", "RegState", "::", "Define", "|", "getDeadRegState", "(", "Reg0IsDead", ")", ")", ".", "addReg", "(", "Reg2", ",", "getKillRegState", "(", "Reg2IsKill", ")", ")", ".", "addReg", "(", "Reg1", ",", "getKillRegState", "(", "Reg1IsKill", ")", ")", ".", "addImm", "(", "(", "ME", "+", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", ".", "addImm", "(", "(", "MB", "-", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", ";", "}", "if", "(", "ChangeReg0" ]

[ "<FIXS>", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PARALLEL", ")", "<FIXE>", "<FIXS>", "gcc_assert", "(", "GET_CODE", "(", "addr", ")", "==", "SET", ")", ";", "<FIXE>" ]

[ "&&", "TARGET_PENTIUM", ")", "{", "addr", "=", "PATTERN", "(", "insn", ")", ";", "<BUGS>", "if", "(", "GET_CODE", "(", "addr", ")", "==", "SET", ")", ";", "else", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PARALLEL", "&&", "GET_CODE", "(", "XVECEXP", "(", "addr", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "==", "SET", ")", "<BUGE>", "addr", "=", "XVECEXP", "(", "addr", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "<BUGS>", "elseabort", "(", ")", ";", "<BUGE>", "addr", "=", "SET_SRC", "(", "addr", ")", ";", "}", "else" ]

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

[ "def", "A2_psubf", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "IntRegs", ":", "$", "Rt32", ",", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_4c5ba658", ",", "TypeALU32_3op", ">", ",", "Enc_9b0bc1", ",", "PredNewRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-" ]

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

[ "return", "_", "_", "builtin_mve_vornq_m_sv16qi", "(", "_", "_", "inactive", ",", "_", "_", "a" ]

[ "[", "]", ">", ",", "Requires", "<", "[", "In64BitMode", "]", ">", ";" ]

[ "def", "RCL64mCL", ":", "RI", "<", "<NUM_LIT>", ",", "MRM2m", ",", "(", "outs", ")", ",", "(", "ins", "i64mem", ":", "$", "dst", ")", ",", "<STR_LIT>", "," ]

[ "<FIXS>", "lowerMSASplatImm", "(", "Op", ",", "<NUM_LIT>", ",", "DAG", ",", "true", ")", ",", "ISD", "::", "SETEQ", ")", ";", "<FIXE>" ]

[ "case", "Intrinsic", "::", "mips_ceqi_w", ":", "case", "Intrinsic", "::", "mips_ceqi_d", ":", "return", "DAG", ".", "getSetCC", "(", "DL", ",", "Op", "->", "getValueType", "(", "<NUM_LIT>", ")", ",", "Op", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "<BUGS>", "lowerMSASplatImm", "(", "Op", ",", "<NUM_LIT>", ",", "DAG", ")", ",", "ISD", "::", "SETEQ", ")", ";", "<BUGE>", "case", "Intrinsic", "::", "mips_cle_s_b", ":", "case", "Intrinsic", "::", "mips_cle_s_h", ":", "case", "Intrinsic", "::", "mips_cle_s_w", ":" ]

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

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

[ "auto", "*", "DRC", "=", "getFinalVRegClass", "(", "RD", ",", "MRI", ")", ";" ]

[ "bool", "HexagonBitSimplify", "::", "isTransparentCopy", "(", "const", "BitTracker", "::", "RegisterRef", "&", "RD", ",", "const", "BitTracker", "::", "RegisterRef", "&", "RS", ",", "MachineRegisterInfo", "&", "MRI", ")", "{", "if", "(", "!", "Register", "::", "isVirtualRegister", "(", "RD", ".", "Reg", ")", "||", "!", "Register", "::", "isVirtualRegister", "(", "RS", ".", "Reg", ")", ")", "return", "false", ";" ]

[ "Results", ".", "push_back", "(", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "SL", ",", "MVT", "::", "v2f16", ",", "Op", ")", ")", ";" ]

[ "Results", ".", "push_back", "(", "Res", ".", "getOperand", "(", "I", ")", ")", ";", "}", "}", "else", "{", "Results", ".", "push_back", "(", "Res", ")", ";", "Results", ".", "push_back", "(", "Res", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "}", "return", ";", "}", "break", ";", "}", "case", "ISD", "::", "SELECT", ":", "{", "SDLoc", "SL", "(", "N", ")", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "EVT", "NewVT", "=", "getEquivalentMemType", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "VT", ")", ";", "SDValue", "LHS", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "SL", ",", "NewVT", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "RHS", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "SL", ",", "NewVT", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "EVT", "SelectVT", "=", "NewVT", ";", "if", "(", "NewVT", ".", "bitsLT", "(", "MVT", "::", "i32", ")", ")", "{", "LHS", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "SL", ",", "MVT", "::", "i32", ",", "LHS", ")", ";", "RHS", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "SL", ",", "MVT", "::", "i32", ",", "RHS", ")", ";", "SelectVT", "=", "MVT", "::", "i32", ";", "}", "SDValue", "NewSelect", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SELECT", ",", "SL", ",", "SelectVT", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "LHS", ",", "RHS", ")", ";", "if", "(", "NewVT", "!=", "SelectVT", ")", "NewSelect", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "SL", ",", "NewVT", ",", "NewSelect", ")", ";", "Results", ".", "push_back", "(", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "SL", ",", "VT", ",", "NewSelect", ")", ")", ";", "return", ";", "}", "case", "ISD", "::", "FNEG", ":", "{", "if", "(", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", "!=", "MVT", "::", "v2f16", ")", "break", ";", "SDLoc", "SL", "(", "N", ")", ";", "SDValue", "BC", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "SL", ",", "MVT", "::", "i32", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "Op", "=", "DAG", ".", "getNode", "(", "ISD", "::", "XOR", ",", "SL", ",", "MVT", "::", "i32", ",", "BC", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "SL", ",", "MVT", "::", "i32", ")", ")", ";", "Results", ".", "push_back", "(", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "SL", ",", "MVT", "::", "v2f16", ",", "Op", ")", ")", ";", "return", ";", "}", "case", "ISD", "::", "FABS", ":", "{", "if", "(", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", "!=", "MVT", "::", "v2f16", ")", "break", ";", "SDLoc", "SL", "(", "N", ")", ";", "SDValue", "BC", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "SL", ",", "MVT", "::", "i32", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "Op", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "SL", ",", "MVT", "::", "i32", ",", "BC", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "SL", ",", "MVT", "::", "i32", ")", ")", ";" ]

[ "(", "not", ":", "BOOL_128", "(", "match_operand", ":", "BOOL_128", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", "]" ]

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

[ ">", ",", "BinaryIntInt", ";" ]

[ "def", "int_AMDIL_mulhi24_u32", ":", "GCCBuiltin", "<", "<STR_LIT>" ]

[ "}" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected condition code", "<STR_LIT>", ")", ";" ]

[ ")", ",", "(", "LDRDui", "GPR64sp", ":", "$", "Rn", ",", "uimm12s8", ":", "$", "offset", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v8i8", "(", "load", "(", "am_indexed64", "GPR64sp", ":", "$", "Rn", ",", "uimm12s8", ":", "$", "offset", ")", ")" ]

[ "return", "ret", ";" ]

[ "_", "_", "builtin_aarch64_simd_ci", "_", "_", "o", ";", "_", "_", "o", "=", "_", "_", "builtin_aarch64_ld3v2si", "(", "(", "const", "_", "_", "builtin_aarch64_simd_si", "*", ")", "_", "_", "a", ")", ";", "ret", ".", "val", "[", "<NUM_LIT>", "]", "=", "(", "uint32x2_t", ")", "_", "_", "builtin_aarch64_get_dregciv2si", "(", "_", "_", "o", ",", "<NUM_LIT>", ")", ";", "ret", ".", "val", "[", "<NUM_LIT>", "]", "=", "(", "uint32x2_t", ")", "_", "_", "builtin_aarch64_get_dregciv2si", "(", "_", "_", "o", ",", "<NUM_LIT>", ")", ";", "ret", ".", "val", "[", "<NUM_LIT>", "]", "=", "(", "uint32x2_t", ")", "_", "_", "builtin_aarch64_get_dregciv2si", "(", "_", "_", "o", ",", "<NUM_LIT>", ")", ";" ]

[ "<NUM_LIT>", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "zero_extract", ":", "QI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int" ]

[ "true", ";" ]

[ "default", ":", "return", "false", ";", "case", "Hexagon", "::", "L2_ploadrdt_io", ":", "case", "Hexagon", "::", "L2_ploadrdf_io", ":", "case", "Hexagon", "::", "L2_ploadrit_io", ":", "case", "Hexagon", "::", "L2_ploadrif_io", ":", "case", "Hexagon", "::", "L2_ploadrht_io", ":", "case", "Hexagon", "::", "L2_ploadrhf_io", ":", "case", "Hexagon", "::", "L2_ploadrbt_io", ":", "case", "Hexagon", "::", "L2_ploadrbf_io", ":", "case", "Hexagon", "::", "L2_ploadruht_io", ":", "case", "Hexagon", "::", "L2_ploadruhf_io", ":", "case", "Hexagon", "::", "L2_ploadrubt_io", ":", "case", "Hexagon", "::", "L2_ploadrubf_io", ":", "case", "Hexagon", "::", "L2_ploadrdt_pi", ":", "case", "Hexagon", "::", "L2_ploadrdf_pi", ":", "case", "Hexagon", "::", "L2_ploadrit_pi", ":", "case", "Hexagon", "::", "L2_ploadrif_pi", ":", "case", "Hexagon", "::", "L2_ploadrht_pi", ":", "case", "Hexagon", "::", "L2_ploadrhf_pi", ":", "case", "Hexagon", "::", "L2_ploadrbt_pi", ":", "case", "Hexagon", "::", "L2_ploadrbf_pi", ":", "case", "Hexagon", "::", "L2_ploadruht_pi", ":", "case", "Hexagon", "::", "L2_ploadruhf_pi", ":", "case", "Hexagon", "::", "L2_ploadrubt_pi", ":", "case", "Hexagon", "::", "L2_ploadrubf_pi", ":", "case", "Hexagon", "::", "L4_ploadrdt_rr", ":", "case", "Hexagon", "::", "L4_ploadrdf_rr", ":", "case", "Hexagon", "::", "L4_ploadrbt_rr", ":", "case", "Hexagon", "::", "L4_ploadrbf_rr", ":", "case", "Hexagon", "::", "L4_ploadrubt_rr", ":", "case", "Hexagon", "::", "L4_ploadrubf_rr", ":", "case", "Hexagon", "::", "L4_ploadrht_rr", ":", "case", "Hexagon", "::", "L4_ploadrhf_rr", ":", "case", "Hexagon", "::", "L4_ploadruht_rr", ":", "case", "Hexagon", "::", "L4_ploadruhf_rr", ":", "case", "Hexagon", "::", "L4_ploadrit_rr", ":", "case", "Hexagon", "::", "L4_ploadrif_rr", ":", "return" ]

[ "<STR_LIT>" ]

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

[ "<FIXS>", "let", "ElementSize", "=", "Sz", ";", "<FIXE>" ]

[ "let", "Constraints", "=", "<STR_LIT>", ";", "let", "DestructiveInstType", "=", "DestructiveOther", ";", "<BUGS>", "let", "ElementSize", "=", "size", ";", "<BUGE>", "}", "multiclass", "sve_fp_2op_p_zd", "bits", "<NUM_LIT>", ">", "opc", ",", "string", "asm", "," ]

[ "v", ")", "{" ]

[ "static", "bool", "xtensa_uimm8", "(", "HOST_WIDE_INT" ]

[ "bool", "X86InstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "bool", "HasAVX", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "hasAVX", "(", ")", ";", "MachineInstrBuilder", "MIB", "(", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "X86", "::", "SETB_C8r", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "SBB8rr", ")", ")", ";", "case", "X86", "::", "SETB_C16r", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "SBB16rr", ")", ")", ";", "case", "X86", "::", "SETB_C32r", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "SBB32rr", ")", ")", ";", "case", "X86", "::", "SETB_C64r", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "SBB64rr", ")", ")", ";", "case", "X86", "::", "V_SET0", ":", "case", "X86", "::", "FsFLD0SS", ":", "case", "X86", "::", "FsFLD0SD", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "HasAVX", "?", "X86", "::", "VXORPSrr", ":", "X86", "::", "XORPSrr", ")", ")", ";", "case", "X86", "::", "AVX_SET0", ":", "assert", "(", "HasAVX", "&&", "<STR_LIT>", "AVX not supported", "<STR_LIT>", ")", ";", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "VXORPSYrr", ")", ")", ";", "case", "X86", "::", "AVX512_512_SET0", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "VPXORDZrr", ")", ")", ";", "case", "X86", "::", "V_SETALLONES", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "HasAVX", "?", "X86", "::", "VPCMPEQDrr", ":", "X86", "::", "PCMPEQDrr", ")", ")", ";", "case", "X86", "::", "AVX2_SETALLONES", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "VPCMPEQDYrr", ")", ")", ";", "case", "X86", "::", "TEST8ri_NOREX", ":", "MI", "->", "setDesc", "(", "get", "(", "X86", "::", "TEST8ri", ")", ")", ";", "return", "true", ";", "case", "X86", "::", "KSET0W", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "KXORWrr", ")", ")", ";", "case", "X86", "::", "KSET1B", ":", "case", "X86", "::", "KSET1W", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "KXNORWrr", ")", ")", ";", "}", "return", "false", ";", "}" ]

[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]

[ "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "<STR_LIT>", "Mips Delay Slot Filler", "<STR_LIT>", ";", "}" ]

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

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

[ "(", "zero_extend", ":", "PSI", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "]", "{", "operands", "[", "<NUM_LIT>", "]", "=", "simplify_gen_subreg", "(", "HImode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "PSImode", ",", "<NUM_LIT>", ")" ]

[ "}" ]

[ "class", "isModifierType", "<", "ValueType", "SrcVT", ">", "{", "bit", "ret", "=", "!", "if", "(", "!", "eq", "(", "SrcVT", ".", "Value", ",", "f16", ".", "Value", ")", ",", "<NUM_LIT>", ",", "!", "if", "(", "!", "eq", "(", "SrcVT", ".", "Value", ",", "f32", ".", "Value", ")", ",", "<NUM_LIT>", ",", "!", "if", "(", "!", "eq", "(", "SrcVT", ".", "Value", ",", "f64", ".", "Value", ")", ",", "<NUM_LIT>", ",", "!", "if", "(", "!", "eq", "(", "SrcVT", ".", "Value", ",", "v2f16", ".", "Value", ")", ",", "<NUM_LIT>", ",", "!", "if", "(", "!", "eq", "(", "SrcVT", ".", "Value", ",", "v2i16", ".", "Value", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ")", ")", ")", ";" ]

[ "OpcodeIndex", "]", ":" ]

[ "SDValue", "MemAddr", ",", "Align", ";", "unsigned", "AddrOpIdx", "=", "isUpdating", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "if", "(", "!", "SelectAddrMode6", "(", "N", ",", "N", "->", "getOperand", "(", "AddrOpIdx", ")", ",", "MemAddr", ",", "Align", ")", ")", "return", "NULL", ";", "SDValue", "Chain", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "bool", "is64BitVector", "=", "VT", ".", "is64BitVector", "(", ")", ";", "Align", "=", "GetVLDSTAlign", "(", "Align", ",", "NumVecs", ",", "is64BitVector", ")", ";", "unsigned", "OpcodeIndex", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "unhandled vld type", "<STR_LIT>", ")", ";", "case", "MVT", "::", "v8i8", ":", "OpcodeIndex", "=", "<NUM_LIT>", ";", "break", ";", "case", "MVT", "::", "v4i16", ":", "OpcodeIndex", "=", "<NUM_LIT>", ";", "break", ";", "case", "MVT", "::", "v2f32", ":", "case", "MVT", "::", "v2i32", ":", "OpcodeIndex", "=", "<NUM_LIT>", ";", "break", ";", "case", "MVT", "::", "v1i64", ":", "OpcodeIndex", "=", "<NUM_LIT>", ";", "break", ";", "case", "MVT", "::", "v16i8", ":", "OpcodeIndex", "=", "<NUM_LIT>", ";", "break", ";", "case", "MVT", "::", "v8i16", ":", "OpcodeIndex", "=", "<NUM_LIT>", ";", "break", ";", "case", "MVT", "::", "v4f32", ":", "case", "MVT", "::", "v4i32", ":", "OpcodeIndex", "=", "<NUM_LIT>", ";", "break", ";", "case", "MVT", "::", "v2i64", ":", "OpcodeIndex", "=", "<NUM_LIT>", ";", "assert", "(", "NumVecs", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "v2i64 type only supported for VLD1", "<STR_LIT>", ")", ";", "break", ";", "}", "EVT", "ResTy", ";", "if", "(", "NumVecs", "==", "<NUM_LIT>", ")", "ResTy", "=", "VT", ";", "else", "{", "unsigned", "ResTyElts", "=", "(", "NumVecs", "==", "<NUM_LIT>", ")", "?", "<NUM_LIT>", ":", "NumVecs", ";", "if", "(", "!", "is64BitVector", ")", "ResTyElts", "*=", "<NUM_LIT>", ";", "ResTy", "=", "EVT", "::", "getVectorVT", "(", "*", "CurDAG", "->", "getContext", "(", ")", ",", "MVT", "::", "i64", ",", "ResTyElts", ")", ";", "}", "std", "::", "vector", "<", "EVT", ">", "ResTys", ";", "ResTys", ".", "push_back", "(", "ResTy", ")", ";", "if", "(", "isUpdating", ")", "ResTys", ".", "push_back", "(", "MVT", "::", "i32", ")", ";", "ResTys", ".", "push_back", "(", "MVT", "::", "Other", ")", ";", "SDValue", "Pred", "=", "getAL", "(", "CurDAG", ")", ";", "SDValue", "Reg0", "=", "CurDAG", "->", "getRegister", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ";", "SDNode", "*", "VLd", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Ops", ";", "if", "(", "is64BitVector", "||", "NumVecs", "<=", "<NUM_LIT>", ")", "{", "unsigned", "Opc", "=", "(", "is64BitVector", "?", "DOpcodes", "[" ]

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

[ "let", "OutOperandList", "=", "(", "outs", "IRF", ":", "$", "dest", ")", ";", "let", "InOperandList", "=", "(", "ins", "IRF", ":", "$", "src1", ",", "SRF", ":", "$", "src2", ",", "SwitchSet", ":", "$", "sw", ",", "IRF", ":", "$", "income", ",", "SPred", ":", "$", "pred", ")", ";", "let", "Pattern", "=", "pattern", ";", "let", "Itinerary", "=", "IIC_LoadScalLocal", ";", "let", "isNotUsedInDisasm", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "dest", ";", "bits", "<", "<NUM_LIT>", ">", "src1", ";", "bits", "<", "<NUM_LIT>", ">", "src2", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "SrcA", "=", "src1", ";", "let", "SrcExtra", "=", "src2", ";", "let", "Dest", "=", "dest", ";", "let", "Switches", "=", "sw", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "VectorPred", "=", "<NUM_LIT>", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";", "let", "OutOfSlotData", "=", "<NUM_LIT>", ";", "let", "Constraints" ]

[ "void", "ARMTargetLowering", "::", "LowerAsmOperandForConstraint", "(", "SDValue", "Op", ",", "char", "Constraint", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "Ops", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Result", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "switch", "(", "Constraint", ")", "{", "default", ":", "break", ";", "case", "'", "I", "'", ":", "case", "'", "J", "'", ":", "case", "'", "K", "'", ":", "case", "'", "L", "'", ":", "case", "'", "M", "'", ":", "case", "'", "N", "'", ":", "case", "'", "O", "'", ":", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ";", "if", "(", "!", "C", ")", "return", ";", "int64_t", "CVal64", "=", "C", "->", "getSExtValue", "(", ")", ";", "int", "CVal", "=", "(", "int", ")", "CVal64", ";", "if", "(", "CVal", "!=", "CVal64", ")", "return", ";", "switch", "(", "Constraint", ")", "{", "case", "'", "I", "'", ":", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "{", "if", "(", "CVal", ">=", "<NUM_LIT>", "&&", "CVal", "<=", "<NUM_LIT>", ")", "break", ";", "}", "else", "if", "(", "Subtarget", "->", "isThumb2", "(", ")", ")", "{", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "CVal", ")", "!=", "-", "<NUM_LIT>", ")", "break", ";", "}", "else", "{", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "CVal", ")", "!=", "-", "<NUM_LIT>", ")", "break", ";", "}", "return", ";", "case", "'", "J", "'", ":", "if", "(", "Subtarget", "->", "isThumb", "(", ")", ")", "{", "if", "(", "CVal", ">=", "-", "<NUM_LIT>", "&&", "CVal", "<=", "-", "<NUM_LIT>", ")", "break", ";", "}", "else", "{", "if", "(", "CVal", ">=", "-", "<NUM_LIT>", "&&", "CVal", "<=", "<NUM_LIT>", ")", "break", ";", "}", "return", ";", "case", "'", "K", "'", ":", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "{", "if", "(", "CVal", "!=", "<NUM_LIT>", "&&", "<STR_LIT>", "::", "<STR_LIT>", "(", "CVal", ")", ")", "break", ";", "}", "else", "if", "(", "Subtarget", "->", "isThumb2", "(", ")", ")", "{", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "~", "CVal", ")", "!=", "-", "<NUM_LIT>", ")", "break", ";", "}", "else", "{", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "~", "CVal", ")", "!=", "-", "<NUM_LIT>", ")", "break", ";", "}", "return", ";", "case", "'", "L", "'", ":", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "{", "if", "(", "CVal", ">=", "-", "<NUM_LIT>", "&&", "CVal", "<", "<NUM_LIT>", ")", "break", ";", "}", "else", "if", "(", "Subtarget", "->", "isThumb2", "(", ")", ")", "{", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "-", "CVal", ")", "!=", "-", "<NUM_LIT>", ")", "break", ";", "}", "else", "{", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "-", "CVal", ")", "!=", "-", "<NUM_LIT>", ")", "break", ";", "}", "return", ";", "case", "'", "M", "'", ":", "if", "(", "Subtarget", "->", "isThumb", "(", ")", ")", "{", "if", "(", "(", "CVal", ">=", "<NUM_LIT>", "&&", "CVal", "<=", "<NUM_LIT>", ")", "&&", "(", "(", "CVal", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", ")", "break", ";", "}", "else", "{", "if", "(", "(", "CVal", ">=", "<NUM_LIT>", "&&", "CVal", "<=", "<NUM_LIT>", ")", "||", "(", "(", "CVal", "&", "(", "CVal", "-", "<NUM_LIT>", ")", ")", "==", "<NUM_LIT>", ")", ")", "break", ";", "}", "return", ";", "case", "'", "N", "'", ":", "if", "(", "Subtarget", "->", "isThumb", "(", ")", ")", "{", "if", "(", "CVal", ">=", "<NUM_LIT>", "&&", "CVal", "<=", "<NUM_LIT>", ")", "break", ";", "}", "return", ";", "case", "'", "O", "'", ":", "if", "(", "Subtarget", "->", "isThumb", "(", ")", ")", "{", "if", "(", "(", "CVal", ">=", "-", "<NUM_LIT>", "&&", "CVal", "<=", "<NUM_LIT>", ")", "&&", "(", "(", "CVal", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", ")", "break", ";", "}", "return", ";", "}", "Result", "=", "DAG", ".", "getTargetConstant", "(", "CVal", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "}", "if", "(", "Result", ".", "getNode", "(", ")", ")", "{", "Ops", ".", "push_back", "(", "Result", ")", ";", "return", ";", "}", "return", "TargetLowering", "::", "LowerAsmOperandForConstraint", "(", "Op", ",", "Constraint", ",", "Ops", ",", "DAG", ")", ";", "}" ]

[ "Lower", "the", "specified", "operand", "into", "the", "Ops", "vector", "." ]

[ "(", "*", "this", ")", ";" ]

[ "MachineFunctionInfo", "*", "M68kMachineFunctionInfo", "::", "clone", "(", "BumpPtrAllocator", "&", "Allocator", ",", "MachineFunction", "&", "DestMF", ",", "const", "DenseMap", "<", "MachineBasicBlock", "*", ",", "MachineBasicBlock", "*", ">", "&", "Src2DstMBB", ")", "const", "{", "return", "DestMF", ".", "cloneInfo", "<", "M68kMachineFunctionInfo", ">" ]

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

[ "vrsqrteh_f16", "(", "float16_t", "_", "_", "a", ")", "{", "return", "_", "_", "builtin_aarch64_rsqrtehf", "(", "_", "_" ]

[ "}" ]

[ "void", "BlackfinInstrInfo", "::", "storeRegToAddr", "(", "MachineFunction", "&", "MF", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Addr", ",", "const", "TargetRegisterClass", "*", "RC", ",", "SmallVectorImpl", "<", "MachineInstr", "*", ">", "&", "NewMIs", ")", "const", "{", "llvm_unreachable", "(", "<STR_LIT>", "storeRegToAddr not implemented", "<STR_LIT>", ")", ";" ]

[ "Kind", ",", "Mang", ",", "TM", ")", ";" ]

[ "if", "(", "Kind", ".", "isData", "(", ")", "&&", "IsGlobalInSmallSection", "(", "GV", ",", "TM", ",", "Kind", ")", ")", "return", "SmallDataSection", ";", "return", "TargetLoweringObjectFileELF", "::", "SelectSectionForGlobal", "(", "GV", "," ]

[ ")" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "clobber", "(", "const_int", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

[ "I", ".", "removeOperand", "(", "<NUM_LIT>", ")", ";" ]

[ "}", "if", "(", "TM", ".", "getCodeModel", "(", ")", "!=", "CodeModel", "::", "Small", ")", "return", "false", ";", "X86AddressMode", "AM", ";", "AM", ".", "GV", "=", "GV", ";", "AM", ".", "GVOpFlags", "=", "STI", ".", "classifyGlobalReference", "(", "GV", ")", ";", "if", "(", "isGlobalStubReference", "(", "AM", ".", "GVOpFlags", ")", ")", "return", "false", ";", "if", "(", "isGlobalRelativeToPICBase", "(", "AM", ".", "GVOpFlags", ")", ")", "return", "false", ";", "if", "(", "STI", ".", "isPICStyleRIPRel", "(", ")", ")", "{", "assert", "(", "AM", ".", "Base", ".", "Reg", "==", "<NUM_LIT>", "&&", "AM", ".", "IndexReg", "==", "<NUM_LIT>", ")", ";", "AM", ".", "Base", ".", "Reg", "=", "X86", "::", "RIP", ";", "}", "const", "Register", "DefReg", "=", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "LLT", "Ty", "=", "MRI", ".", "getType", "(", "DefReg", ")", ";", "unsigned", "NewOpc", "=", "getLeaOP", "(", "Ty", ",", "STI", ")", ";", "I", ".", "setDesc", "(", "TII", ".", "get", "(", "NewOpc", ")", ")", ";", "MachineInstrBuilder", "MIB", "(", "MF", ",", "I", ")", ";" ]

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

[ "bool", "evaluateBranch", "(", "const", "MCInst", "&", "Inst", ",", "uint64_t", "Addr", ",", "uint64_t", "Size", ",", "uint64_t", "&", "Target", ")", "const", "override", "{", "if", "(", "Info", "->", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ".", "OpInfo", "[", "<NUM_LIT>", "]", ".", "OperandType", "!=", "MCOI", "::", "OPERAND_PCREL", ")", "return", "false", ";", "int64_t", "Imm", "=", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "Target", "=", "Addr", "+", "Imm", "+", "<NUM_LIT>", ";" ]

[ "FormalArgHandler", "ArgHandler", "(", "MIRBuilder", ",", "MRI", ")", ";" ]

[ "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "auto", "&", "DL", "=", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "auto", "&", "TLI", "=", "*", "getTLI", "<", "M68kTargetLowering", ">", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "<NUM_LIT>", ">", "SplitArgs", ";", "unsigned", "I", "=", "<NUM_LIT>", ";", "for", "(", "const", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "ArgInfo", "OrigArg", "{", "VRegs", "[", "I", "]", ",", "Arg", ".", "getType", "(", ")", ",", "I", "}", ";", "setArgFlags", "(", "OrigArg", ",", "I", "+", "AttributeList", "::", "FirstArgIndex", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ",", "F", ".", "getCallingConv", "(", ")", ")", ";", "++", "I", ";", "}", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "getCCAssignFn", "(", "F", ".", "getCallingConv", "(", ")", ",", "false", ",", "F", ".", "isVarArg", "(", ")", ")", ";", "IncomingValueAssigner", "ArgAssigner", "(", "AssignFn", ")", ";" ]

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

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

[ "}", ";" ]

[ "class", "BaseSIMDDifferentThreeVector", "<", "bit", "U", ",", "bits", "<", "<NUM_LIT>", ">", "size", ",", "bits", "<", "<NUM_LIT>", ">", "opcode", ",", "RegisterOperand", "outtype", ",", "RegisterOperand", "intype1", ",", "RegisterOperand", "intype2", ",", "string", "asm", ",", "string", "outkind", ",", "string", "inkind1", ",", "string", "inkind2", ",", "list", "<", "dag", ">", "pattern", ">", ":", "I", "<", "(", "outs", "outtype", ":", "$", "Rd", ")", ",", "(", "ins", "intype1", ":", "$", "Rn", ",", "intype2", ":", "$", "Rm", ")", ",", "asm", ",", "<STR_LIT>", "#", "outkind", "#", "<STR_LIT>", "#", "inkind1", "#", "<STR_LIT>", "#", "inkind2", "#", "<STR_LIT>", "#", "outkind", "#", "<STR_LIT>", ",", "<STR_LIT>", ",", "pattern", ">", ",", "Sched", "<", "[", "WriteVq", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "size", "{", "<NUM_LIT>" ]

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

[ "(", "parallel", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "]", ")", ")", ")", "(", "match_operand", ":", "VDQF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VDQF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{", "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "ENDIAN_LANE_N", "(", "<", "MODE", ">", "mode", ",", "INTVAL", "(", "operands", "[" ]

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

[ "arm_simd_types", "[", "Int8x16_t", "]", ".", "eltype", "=", "intQI_type_node", ";", "arm_simd_types", "[", "Int16x4_t", "]", ".", "eltype", "=", "intHI_type_node", ";", "arm_simd_types", "[", "Int16x8_t", "]", ".", "eltype", "=", "intHI_type_node", ";", "arm_simd_types", "[", "Int32x2_t", "]", ".", "eltype", "=", "intSI_type_node", ";", "arm_simd_types", "[", "Int32x4_t", "]", ".", "eltype", "=", "intSI_type_node", ";", "arm_simd_types", "[", "Int64x2_t", "]", ".", "eltype", "=", "intDI_type_node", ";", "arm_simd_types", "[", "Uint8x8_t", "]", ".", "eltype", "=", "unsigned_intQI_type_node", ";", "arm_simd_types", "[", "Uint8x16_t", "]", ".", "eltype", "=", "unsigned_intQI_type_node", ";", "arm_simd_types", "[", "Uint16x4_t", "]", ".", "eltype", "=", "unsigned_intHI_type_node", ";", "arm_simd_types", "[", "Uint16x8_t", "]", ".", "eltype", "=", "unsigned_intHI_type_node", ";", "arm_simd_types", "[", "Uint32x2_t", "]", ".", "eltype", "=", "unsigned_intSI_type_node", ";", "arm_simd_types", "[", "Uint32x4_t", "]", ".", "eltype", "=", "unsigned_intSI_type_node", ";", "arm_simd_types", "[", "Uint64x2_t", "]", ".", "eltype", "=", "unsigned_intDI_type_node", ";", "arm_simd_types", "[", "Poly8x8_t", "]", ".", "eltype", "=", "arm_simd_polyQI_type_node", ";", "arm_simd_types", "[", "Poly8x16_t", "]", ".", "eltype", "=", "arm_simd_polyQI_type_node", ";", "arm_simd_types", "[", "Poly16x4_t", "]", ".", "eltype", "=", "arm_simd_polyHI_type_node", ";", "arm_simd_types", "[", "Poly16x8_t", "]", ".", "eltype", "=", "arm_simd_polyHI_type_node", ";", "arm_simd_types", "[", "Float16x4_t", "]", ".", "eltype", "=", "arm_fp16_type_node", ";", "arm_simd_types", "[", "Float16x8_t", "]", ".", "eltype", "=", "arm_fp16_type_node", ";", "arm_simd_types", "[", "Float32x2_t", "]", ".", "eltype", "=", "float_type_node", ";", "arm_simd_types", "[", "Float32x4_t", "]", ".", "eltype", "=", "float_type_node", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "nelts", ";", "i", "++", ")", "{", "tree", "eltype", "=", "arm_simd_types", "[", "i", "]", ".", "eltype", ";", "machine_mode", "mode", "=", "arm_simd_types", "[", "i", "]", ".", "mode", ";", "if", "(", "arm_simd_types", "[", "i", "]", ".", "itype", "==", "NULL", ")", "arm_simd_types", "[", "i", "]", ".", "itype", "=", "build_distinct_type_copy", "(", "build_vector_type", "(", "eltype", ",", "GET_MODE_NUNITS", "(", "mode", ")", ")", ")", ";", "tdecl", "=", "add_builtin_type", "(", "arm_simd_types", "[", "i", "]", ".", "name", ",", "arm_simd_types", "[", "i", "]", ".", "itype", ")", ";", "TYPE_NAME", "(", "arm_simd_types", "[", "i", "]", ".", "itype", ")", "=", "tdecl", ";", "SET_TYPE_STRUCTURAL_EQUALITY", "(", "arm_simd_types", "[", "i", "]", "." ]

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

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

[ "size", ";" ]

[ "ArgumentStackSize", "=" ]

[ "AsmOperandClass", "{" ]

[ "def", "MovKSymbolG3AsmOperand", ":" ]

[ "_", "_", "asm__", "(", "<STR_LIT>", "mvn %0.16b,%1.16b", "<STR_LIT>", ":", "<STR_LIT>", "=w", "<STR_LIT>", "(", "result", ")", ":", "<STR_LIT>", "w", "<STR_LIT>", "(", "a", ")", ":", ")", ";" ]

[ "vmvnq_s8", "(", "int8x16_t", "a", ")", "{", "int8x16_t", "result", ";" ]

[ "<STR_LIT>", ")" ]

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

[ "<FIXS>", "DAG", ".", "getIntPtrConstant", "(", "RegInfo", "->", "getSlotSize", "(", ")", ",", "dl", ")", ")", ";", "<FIXE>" ]

[ "unsigned", "StoreAddrReg", "=", "(", "PtrVT", "==", "MVT", "::", "i64", ")", "?", "X86", "::", "RCX", ":", "X86", "::", "ECX", ";", "SDValue", "StoreAddr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "Frame", ",", "<BUGS>", "DAG", ".", "getIntPtrConstant", "(", "RegInfo", "->", "getSlotSize", "(", ")", ")", ")", ";", "<BUGE>", "StoreAddr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "StoreAddr", ",", "Offset", ")", ";", "Chain", "=", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "Handler", ",", "StoreAddr", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";" ]

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

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

[ "<FIXS>", "(", "match_operand", ":", "VCOND", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<FIXE>", "<FIXS>", "aarch64_simd_lane_bounds", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ",", "GET_MODE_NUNITS", "(", "VCOND", ">", "mode", ")", ")", "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "ENDIAN_LANE_N", "(", "VCOND", ">", "mode", ",", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", ")", "<FIXE>" ]

[ "[", "(", "match_operand", ":", "VWIDE", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VWIDE", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VSD_HSI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "match_operand", ":", "VCON", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<STR_LIT>", "{", "<BUGS>", "aarch64_simd_lane_bounds", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ",", "GET_MODE_NUNITS", "(", "VCON", ">", "mode", ")", "/", "<NUM_LIT>", ")", "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "ENDIAN_LANE_N", "(", "VCONQ", ">", "mode", ",", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", ")", "<BUGE>", "emit_insn", "(", "gen_aarch64_sqdmlal_lane", "mode", ">", "_internal", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")" ]

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

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

[ "<NUM_LIT>", ";" ]

[ "def", "_fixed", ":", "NeonI_LdStMult_Post", "<", "q", ",", "<NUM_LIT>", ",", "opcode", ",", "size", ",", "(", "outs", "VecList", ":", "$", "Rt", ",", "GPR64xsp", ":", "$", "wb", ")", ",", "(", "ins", "GPR64xsp", ":", "$", "Rn", ",", "ImmTy", ":", "$", "amt", ")", ",", "asmop", "#", "<STR_LIT>", ",", "[", "]", ",", "NoItinerary", ">", "{", "let", "Rm", "=" ]

[ "getRegister", "(", "RegNo", ">>", "<NUM_LIT>", ")", ";" ]

[ "if", "(", "RegNo", ">", "<NUM_LIT>", ")", "return", "Fail", ";", "if", "(", "RegNo", "&", "<NUM_LIT>", ")", "return", "Fail", ";", "unsigned", "Register", "=", "AArch64MCRegisterClasses", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", "." ]

[ "}" ]

[ "static", "SDValue", "lowerVectorShuffleWithSHUFPD", "(", "const", "SDLoc", "&", "DL", ",", "MVT", "VT", ",", "ArrayRef", "<", "int", ">", "Mask", ",", "SDValue", "V1", ",", "SDValue", "V2", ",", "SelectionDAG", "&", "DAG", ")", "{", "assert", "(", "(", "VT", "==", "MVT", "::", "v2f64", "||", "VT", "==", "MVT", "::", "v4f64", "||", "VT", "==", "MVT", "::", "v8f64", ")", "&&", "<STR_LIT>", "Unexpected data type for VSHUFPD", "<STR_LIT>", ")", ";", "unsigned", "Immediate", "=", "<NUM_LIT>", ";", "if", "(", "!", "matchVectorShuffleWithSHUFPD", "(", "VT", ",", "V1", ",", "V2", ",", "Immediate", ",", "Mask", ")", ")", "return", "SDValue", "(", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "V1", ",", "V2", ",", "DAG", ".", "getConstant", "(", "Immediate", ",", "DL", ",", "MVT", "::", "i8", ")", ")", ";" ]

[ ",", "SSHLLvvi_4H", ",", "VPR128", ",", "VPR64", ">", ";" ]

[ "def", "SXTLvv_4H", ":", "NeonI_ext_len_alias", "<", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>" ]

[ "const", "MachineOperand", "&", "CalleeOp", "=", "MI", ".", "getOperand", "(", "getCalleeOpNo", "(", "MI", ")", ")", ";" ]

[ "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "WebAssembly", "::", "CATCH_I32", "||", "MI", ".", "getOpcode", "(", ")", "==", "WebAssembly", "::", "CATCH_I64", "||", "MI", ".", "getOpcode", "(", ")", "==", "WebAssembly", "::", "CATCH_I32_S", "||", "MI", ".", "getOpcode", "(", ")", "==", "WebAssembly", "::", "CATCH_I64_S", ")", "SeenCatch", "=", "true", ";", "if", "(", "SeenCatch", "&&", "MI", ".", "isCall", "(", ")", ")", "{" ]

[ "bool", "ia64_can_eliminate", "(", "const", "int", "from", "ATTRIBUTE_UNUSED", ",", "const", "int", "to", ")", "{", "return", "(", "to", "==", "BR_REG", "(", "<NUM_LIT>", ")", "?", "crtl", "->", "is_leaf", ":", "true", ")", ";", "}" ]

[ "Worker", "function", "for", "TARGET_CAN_ELIMINATE", "." ]

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

[ "if", "(", "Opcode", "==", "Instruction", "::", "ICmp", "||", "Opcode", "==", "Instruction", "::", "FCmp", ")", "{", "unsigned", "PredicateExtraCost", "=", "<NUM_LIT>", ";", "if", "(", "I", "!=", "nullptr", ")", "{", "switch", "(", "cast", "<", "CmpInst", ">", "(", "I", ")", "->", "getPredicate", "(", ")", ")", "{", "case", "CmpInst", "::", "Predicate", "::", "ICMP_NE", ":", "case", "CmpInst", "::", "Predicate", "::", "ICMP_UGE", ":", "case", "CmpInst", "::", "Predicate", "::", "ICMP_ULE", ":", "case", "CmpInst", "::", "Predicate", "::", "ICMP_SGE", ":", "case", "CmpInst", "::", "Predicate", "::", "ICMP_SLE", ":", "PredicateExtraCost", "=", "<NUM_LIT>", ";", "break", ";", "case", "CmpInst", "::", "Predicate", "::", "FCMP_ONE", ":", "case", "CmpInst", "::", "Predicate", "::", "FCMP_ORD", ":", "case", "CmpInst", "::", "Predicate", "::", "FCMP_UEQ", ":", "case", "CmpInst", "::", "Predicate", "::", "FCMP_UNO", ":", "PredicateExtraCost", "=", "<NUM_LIT>", ";", "break", ";", "default", ":", "break", ";", "}", "}", "unsigned", "CmpCostPerVector", "=", "(", "ValTy", "->", "getScalarType", "(", ")", "->", "isFloatTy", "(", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "unsigned", "NumVecs_cmp", "=", "getNumberOfParts", "(", "ValTy", ")", ";", "unsigned", "Cost", "=", "(", "NumVecs_cmp", "*", "(", "CmpCostPerVector", "+", "PredicateExtraCost", ")", ")", ";", "return", "Cost", ";", "}", "else", "{", "assert", "(", "Opcode", "==", "Instruction", "::", "Select", ")", ";", "unsigned", "PackCost", "=", "<NUM_LIT>", ";", "Type", "*", "CmpOpTy", "=", "(", "(", "I", "!=", "nullptr", ")", "?", "getCmpOpsType", "(", "I", ",", "VF", ")", ":", "nullptr", ")", ";", "if", "(", "CmpOpTy", "!=", "nullptr", ")", "PackCost", "=", "getVectorBitmaskConversionCost", "(", "CmpOpTy", ",", "ValTy", ")", ";", "return", "getNumberOfParts", "(", "ValTy", ")", "+", "PackCost", ";", "}", "}", "else", "{", "switch", "(", "Opcode", ")", "{", "case", "Instruction", "::", "ICmp", ":", "{" ]

[ "return", "EndResult", ";" ]

[ "if", "(", "Phi", "==", "nullptr", "||", "Phi", "->", "getNumIncomingValues", "(", ")", "!=", "<NUM_LIT>", "||", "Phi", "->", "getParent", "(", ")", "!=", "L", "->", "getHeader", "(", ")", "||", "Phi", "->", "getNumUses", "(", ")", "!=", "<NUM_LIT>", ")", "return", "nullptr", ";", "unsigned", "IncrementIndex", "=", "Phi", "->", "getIncomingBlock", "(", "<NUM_LIT>", ")", "==", "L", "->", "getLoopLatch", "(", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "Offsets", "=", "Phi", "->", "getIncomingValue", "(", "IncrementIndex", ")", ";", "std", "::", "pair", "<", "Value", "*", ",", "int64_t", ">", "Add", "=", "getVarAndConst", "(", "Offsets", ",", "TypeScale", ")", ";", "if", "(", "Add", ".", "first", "==", "nullptr", ")", "return", "nullptr", ";", "Value", "*", "OffsetsIncoming", "=", "Add", ".", "first", ";", "int64_t", "Immediate", "=", "Add", ".", "second", ";", "if", "(", "OffsetsIncoming", "!=", "Phi", ")", "return", "nullptr", ";", "Builder", ".", "SetInsertPoint", "(", "&", "Phi", "->", "getIncomingBlock", "(", "<NUM_LIT>", "-", "IncrementIndex", ")", "->", "back", "(", ")", ")", ";", "unsigned", "NumElems", "=", "cast", "<", "FixedVectorType", ">", "(", "OffsetsIncoming", "->", "getType", "(", ")", ")", "->", "getNumElements", "(", ")", ";", "Instruction", "*", "ScaledOffsets", "=", "BinaryOperator", "::", "Create", "(", "Instruction", "::", "Shl", ",", "Phi", "->", "getIncomingValue", "(", "<NUM_LIT>", "-", "IncrementIndex", ")", ",", "Builder", ".", "CreateVectorSplat", "(", "NumElems", ",", "Builder", ".", "getInt32", "(", "TypeScale", ")", ")", ",", "<STR_LIT>", "ScaledIndex", "<STR_LIT>", ",", "&", "Phi", "->", "getIncomingBlock", "(", "<NUM_LIT>", "-", "IncrementIndex", ")", "->", "back", "(", ")", ")", ";", "OffsetsIncoming", "=", "BinaryOperator", "::", "Create", "(", "Instruction", "::", "Add", ",", "ScaledOffsets", ",", "Builder", ".", "CreateVectorSplat", "(", "NumElems", ",", "Builder", ".", "CreatePtrToInt", "(", "BasePtr", ",", "cast", "<", "VectorType", ">", "(", "ScaledOffsets", "->", "getType", "(", ")", ")", "->", "getElementType", "(", ")", ")", ")", ",", "<STR_LIT>", "StartIndex", "<STR_LIT>", ",", "&", "Phi", "->", "getIncomingBlock", "(", "<NUM_LIT>", "-", "IncrementIndex", ")", "->", "back", "(", ")", ")", ";", "OffsetsIncoming", "=", "BinaryOperator", "::", "Create", "(", "Instruction", "::", "Sub", ",", "OffsetsIncoming", ",", "Builder", ".", "CreateVectorSplat", "(", "NumElems", ",", "Builder", ".", "getInt32", "(", "Immediate", ")", ")", ",", "<STR_LIT>", "PreIncrementStartIndex", "<STR_LIT>", ",", "&", "Phi", "->", "getIncomingBlock", "(", "<NUM_LIT>", "-", "IncrementIndex", ")", "->", "back", "(", ")", ")", ";", "Phi", "->", "setIncomingValue", "(", "<NUM_LIT>", "-", "IncrementIndex", ",", "OffsetsIncoming", ")", ";", "Builder", ".", "SetInsertPoint", "(", "I", ")", ";", "Instruction", "*", "EndResult", ";", "Instruction", "*", "NewInduction", ";", "if", "(", "I", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "masked_gather", ")", "{", "Value", "*", "Load", "=", "tryCreateMaskedGatherBaseWB", "(", "I", ",", "Phi", ",", "Builder", ",", "Immediate", ")", ";", "EndResult", "=", "ExtractValueInst", "::", "Create", "(", "Load", ",", "<NUM_LIT>", ",", "<STR_LIT>", "Gather", "<STR_LIT>", ")", ";", "NewInduction", "=", "ExtractValueInst", "::", "Create", "(", "Load", ",", "<NUM_LIT>", ",", "<STR_LIT>", "GatherIncrement", "<STR_LIT>", ")", ";", "Builder", ".", "Insert", "(", "EndResult", ")", ";", "Builder", ".", "Insert", "(", "NewInduction", ")", ";", "}", "else", "{", "EndResult", "=", "NewInduction", "=", "tryCreateMaskedScatterBaseWB", "(", "I", ",", "Phi", ",", "Builder", ",", "Immediate", ")", ";", "}", "Instruction", "*", "AddInst", "=", "cast", "<", "Instruction", ">", "(", "Offsets", ")", ";", "AddInst", "->", "replaceAllUsesWith", "(", "NewInduction", ")", ";", "AddInst", "->", "eraseFromParent", "(", ")", ";", "Phi", "->", "setIncomingValue", "(", "IncrementIndex", ",", "NewInduction", ")", ";" ]

[ "uint8x8_t", "_", "_", "c", ")", "{" ]

[ "vmla_u8", "(", "uint8x8_t", "_", "_", "a", ",", "uint8x8_t", "_", "_", "b", "," ]

[ ")", ";" ]

[ "SDValue", "N0", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "N1", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "N0", ".", "getOpcode", "(", ")", "!=", "<STR_LIT>", "::", "<STR_LIT>", "||", "!", "N0", ".", "hasOneUse", "(", ")", "||", "N1", ".", "getOpcode", "(", ")", "!=", "<STR_LIT>", "::", "<STR_LIT>", "||", "!", "N1", ".", "hasOneUse", "(", ")", ")", "return", "SDValue", "(", ")", ";", "SDValue", "Vec0", "=", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Vec1", "=", "N1", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "EVT", "VecVT0", "=", "Vec0", ".", "getValueType", "(", ")", ";", "EVT", "VecVT1", "=", "Vec1", ".", "getValueType", "(" ]

[ "_", "X", ",", "_", "_", "m256i", "_", "_", "Y", ",", "const", "int", "_", "_", "P", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "mmask32", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_cmp_epi8_mask", "(", "_", "_", "m256i", "_" ]

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

[ "if", "(", "VT", ".", "isVector", "(", ")", "&&", "VT", ".", "getVectorNumElements", "(", ")", "==", "<NUM_LIT>", "&&", "(", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", "||", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i8", ")", ")", "return", "<NUM_LIT>", ";", "return", "getNumRegisters", "(", "Context", "," ]

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

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

[ ")", ")" ]

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

[ ")", ";" ]

[ "auto", "Next", "=", "skipIgnoreExecInstsTrivialSucc", "(", "MBB", ",", "std", "::", "next", "(", "MI", "->", "getIterator", "(", ")", ")", ")", ";", "if", "(", "Next", "==", "MBB", ".", "end", "(", ")", "||", "!", "LoweredEndCf", ".", "count", "(", "&", "*", "Next", ")", ")", "continue", ";", "Register", "SavedExec", "=", "TII", "->", "getNamedOperand", "(", "*", "Next", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", "->", "getReg", "(", ")", ";", "assert", "(", "SavedExec", ".", "isVirtual", "(", ")", "&&", "<STR_LIT>", "Expected saved exec to be src1!", "<STR_LIT>" ]

[ "<STR_LIT>", ";" ]

[ "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "<STR_LIT>", "X86 Partial Reduction" ]

[ "}" ]

[ "_", "_", "arm_vcmpleq_m_n_s8", "(", "int8x16_t", "_", "_", "a", ",", "int8_t", "_", "_", "b", ",", "mve_pred16_t", "_", "_", "p", ")", "{", "return", "_", "_", "builtin_mve_vcmpleq_m_n_sv16qi", "(", "_", "_", "a", ",", "_", "_", "b", ",", "_", "_", "p", ")", ";" ]

[ "<STR_LIT>", ")" ]

[ "(", "define_automaton" ]

[ "_", "_", "res", ".", "as_short", "[", "<NUM_LIT>", "]", "=", "_", "_", "mu2", ".", "as_short", "[", "<NUM_LIT>", "]", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m64", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_unpacklo_pi16", "(", "_", "_", "m64", "_", "_", "m1", ",", "_", "_", "m64", "_", "_", "m2", ")", "{", "_", "_", "m64_union", "_", "_", "mu1", ",", "_", "_", "mu2", ",", "_", "_", "res", ";", "_", "_", "mu1", ".", "as_m64", "=", "_", "_", "m1", ";", "_", "_", "mu2", ".", "as_m64", "=", "_", "_", "m2", ";", "_", "_", "res", ".", "as_short", "[", "<NUM_LIT>", "]", "=", "_", "_", "mu1", ".", "as_short", "[", "<NUM_LIT>", "]", ";", "_", "_", "res", ".", "as_short", "[", "<NUM_LIT>", "]", "=", "_", "_", "mu2", ".", "as_short", "[", "<NUM_LIT>", "]", ";", "_", "_", "res", ".", "as_short", "[", "<NUM_LIT>", "]", "=", "_", "_", "mu1", ".", "as_short", "[", "<NUM_LIT>", "]", ";" ]

[ "}" ]

[ "class", "Enc_4dc228", ":", "OpcodeHexagon", "{", "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>", ">", "II", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "II", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "II", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "II", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "if", "(", "FRemFunc", ")", "FRemFunc", "->", "setUnnamedAddr", "(", "GlobalValue", "::", "UnnamedAddr", "::", "Local", ")", ";" ]

[ "SDivFunc", "=", "findFunction", "(", "M", ",", "<STR_LIT>", "__sdiv", "<STR_LIT>", ")", ";", "SRemFunc", "=", "findFunction", "(", "M", ",", "<STR_LIT>", "__srem", "<STR_LIT>", ")", ";", "if", "(", "FDivFunc", ")", "FDivFunc", "->", "setUnnamedAddr", "(", "GlobalValue", "::", "UnnamedAddr", "::", "Local", ")", ";" ]

[ "mode", ",", "operands", "[", "<NUM_LIT>", "]", "," ]

[ "<STR_LIT>", "[", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "mult", ":", "<", "vmode_PART", ">", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC_FP", "CCFP_REGNUM", ")", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", ")", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "mult", ":", "<", "vmode_PART", ">", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC_FP", "CCFP_REGNUM", ")", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", ")", "]", "{", "operands", "[", "<NUM_LIT>", "]", "=", "simplify_gen_subreg", "(", "<", "vmode_PART", ">", "mode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "<", "MODE", ">", "mode", ",", "<NUM_LIT>", ")", "operands", "[", "<NUM_LIT>", "]", "=", "simplify_gen_subreg", "(", "<", "vmode_PART", ">", "mode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "<", "MODE", ">", "mode", ",", "<NUM_LIT>", ")", "operands", "[", "<NUM_LIT>", "]", "=", "simplify_gen_subreg", "(", "<", "vmode_PART", ">", "mode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "<", "MODE", ">", "mode", ",", "<NUM_LIT>", ")", "operands", "[", "<NUM_LIT>", "]", "=", "simplify_gen_subreg", "(", "<", "vmode_PART", ">", "mode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "<", "MODE", ">", "mode", ",", "UNITS_PER_WORD", ")", "operands", "[", "<NUM_LIT>", "]", "=", "simplify_gen_subreg", "(", "<", "vmode_PART", ">" ]

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

[ "static", "voidtilegx_setup_incoming_varargs", "(", "cumulative_args_t", "cum", ",", "<BUGS>", "enum", "machine_mode", "mode", ",", "<BUGE>", "tree", "type", ",", "int", "*", "pretend_args", ",", "int", "no_rtl", ")", "{", "CUMULATIVE_ARGS", "local_cum", "=", "*", "get_cumulative_args", "(", "cum", ")", ";" ]

[ "<FIXS>", "mem", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "ptr_mode", ",", "<NUM_LIT>", ")", ";", "<FIXE>", "<FIXS>", "mem", "=", "gen_rtx_MEM", "(", "mode", ",", "force_reg", "(", "ptr_mode", ",", "mem", ")", ")", ";", "<FIXE>" ]

[ "rtx", "mem", ";", "arg0", "=", "TREE_VALUE", "(", "arglist", ")", ";", "<BUGS>", "mem", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "Pmode", ",", "<NUM_LIT>", ")", ";", "<BUGE>", "<BUGS>", "mem", "=", "gen_rtx_MEM", "(", "mode", ",", "force_reg", "(", "Pmode", ",", "mem", ")", ")", ";", "<BUGE>", "MEM_VOLATILE_P", "(", "mem", ")", "=", "<NUM_LIT>", ";", "emit_move_insn", "(", "mem", ",", "const0_rtx", ")", ";" ]

[ "]", ")" ]

[ "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "if_then_else", ":", "W", "(", "eq", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "const_int", "-", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "ne", ":", "SI", "(", "reg", ":", "CC", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>" ]

[ "lane", "{", "<NUM_LIT>", "}", ";" ]

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

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

[ "const", "SIMachineFunctionInfo", "*", "Info", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "return", "Info", "->", "getMode", "(", ")" ]

[ "reg1", ",", "reg2", ")", ";" ]

[ "if", "(", "m", "->", "fs", ".", "cfa_reg", "==", "stack_pointer_rtx", ")", "m", "->", "fs", ".", "cfa_offset", "+=", "offset", ";", "m", "->", "fs", ".", "sp_offset", "+=", "offset", ";", "if", "(", "REG_P", "(", "reg1", ")", "&&", "GET_MODE", "(", "reg1", ")", "!=", "word_mode", ")", "reg1", "=", "gen_rtx_REG", "(", "word_mode", ",", "REGNO", "(", "reg1", ")", ")", ";", "if", "(", "REG_P", "(", "reg2", ")", "&&", "GET_MODE", "(", "reg2", ")", "!=", "word_mode", ")", "reg2", "=", "gen_rtx_REG", "(", "word_mode", ",", "REGNO", "(", "reg2", ")", ")", ";", "return", "ppx_p", "?", "gen_push2p_di", "(", "mem", ",", "reg1", ",", "reg2", ")", ":", "gen_push2_di", "(", "mem", "," ]

[ "Def", ";" ]

[ "return", "Def", ";", "}", "}", "for", "(", "MachineOperand", "&", "DefMO", ":", "Def", "->", "explicit_uses", "(", ")", ")", "{", "if", "(", "!", "DefMO", ".", "isReg", "(", ")", ")", "continue", ";", "return", "findStartOfTree", "(", "DefMO", ",", "MRI", ",", "MFI", ")", ";", "}", "return" ]

[ "]", ")" ]

[ "(", "define_mode_iterator", "SWI48", "[", "SI", "(", "DI", "<STR_LIT>", ")" ]

[ "hasSubClassEq", "(", "OpClass", ")", ";" ]

[ "const", "MCInstrDesc", "&", "Desc", "=", "TII", "->", "get", "(", "MN", "->", "getMachineOpcode", "(", ")", ")", ";", "int", "OpClassID", "=", "Desc", ".", "OpInfo", "[", "Op", ".", "getResNo", "(", ")", "]", ".", "RegClass", ";", "if", "(", "OpClassID", "==", "-", "<NUM_LIT>", ")", "{", "switch", "(", "MN", "->", "getMachineOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "REG_SEQUENCE", ":", "OpClass", "=", "TRI", "->", "getRegClass", "(", "cast", "<", "ConstantSDNode", ">", "(", "MN", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ")", ";", "break", ";", "default", ":", "OpClass", "=", "getRegClassFor", "(", "Op", ".", "getSimpleValueType", "(", ")", ")", ";", "break", ";", "}", "}", "else", "{", "OpClass", "=", "TRI", "->", "getRegClass", "(", "OpClassID", ")", ";", "}", "}", "else", "if", "(", "Node", "->", "getOpcode", "(", ")", "==", "ISD", "::", "CopyFromReg", ")", "{", "RegisterSDNode", "*", "Reg", "=", "cast", "<", "RegisterSDNode", ">", "(", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ")", ";", "OpClass", "=", "MRI", ".", "getRegClass", "(", "Reg", "->", "getReg", "(", ")", ")", ";", "}", "else", "return", "false", ";", "return", "TRI", "->", "getRegClass", "(", "RegClass", ")", "->" ]

[ "opc", ",", "regtype", ",", "asm", ",", "(", "outs", "regtype", ":", "$", "Rt", ")", ",", "(", "ins", "ro_indexed32", ":", "$", "addr", ")", ",", "pat", ">", ",", "Sched", "<", "[", "WriteLDIdx", ",", "ReadAdrBase", "]", ">", ";" ]

[ "class", "Load32RO", "<", "bits", "<", "<NUM_LIT>", ">", "sz", ",", "bit", "V", ",", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "RegisterClass", "regtype", ",", "string", "asm", ",", "list", "<", "dag", ">", "pat", ">", ":", "LoadStore32RO", "<", "sz", ",", "V", "," ]

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

[ "void", "EmitByte", "(", "unsigned", "char", "C", ",", "unsigned", "&", "CurByte", ",", "raw_ostream" ]

[ ")" ]

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