Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

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

[ "lang_hooks", ".", "types", ".", "register_builtin_type", "(", "bfloat16_type_node", ",", "<STR_LIT>", "__bf16", "<STR_LIT>", ")", ";", "aarch64_bf16_ptr_type_node", "=", "build_pointer_type" ]

[ "void", "mips_expand_epilogue", "(", ")", "{", "HOST_WIDE_INT", "tsize", "=", "current_frame_info", ".", "total_size", ";", "rtx", "tsize_rtx", "=", "GEN_INT", "(", "tsize", ")", ";", "rtx", "tmp_rtx", "=", "(", "rtx", ")", "<NUM_LIT>", ";", "if", "(", "mips_can_use_return_insn", "(", ")", ")", "{", "emit_insn", "(", "gen_return", "(", ")", ")", ";", "return", ";", "}", "if", "(", "mips_entry", "&&", "!", "mips_can_use_return_insn", "(", ")", ")", "tsize", "-=", "<NUM_LIT>", ";", "if", "(", "tsize", ">", "<NUM_LIT>", "&&", "!", "TARGET_MIPS16", ")", "{", "tmp_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "MIPS_TEMP1_REGNUM", ")", ";", "emit_move_insn", "(", "tmp_rtx", ",", "tsize_rtx", ")", ";", "tsize_rtx", "=", "tmp_rtx", ";", "}", "if", "(", "tsize", ">", "<NUM_LIT>", ")", "{", "long", "or", "ig_tsize", "=", "tsize", ";", "if", "(", "frame_pointer_needed", ")", "{", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "if", "(", "TARGET_MIPS16", ")", "{", "tsize", "-=", "current_function_outgoing_args_size", ";", "if", "(", "or", "ig_tsize", ">", "<NUM_LIT>", ")", "{", "rtx", "g6_rtx", "=", "gen_rtx", "(", "REG", ",", "Pmode", ",", "GP_REG_FIRST", "+", "<NUM_LIT>", ")", ";", "emit_move_insn", "(", "g6_rtx", ",", "GEN_INT", "(", "tsize", ")", ")", ";", "if", "(", "Pmode", "==", "DImode", ")", "emit_insn", "(", "gen_adddi3", "(", "hard_frame_pointer_rtx", ",", "hard_frame_pointer_rtx", ",", "g6_rtx", ")", ")", ";", "else", "emit_insn", "(", "gen_addsi3", "(", "hard_frame_pointer_rtx", ",", "hard_frame_pointer_rtx", ",", "g6_rtx", ")", ")", ";", "tsize", "=", "<NUM_LIT>", ";", "}", "if", "(", "tsize", "&&", "tsize", "!=", "or", "ig_tsize", ")", "tsize_rtx", "=", "GEN_INT", "(", "tsize", ")", ";", "}", "if", "(", "Pmode", "==", "DImode", ")", "emit_insn", "(", "gen_movdi", "(", "stack_pointer_rtx", ",", "hard_frame_pointer_rtx", ")", ")", ";", "else", "emit_insn", "(", "gen_movsi", "(", "stack_pointer_rtx", ",", "hard_frame_pointer_rtx", ")", ")", ";", "}", "else", "if", "(", "TARGET_ABICALLS", "&&", "mips_abi", "!=", "ABI_32", "&&", "mips_abi", "!=", "ABI_O64", "&&", "(", "current_frame_info", ".", "mask", "&", "(", "<NUM_LIT>", "L", "<<", "(", "PIC_OFFSET_TABLE_REGNUM", "-", "GP_REG_FIRST", ")", ")", ")", ")", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "save_restore_insns", "(", "<NUM_LIT>", ",", "tmp_rtx", ",", "or", "ig_tsize", ",", "(", "FILE", "*", ")", "<NUM_LIT>", ")", ";", "if", "(", "tsize", ">", "<NUM_LIT>", "&&", "TARGET_MIPS16", ")", "abort", "(", ")", ";", "if", "(", "current_function_calls_eh_return", ")", "{", "rtx", "eh_ofs", "=", "EH_RETURN_STACKADJ_RTX", ";", "if", "(", "Pmode", "==", "DImode", ")", "emit_insn", "(", "gen_adddi3", "(", "eh_ofs", ",", "eh_ofs", ",", "tsize_rtx", ")", ")", ";", "else", "emit_insn", "(", "gen_addsi3", "(", "eh_ofs", ",", "eh_ofs", ",", "tsize_rtx", ")", ")", ";", "tsize_rtx", "=", "eh_ofs", ";", "}", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "if", "(", "tsize", "!=", "<NUM_LIT>", "||", "current_function_calls_eh_return", ")", "{", "if", "(", "!", "TARGET_MIPS16", ")", "{", "if", "(", "Pmode", "==", "DImode", ")", "emit_insn", "(", "gen_adddi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "tsize_rtx", ")", ")", ";", "else", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "tsize_rtx", ")", ")", ";", "}", "else", "{", "rtx", "g6_rtx", "=", "gen_rtx", "(", "REG", ",", "Pmode", ",", "GP_REG_FIRST", "+", "<NUM_LIT>", ")", ";", "if", "(", "Pmode", "==", "DImode", ")", "{", "emit_insn", "(", "gen_movdi", "(", "g6_rtx", ",", "stack_pointer_rtx", ")", ")", ";", "emit_insn", "(", "gen_adddi3", "(", "g6_rtx", ",", "g6_rtx", ",", "tsize_rtx", ")", ")", ";", "emit_insn", "(", "gen_movdi", "(", "stack_pointer_rtx", ",", "g6_rtx", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_movsi", "(", "g6_rtx", ",", "stack_pointer_rtx", ")", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "g6_rtx", ",", "g6_rtx", ",", "tsize_rtx", ")", ")", ";", "emit_insn", "(", "gen_movsi", "(", "stack_pointer_rtx", ",", "g6_rtx", ")", ")", ";", "}", "}", "}", "}", "if", "(", "TARGET_MIPS16", "&&", "(", "current_frame_info", ".", "mask", "&", "RA_MASK", ")", "!=", "<NUM_LIT>", ")", "emit_jump_insn", "(", "gen_return_internal", "(", "gen_rtx", "(", "REG", ",", "Pmode", ",", "GP_REG_FIRST", "+", "<NUM_LIT>", ")", ")", ")", ";", "else", "emit_jump_insn", "(", "gen_return_internal", "(", "gen_rtx", "(", "REG", ",", "Pmode", ",", "GP_REG_FIRST", "+", "<NUM_LIT>", ")", ")", ")", ";", "}" ]

[ "Expand", "the", "epilogue", "into", "a", "bunch", "of", "separate", "insns", ".", "SIBCALL_P", "is", "true", "if", "this", "epilogue", "precedes", "a", "sibling", "call", ",", "false", "if", "it", "is", "for", "a", "normal", "``", "epilogue", "''", "pattern", "." ]

[ "}", ")" ]

[ "UNSPEC_VSX_STSTDC", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{", "operands", "[", "<NUM_LIT>", "]", "=", "gen_reg_rtx", "(", "CCFPmode", ")", "operands", "[", "<NUM_LIT>", "]", "=", "CONST0_RTX", "(", "SImode", ")" ]

[ "<FIXS>", "case", "E_CCLmode", ":", "<FIXE>" ]

[ "}", "break", ";", "<BUGS>", "case", "CCLmode", ":", "<BUGE>", "switch", "(", "GET_CODE", "(", "code", ")", ")", "{", "case", "EQ", ":", "return", "CC0", "|", "CC2", ";" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "src2", ";", "bits", "<", "<NUM_LIT>", ">", "src2_rel", ";", "bits", "<", "<NUM_LIT>", ">", "src2_neg", ";", "bits", "<", "<NUM_LIT>", ">", "src2_sel", "=", "src2", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "src2_chan", "=", "src2", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Word1", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "src2_sel", ";" ]

[ ">", ";" ]

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

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

[ "extern", "_", "_", "inline", "_", "_", "m256d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_maskz_fmsub_pd", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m256d", "_", "_", "A", ",", "_", "_", "m256d", "_", "_", "B", ",", "_", "_", "m256d", "_", "_", "C", ")", "{", "return", "(", "_", "_", "m256d", ")", "_", "_", "builtin_ia32_vfmsubpd256_maskz", "(", "(", "_", "_", "v4df", ")", "_", "_", "A", ",", "(", "_", "_", "v4df", ")", "_", "_", "B", ",", "(", "_", "_", "v4df", ")", "_", "_", "C", ",", "(", "_", "_" ]

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

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

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

[ "def", "SKLWriteResGroup134", ":", "SchedWriteRes", "<", "[", "SKLPort01", ",", "SKLPort23", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=", "<NUM_LIT>", ";", "let", "ResourceCycles", "=", "[", "<NUM_LIT>" ]

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

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

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

[ "return", "(", "(", "(", "uint32_t", ")", "Imm", ")", "<", "<NUM_LIT>", ")", ";", "}", "]", ">", "{" ]

[ "<NUM_LIT>", ";" ]

[ "def", "L2_loadbzw4_pcr", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ",", "IntRegs", ":", "$", "Rx32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rx32in", ",", "ModRegs", ":", "$", "Mu2", ")", ",", "<STR_LIT>", ",", "tc_44d3da28", ",", "TypeLD", ">", ",", "Enc_7eee72", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=" ]

[ "<FIXS>", "return", "FixupConstant", "(", "Fixups", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "<FIXE>" ]

[ "{", "X86", "::", "VPMOVZXWDZ128rm", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "rebuildZExtCst", "}", ",", "{", "X86", "::", "VPMOVSXDQZ128rm", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "rebuildSExtCst", "}", ",", "{", "X86", "::", "VPMOVZXDQZ128rm", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "rebuildZExtCst", "}", "}", ";", "<BUGS>", "return", "FixupConstant", "(", "Fixups", ",", "<NUM_LIT>", ")", ";", "<BUGE>", "}", "case", "X86", "::", "VMOVDQA32Z256rm", ":", "case", "X86", "::", "VMOVDQA64Z256rm", ":" ]

[ "ResTy", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Zero", ")", ";" ]

[ "MVT", "ResTy", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ".", "getSimpleVT", "(", ")", ";", "SDValue", "Zero", "=", "CurDAG", "->", "getTargetConstant", "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "SDNode", "*", "T", "=", "CurDAG", "->", "getMachineNode", "(", "Hexagon", "::", "A4_vcmpbgtui", ",", "dl", "," ]

[ ")", ",", "!", "strconcat", "(", "asm", ",", "<STR_LIT>", ")", ")", ",", "[", "]", ">", ",", "Sched", "<", "[", "sched", ".", "Folded", ",", "ReadAfterLd", "]", ">", ";" ]

[ "def", "rm_Int", ":", "SI", "<", "opc", ",", "MRMSrcMem", ",", "(", "outs", "DstRC", ":", "$", "dst", ")", ",", "(", "ins", "DstRC", ":", "$", "src1", ",", "x86memop", ":", "$", "src2", ")", ",", "!", "if", "(", "Is2Addr", ",", "!", "strconcat", "(", "asm", ",", "<STR_LIT>" ]

[ "<FIXS>", "(", "unspec_volatile", ":", "V8DI", "[", "(", "match_operand", ":", "V8DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_ST64B", ")", "<FIXE>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "mem", ":", "V8DI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<BUGS>", "(", "unspec_volatile", ":", "V8DI", "[", "(", "match_operand", ":", "V8DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_ST64B", ")", "<BUGE>", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

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

[ "def", "am6offset", ":", "MemOperand", ",", "ComplexPattern", "<", "i32", ",", "<NUM_LIT>", ",", "<STR_LIT>", ",", "[", "]", ",", "[", "SDNPWantRoot", "]", ">", "{", "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "MIOperandInfo", "=", "(", "ops", "GPR", ")", ";" ]

[ "_", "_", "p", ")", "{" ]

[ "_", "_", "arm_vrshrnbq_m_n_u32", "(", "uint16x8_t", "_", "_", "a", ",", "uint32x4_t", "_", "_", "b", ",", "const", "int", "_", "_", "imm", ",", "mve_pred16_t" ]

[ "<FIXS>", "def", "tSTRr", ":", "T1pILdStEncode", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", "tGPR", ":", "$", "Rt", ",", "t_addrmode_rrs4", ":", "$", "addr", ")", ",", "<FIXE>", "<FIXS>", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "store", "tGPR", ":", "$", "Rt", ",", "t_addrmode_rrs4", ":", "$", "addr", ")", "]", ">", ";", "<FIXE>", "<FIXS>", "T1pILdStEncodeImm", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", "tGPR", ":", "$", "Rt", ",", "t_addrmode_is4", ":", "$", "addr", ")", ",", "<FIXE>", "<FIXS>", "[", "(", "store", "tGPR", ":", "$", "Rt", ",", "t_addrmode_is4", ":", "$", "addr", ")", "]", ">", ";", "<FIXE>", "<FIXS>", "def", "tSTRBr", ":", "T1pILdStEncode", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", "tGPR", ":", "$", "Rt", ",", "t_addrmode_rrs1", ":", "$", "addr", ")", ",", "<FIXE>", "<FIXS>", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "truncstorei8", "tGPR", ":", "$", "Rt", ",", "t_addrmode_rrs1", ":", "$", "addr", ")", "]", ">", ";", "<FIXE>", "<FIXS>", "T1pILdStEncodeImm", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", "tGPR", ":", "$", "Rt", ",", "t_addrmode_is1", ":", "$", "addr", ")", ",", "<FIXE>", "<FIXS>", "[", "(", "truncstorei8", "tGPR", ":", "$", "Rt", ",", "t_addrmode_is1", ":", "$", "addr", ")", "]", ">", ";", "<FIXE>", "<FIXS>", "def", "tSTRHr", ":", "T1pILdStEncode", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", "tGPR", ":", "$", "Rt", ",", "t_addrmode_rrs2", ":", "$", "addr", ")", ",", "<FIXE>", "<FIXS>", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "truncstorei16", "tGPR", ":", "$", "Rt", ",", "t_addrmode_rrs2", ":", "$", "addr", ")", "]", ">", ";", "<FIXE>", "<FIXS>", "T1pILdStEncodeImm", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", "tGPR", ":", "$", "Rt", ",", "t_addrmode_is2", ":", "$", "addr", ")", ",", "<FIXE>", "<FIXS>", "[", "(", "truncstorei16", "tGPR", ":", "$", "Rt", ",", "t_addrmode_is2", ":", "$", "addr", ")", "]", ">", ";", "<FIXE>", "<FIXS>", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "store", "tGPR", ":", "$", "Rt", ",", "t_addrmode_sp", ":", "$", "addr", ")", "]", ">", ",", "<FIXE>" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "addr", ";", "}", "<BUGS>", "def", "tSTR", ":", "T1pILdStEncode", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", "tGPR", ":", "$", "src", ",", "t_addrmode_s4", ":", "$", "addr", ")", ",", "<BUGE>", "AddrModeT1_4", ",", "IIC_iStore_r", ",", "<BUGS>", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "store", "tGPR", ":", "$", "src", ",", "t_addrmode_s4", ":", "$", "addr", ")", "]", ">", ";", "<BUGE>", "def", "tSTRi", ":", "<BUGS>", "T1pILdStEncodeImm", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", "tGPR", ":", "$", "Rt", ",", "t_addrmode_s4", ":", "$", "addr", ")", ",", "<BUGE>", "AddrModeT1_4", ",", "IIC_iStore_r", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<BUGS>", "[", "]", ">", ";", "<BUGE>", "<BUGS>", "def", "tSTRB", ":", "T1pILdStEncode", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", "tGPR", ":", "$", "src", ",", "t_addrmode_s1", ":", "$", "addr", ")", ",", "<BUGE>", "AddrModeT1_1", ",", "IIC_iStore_bh_r", ",", "<BUGS>", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "truncstorei8", "tGPR", ":", "$", "src", ",", "t_addrmode_s1", ":", "$", "addr", ")", "]", ">", ";", "<BUGE>", "def", "tSTRBi", ":", "<BUGS>", "T1pILdStEncodeImm", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", "tGPR", ":", "$", "Rt", ",", "t_addrmode_s1", ":", "$", "addr", ")", ",", "<BUGE>", "AddrModeT1_1", ",", "IIC_iStore_bh_r", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<BUGS>", "[", "]", ">", ";", "<BUGE>", "<BUGS>", "def", "tSTRH", ":", "T1pILdStEncode", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", "tGPR", ":", "$", "src", ",", "t_addrmode_s2", ":", "$", "addr", ")", ",", "<BUGE>", "AddrModeT1_2", ",", "IIC_iStore_bh_r", ",", "<BUGS>", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "truncstorei16", "tGPR", ":", "$", "src", ",", "t_addrmode_s2", ":", "$", "addr", ")", "]", ">", ";", "<BUGE>", "def", "tSTRHi", ":", "<BUGS>", "T1pILdStEncodeImm", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", "tGPR", ":", "$", "Rt", ",", "t_addrmode_s2", ":", "$", "addr", ")", ",", "<BUGE>", "AddrModeT1_2", ",", "IIC_iStore_bh_r", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<BUGS>", "[", "]", ">", ";", "<BUGE>", "def", "tSTRspi", ":", "T1pIs", "(", "outs", ")", ",", "(", "ins", "tGPR", ":", "$", "Rt", ",", "t_addrmode_sp", ":", "$", "addr", ")", ",", "IIC_iStore_i", ",", "<BUGS>", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "store", "tGPR", ":", "$", "Rt", ",", "t_addrmode_sp", ":", "$", "addr", ")", "]", ">", ",", "<BUGE>", "T1LdStSP", "{", "<NUM_LIT>", ",", "?", ",", "?", "}", ">", "{", "bits", "<NUM_LIT>", ">", "Rt", ";", "bits", "<NUM_LIT>", ">", "addr", ";" ]

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

[ "def", "A4_vcmpbgti", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss32", ",", "s8_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_643b4717", ",", "TypeALU64", ">", ",", "Enc_0d8adb", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "P", ",", "_", "_", "m512d", "_", "_", "A", ")", "{" ]

[ "extern", "_", "_", "inline", "void", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_storeu_pd", "(", "void", "*", "_", "_" ]

[ "copy0MBB", ";" ]

[ "MachineBasicBlock", "*", "sinkMBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "F", "->", "insert", "(", "It", ",", "copy0MBB", ")", ";", "F", "->", "insert", "(", "It", ",", "sinkMBB", ")", ";", "sinkMBB", "->", "splice", "(", "sinkMBB", "->", "begin", "(", ")", ",", "BB", ",", "std", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "BB", "->", "end", "(", ")", ")", ";", "sinkMBB", "->", "transferSuccessorsAndUpdatePHIs", "(", "BB", ")", ";", "BB", "->", "addSuccessor", "(", "copy0MBB", ")", ";", "BB", "->", "addSuccessor", "(", "sinkMBB", ")", ";", "BuildMI", "(", "BB", ",", "DL", ",", "TII", "->", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "sinkMBB", ")", ";", "BB", "=" ]

[ "}" ]

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

[ "const", "char", "*", "lshrsi3_out", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ",", "int", "*", "len", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "CONST_INT", ")", "{", "int", "k", ";", "int", "*", "t", "=", "len", ";", "if", "(", "!", "len", ")", "len", "=", "&", "k", ";", "switch", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "{", "default", ":", "if", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "<", "<NUM_LIT>", ")", "break", ";", "if", "(", "AVR_HAVE_MOVW", ")", "return", "*", "len", "=", "<NUM_LIT>", ",", "(", "<STR_LIT>", "clr %D0", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "clr %C0", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "movw %A0,%C0", "<STR_LIT>", ")", ";", "*", "len", "=", "<NUM_LIT>", ";", "return", "(", "<STR_LIT>", "clr %D0", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "clr %C0", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "clr %B0", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "clr %A0", "<STR_LIT>", ")", ";", "case", "<NUM_LIT>", ":", "{", "int", "reg0", "=", "true_regnum", "(", "operands", "[", "<NUM_LIT>", "]", ")", ";", "int", "reg1", "=", "true_regnum", "(", "operands", "[", "<NUM_LIT>", "]", ")", ";", "*", "len", "=", "<NUM_LIT>", ";", "if", "(", "reg0", "<=", "reg1", ")", "return", "(", "<STR_LIT>", "mov %A0,%B1", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "mov %B0,%C1", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "mov %C0,%D1", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "clr %D0", "<STR_LIT>", ")", ";", "else", "return", "(", "<STR_LIT>", "clr %D0", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "mov %C0,%D1", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "mov %B0,%C1", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "mov %A0,%B1", "<STR_LIT>", ")", ";", "}", "case", "<NUM_LIT>", ":", "{", "int", "reg0", "=", "true_regnum", "(", "operands", "[", "<NUM_LIT>", "]", ")", ";", "int", "reg1", "=", "true_regnum", "(", "operands", "[", "<NUM_LIT>", "]", ")", ";", "if", "(", "reg0", "==", "reg1", "+", "<NUM_LIT>", ")", "return", "*", "len", "=", "<NUM_LIT>", ",", "(", "<STR_LIT>", "clr %C0", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "clr %D0", "<STR_LIT>", ")", ";", "if", "(", "AVR_HAVE_MOVW", ")", "return", "*", "len", "=", "<NUM_LIT>", ",", "(", "<STR_LIT>", "movw %A0,%C1", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "clr %C0", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "clr %D0", "<STR_LIT>", ")", ";", "else", "return", "*", "len", "=", "<NUM_LIT>", ",", "(", "<STR_LIT>", "mov %B0,%D1", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "mov %A0,%C1", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "clr %C0", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "clr %D0", "<STR_LIT>", ")", ";", "}", "case", "<NUM_LIT>", ":", "return", "*", "len", "=", "<NUM_LIT>", ",", "(", "<STR_LIT>", "mov %A0,%D1", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "clr %B0", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "clr %C0", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "clr %D0", "<STR_LIT>", ")", ";", "case", "<NUM_LIT>", ":", "*", "len", "=", "<NUM_LIT>", ";", "return", "(", "<STR_LIT>", "clr %A0", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "sbrc %D0,7", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "inc %A0", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "clr %B0", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "clr %C0", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "clr %D0", "<STR_LIT>", ")", ";", "}", "len", "=", "t", ";", "}", "out_shift_with_cnt", "(", "<STR_LIT>", "lsr %D0", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "ror %C0", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "ror %B0", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "ror %A0", "<STR_LIT>", ",", "insn", ",", "operands", ",", "len", ",", "<NUM_LIT>", ")", ";", "return", "<STR_LIT>", "<STR_LIT>", ";", "}" ]

[ "32bit", "logic", "shift", "right", "(", "(", "unsigned", "int", ")", "x", ">", ">", "i", ")" ]

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

[ "const", "char", "*", "getPassName" ]

[ "<STR_LIT>" ]

[ "[", "(", "set", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "DF", "[", "(", "match_operand", ":", "IEEE128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_TRUNC_ROUND_TO_ODD", ")", ")", "]" ]

[ "for", "(", "auto", "&", "Entry", ":", "InsertedMIToOldDef", ")", "{" ]

[ "MachineInstr", "*", "Def", "=", "It", ".", "first", ";", "MachineBasicBlock", "::", "iterator", "InsertPos", "=", "MachineBasicBlock", "::", "iterator", "(", "It", ".", "second", ")", ";", "Register", "Reg", "=", "Def", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "TII", "->", "reMaterialize", "(", "*", "InsertPos", "->", "getParent", "(", ")", ",", "InsertPos", ",", "Reg", ",", "Def", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getSubReg", "(", ")", ",", "*", "Def", ",", "*", "TRI", ")", ";", "MachineInstr", "*", "NewMI", "=", "&", "*", "(", "--", "InsertPos", ")", ";", "LIS", "->", "InsertMachineInstrInMaps", "(", "*", "NewMI", ")", ";", "LIS", "->", "removeInterval", "(", "Reg", ")", ";", "LIS", "->", "createAndComputeVirtRegInterval", "(", "Reg", ")", ";", "InsertedMIToOldDef", "[", "NewMI", "]", "=", "Def", ";", "updateRegionBoundaries", "(", "NewRegions", ",", "Def", ",", "nullptr", ",", "true", ")", ";", "updateRegionBoundaries", "(", "NewRegions", ",", "InsertPos", ",", "NewMI", ")", ";", "LaneBitmask", "PrevMask", "=", "NewLiveIns", "[", "I", "]", "[", "Reg", "]", ";", "for", "(", "auto", "Idx", ":", "RematDefToLiveInRegions", "[", "Def", "]", ")", "{", "NewLiveIns", "[", "Idx", "]", ".", "erase", "(", "Reg", ")", ";", "if", "(", "InsertPos", "->", "getParent", "(", ")", "!=", "Regions", "[", "Idx", "]", ".", "first", "->", "getParent", "(", ")", ")", "{", "NewPressure", "[", "Idx", "]", ".", "inc", "(", "Reg", ",", "PrevMask", ",", "LaneBitmask", "::", "getNone", "(", ")", ",", "MRI", ")", ";", "}", "else", "{", "GCNDownwardRPTracker", "RPT", "(", "*", "LIS", ")", ";", "auto", "*", "NonDbgMI", "=", "&", "*", "skipDebugInstructionsForward", "(", "NewRegions", "[", "Idx", "]", ".", "first", ",", "NewRegions", "[", "Idx", "]", ".", "second", ")", ";", "RPT", ".", "reset", "(", "*", "NonDbgMI", ",", "&", "NewLiveIns", "[", "Idx", "]", ")", ";", "RPT", ".", "advance", "(", "NewRegions", "[", "Idx", "]", ".", "second", ")", ";", "NewPressure", "[", "Idx", "]", "=", "RPT", ".", "moveMaxPressure", "(", ")", ";", "}", "}", "SinkedDefs", ".", "push_back", "(", "Def", ")", ";", "ImproveOccupancy", "=", "NewPressure", "[", "I", "]", ".", "getOccupancy", "(", "ST", ")", ";", "if", "(", "ImproveOccupancy", ">", "MinOccupancy", ")", "break", ";", "}", "for", "(", "auto", "&", "Def", ":", "SinkedDefs", ")", "for", "(", "auto", "TrackedIdx", ":", "RematDefToLiveInRegions", "[", "Def", "]", ")", "RematerializableInsts", "[", "TrackedIdx", "]", ".", "erase", "(", "Def", ")", ";", "if", "(", "ImproveOccupancy", "<=", "MinOccupancy", ")", "break", ";", "NewRescheduleRegions", "[", "I", "]", "=", "true", ";", "Improved", "=", "true", ";", "}", "if", "(", "!", "Improved", ")", "{", "for", "(", "auto", "&", "Entry", ":", "InsertedMIToOldDef", ")", "{", "MachineInstr", "*", "MI", "=", "Entry", ".", "first", ";", "MachineInstr", "*", "OldMI", "=", "Entry", ".", "second", ";", "Register", "Reg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "LIS", "->", "RemoveMachineInstrFromMaps", "(", "*", "MI", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "OldMI", "->", "clearRegisterDeads", "(", "Reg", ")", ";", "LIS", "->", "removeInterval", "(", "Reg", ")", ";", "LIS", "->", "createAndComputeVirtRegInterval", "(", "Reg", ")", ";", "}", "return", "false", ";", "}" ]

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

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

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

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

[ "_", "U", ",", "_", "_", "R", ")", ";" ]

[ "return", "(", "_", "_", "m512d", ")", "_", "_", "builtin_ia32_vfmsubpd512_mask3", "(", "(", "_", "_", "v8df", ")", "_", "_", "A", ",", "(", "_", "_", "v8df", ")", "_", "_", "B", ",", "(", "_", "_", "v8df", ")", "_", "_", "C", ",", "(", "_", "_", "mmask8", ")", "_" ]

[ "continue", ";" ]

[ "rtx_insn", "*", "scan", ";", "rtx_insn", "*", "barrier", "=", "find_barrier", "(", "num_mova", ",", "mova", ",", "insn", ")", ";", "rtx_insn", "*", "last_float_move", "=", "NULL", ";", "rtx", "last_float", "=", "<NUM_LIT>", ",", "*", "last_float_addr", "=", "NULL", ";", "int", "need_aligned_label", "=", "<NUM_LIT>", ";", "if", "(", "num_mova", "&&", "!", "mova_p", "(", "mova", ")", ")", "{", "insn", "=", "mova", ";", "num_mova", "=", "<NUM_LIT>", ";", "}", "for", "(", "scan", "=", "insn", ";", "scan", "!=", "barrier", ";", "scan", "=", "NEXT_INSN", "(", "scan", ")", ")", "{", "if", "(", "LABEL_P", "(", "scan", ")", ")", "last_float", "=", "<NUM_LIT>", ";", "if", "(", "NONJUMP_INSN_P", "(", "scan", ")", "&&", "recog_memoized", "(", "scan", ")", "==", "CODE_FOR_casesi_worker_2", ")", "need_aligned_label", "=", "<NUM_LIT>", ";", "if", "(", "broken_move", "(", "scan", ")", ")", "{", "rtx", "*", "patp", "=", "&", "PATTERN", "(", "scan", ")", ",", "pat", "=", "*", "patp", ";", "rtx", "src", ",", "dst", ";", "rtx", "lab", ";", "rtx", "new", "src", ";", "machine_mode", "mode", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "patp", "=", "&", "XVECEXP", "(", "pat", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ",", "pat", "=", "*", "patp", ";", "src", "=", "SET_SRC", "(", "pat", ")", ";", "dst", "=", "SET_DEST", "(", "pat", ")", ";", "mode", "=", "GET_MODE", "(", "dst", ")", ";", "if", "(", "mode", "==", "SImode", "&&", "satisfies_constraint_I16", "(", "src", ")", "&&", "REGNO", "(", "dst", ")", "!=", "FPUL_REG", ")", "{", "int", "offset", "=", "<NUM_LIT>", ";", "mode", "=", "HImode", ";", "while", "(", "GET_CODE", "(", "dst", ")", "==", "SUBREG", ")", "{", "offset", "+=", "subreg_regno_offset", "(", "REGNO", "(", "SUBREG_REG", "(", "dst", ")", ")", ",", "GET_MODE", "(", "SUBREG_REG", "(", "dst", ")", ")", ",", "SUBREG_BYTE", "(", "dst", ")", ",", "GET_MODE", "(", "dst", ")", ")", ";", "dst", "=", "SUBREG_REG", "(", "dst", ")", ";", "}", "dst", "=", "gen_rtx_REG", "(", "HImode", ",", "REGNO", "(", "dst", ")", "+", "offset", ")", ";", "}", "if", "(", "REG_P", "(", "dst", ")", "&&", "FP_ANY_REGISTER_P", "(", "REGNO", "(", "dst", ")", ")", ")", "{", "rtx", "*", "clobberp", "=", "&", "XVECEXP", "(", "PATTERN", "(", "scan", ")", ",", "<NUM_LIT>", ",", "XVECLEN", "(", "PATTERN", "(", "scan", ")", ",", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ")", ";", "rtx", "clobber", "=", "*", "clobberp", ";", "gcc_assert", "(", "GET_CODE", "(", "clobber", ")", "==", "CLOBBER", "&&", "rtx_equal_p", "(", "XEXP", "(", "clobber", ",", "<NUM_LIT>", ")", ",", "r0_rtx", ")", ")", ";", "if", "(", "last_float", "&&", "reg_set_between_p", "(", "r0_rtx", ",", "last_float_move", ",", "scan", ")", ")", "last_float", "=", "<NUM_LIT>", ";", "lab", "=", "add_constant", "(", "src", ",", "mode", ",", "last_float", ")", ";", "if", "(", "lab", ")", "emit_insn_before", "(", "gen_mova", "(", "lab", ")", ",", "scan", ")", ";", "else", "{", "rtx", "not", "e", "=", "find_regno_note", "(", "last_float_move", ",", "REG_UNUSED", ",", "<NUM_LIT>", ")", ";", "if", "(", "not", "e", ")", "PUT_REG_NOTE_KIND", "(", "not", "e", ",", "REG_INC", ")", ";", "*", "last_float_addr", "=", "r0_inc_rtx", ";", "}", "last_float_move", "=", "scan", ";", "last_float", "=", "src", ";", "new", "src", "=", "gen_const_mem", "(", "mode", ",", "(", "(", "(", "TARGET_SH4", "&&", "!", "TARGET_FMOVD", ")", "||", "REGNO", "(", "dst", ")", "==", "FPUL_REG", ")", "?", "r0_inc_rtx", ":", "r0_rtx", ")", ")", ";", "last_float_addr", "=", "&", "XEXP", "(", "new", "src", ",", "<NUM_LIT>", ")", ";", "*", "clobberp", "=", "gen_rtx_CLOBBER", "(", "GET_MODE", "(", "clobber", ")", ",", "gen_rtx_SCRATCH", "(", "Pmode", ")", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "UNSPEC", "&&", "XINT", "(", "src", ",", "<NUM_LIT>", ")", "==", "UNSPEC_MOVA", "&&", "GET_CODE", "(", "XVECEXP", "(", "src", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "==", "CONST", ")", "{", "lab", "=", "add_constant", "(", "XVECEXP", "(", "src", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ",", "mode", ",", "<NUM_LIT>", ")", ";", "new", "src", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "lab", ")", ";", "new", "src", "=", "gen_rtx_UNSPEC", "(", "SImode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "new", "src", ")", ",", "UNSPEC_MOVA", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "UNSPEC_VOLATILE", "&&", "XINT", "(", "src", ",", "<NUM_LIT>", ")", "==", "UNSPECV_SP_SWITCH_B", ")", "{", "new", "src", "=", "XVECEXP", "(", "src", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "XVECEXP", "(", "src", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "=", "gen_const_mem", "(", "mode", ",", "new", "src", ")", ";", "INSN_CODE", "(", "scan", ")", "=", "-", "<NUM_LIT>", ";" ]

[ "}" ]

[ "bool", "hasMiscellaneousExtensions3", "(", ")", "const", "{", "return", "HasMiscellaneousExtensions3", ";" ]

[ ";" ]

[ "LLT", "Ty", "=", "MRI", ".", "getType", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "if", "(", "Ty", "==", "LLT", "::", "scalar", "(", "<NUM_LIT>", ")", ")", "return", "legalizeFSQRTF32", "(", "MI", ",", "MRI", ",", "B", ")", ";", "if", "(", "Ty", "==", "LLT", "::", "scalar", "(", "<NUM_LIT>", ")", ")", "return", "legalizeFSQRTF64", "(", "MI", ",", "MRI", ",", "B", ")", ";", "if", "(", "Ty", "==", "LLT", "::", "scalar", "(", "<NUM_LIT>", ")", ")", "return", "legalizeFSQRTF16", "(", "MI", ",", "MRI", ",", "B", ")", ";", "return", "false" ]

[ "dest", ";" ]

[ "class", "VpuInstBinSwDI", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "RegisterClass", "Rdst", ",", "RegisterClass", "Rsrc1", ",", "Operand", "Isrc2", ",", "string", "asmstr", ",", "Operand", "Pred", ",", "list", "<", "dag", ">", "pattern", "=", "[", "]", ">", ":", "VectorInstBase", "<", "opc", ",", "asmstr", ">", "{", "let", "OutOperandList", "=", "(", "outs", "Rdst", ":", "$", "dest", ")", ";", "let", "InOperandList", "=", "(", "ins", "Rsrc1", ":", "$", "op1", ",", "TPCImm", "<", "Isrc2", ">", ":", "$", "op2", ",", "DataType", ":", "$", "optype", ",", "SwitchSet", ":", "$", "sw", ",", "RhazRsOp", ":", "$", "rhaz", ",", "Rdst", ":", "$", "income", ",", "Pred", ":", "$", "pred", ")", ";", "let", "Pattern", "=", "pattern", ";", "let", "Itinerary", "=", "IIC_VectorOp", ";", "bits", "<", "<NUM_LIT>", ">" ]

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

[ "[", "(", "parallel", "[", "(", "set", "(", "match_operand", ":", "VEC_GATHER_MODE", "<NUM_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "VEC_GATHER_MODE", "[", "(", "match_operand", ":", "<", "VEC_GATHER_SRCDI", ">", "<NUM_LIT>", "<STR_LIT>", ")", "(", "mem", ":", "<", "ssescalarmode", ">", "(", "match_par_dup", "<NUM_LIT>" ]

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

[ "def", ":", "InstAlias", "<", "<STR_LIT>", ",", "(", "USHLLv4i32_shift", "V128", ":", "$", "dst", ",", "V128", ":" ]

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

[ "let", "InOperandList", "=", "(", "ins", "Rsrc", ":", "$", "src", ",", "SwitchSet", ":", "$", "sw", ",", "Rdst", ":", "$", "income", ",", "Pred", ":", "$", "pred", ")", ";", "let", "Itinerary", "=", "IIC_LoadComplexOp", ";", "let", "isNotUsedInDisasm", "=", "!", "if", "(", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Rsrc", ")", ",", "<STR_LIT>", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "bits", "<", "<NUM_LIT>", ">", "dest", ";", "bits", "<", "<NUM_LIT>", ">", "src", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "SrcA", "=", "src", ";", "let", "SrcExtra", "=", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "dest", "}", ";", "let", "Switches", "=", "{", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ",", "<NUM_LIT>", "}", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-" ]

[ "int", "X86FrameLowering", "::", "getFrameIndexReferencePreferSP", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ",", "bool", "IgnoreSPUpdates", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", "&&", "TRI", "->", "needsStackRealignment", "(", "MF", ")", "&&", "!", "STI", ".", "isTargetWin64", "(", ")", ")", "return", "getFrameIndexReference", "(", "MF", ",", "FI", ",", "FrameReg", ")", ";", "if", "(", "!", "IgnoreSPUpdates", "&&", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "return", "getFrameIndexReference", "(", "MF", ",", "FI", ",", "FrameReg", ")", ";", "assert", "(", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getTCReturnAddrDelta", "(", ")", ">=", "<NUM_LIT>", "&&", "<STR_LIT>", "we don't handle this case!", "<STR_LIT>", ")", ";", "return", "getFrameIndexReferenceSP", "(", "MF", ",", "FI", ",", "FrameReg", ",", "StackSize", ")", ";", "}" ]

[ "Same", "as", "getFrameIndexReference", ",", "except", "that", "the", "stack", "pointer", "(", "as", "opposed", "to", "the", "frame", "pointer", ")", "will", "be", "the", "preferred", "value", "for", "FrameReg", "." ]

[ "SImode", ")" ]

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

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

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

[ "Mul", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "i32", ",", "N0", ",", "N1", ")", ";" ]

[ "SDValue", "Mul", ";", "if", "(", "Subtarget", "->", "hasMulU24", "(", ")", "&&", "isU24", "(", "N0", ",", "DAG", ")", "&&", "isU24", "(", "N1", ",", "DAG", ")", ")", "{", "N0", "=", "DAG", ".", "getZExtOrTrunc", "(", "N0", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "N1", "=", "DAG", ".", "getZExtOrTrunc", "(", "N1", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "Mul", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "i32", ",", "N0", ",", "N1", ")", ";", "}", "else", "if", "(", "Subtarget", "->", "hasMulI24", "(", ")", "&&", "isI24", "(", "N0", ",", "DAG", ")", "&&", "isI24", "(", "N1", ",", "DAG", ")", ")", "{", "N0", "=", "DAG", ".", "getSExtOrTrunc", "(", "N0", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "N1", "=", "DAG", ".", "getSExtOrTrunc", "(", "N1", ",", "DL", ",", "MVT", "::", "i32", ")", ";" ]

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

[ "for", "(", "unsigned", "i", "=", "SIndex", "+", "<NUM_LIT>", ",", "e", "=", "MemOps", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "int", "NewOffset", "=", "MemOps", "[", "i", "]", ".", "Offset", ";", "unsigned", "Reg", "=", "MemOps", "[", "i", "]", ".", "MBBI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "RegNum", "=", "ARMRegisterInfo", "::", "getRegisterNumbering", "(", "Reg", ")", ";", "isKill", "=", "MemOps", "[", "i", "]", ".", "MBBI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isKill", "(", ")", ";", "if", "(", "NewOffset", "==", "Offset", "+", "(", "int", ")", "Size", "&&", "(", "(", "isAM4", "&&", "RegNum", ">", "PRegNum", ")", "||", "RegNum", "==", "PRegNum", "+", "<NUM_LIT>", ")", ")", "{", "Offset", "+=", "Size", ";", "Regs", ".", "push_back", "(", "std", "::", "make_pair", "(", "Reg", ",", "isKill", ")", ")", ";", "PRegNum", "=", "RegNum", ";", "}", "else", "{", "if", "(", "mergeOps", "(", "MBB", ",", "++", "Loc", ",", "SOffset", ",", "Base", ",", "false", ",", "Opcode", ",", "Pred", ",", "PredReg", ",", "Scratch", ",", "Regs", ",", "TII", ")", ")", "{", "Merges", ".", "push_back", "(", "prior", "(", "Loc", ")", ")", ";", "for", "(", "unsigned", "j", "=", "SIndex", ";", "j", "<", "i", ";", "++", "j", ")", "{", "MBB", ".", "erase", "(", "MemOps", "[", "j", "]", ".", "MBBI", ")", ";", "MemOps", "[", "j", "]", ".", "Merged", "=", "true", ";", "}", "}", "SmallVector", "<", "MachineBasicBlock", "::", "iterator", ",", "<NUM_LIT>", ">", "Merges2", "=", "MergeLDR_STR", "(", "MBB", ",", "i", ",", "Base", ",", "Opcode", ",", "Size", ",", "Pred", ",", "PredReg", ",", "Scratch", ",", "MemOps", ")", ";", "Merges", ".", "append", "(", "Merges2", ".", "begin", "(", ")", ",", "Merges2", ".", "end", "(", ")", ")", ";", "return", "Merges", ";", "}", "if", "(", "MemOps", "[", "i", "]", ".", "Position", ">", "Pos", ")", "{", "Pos", "=", "MemOps", "[", "i", "]", ".", "Position", ";", "Loc", "=", "MemOps", "[", "i", "]", ".", "MBBI", ";", "}", "}", "bool", "BaseKill", "=", "Loc", "->", "findRegisterUseOperandIdx", "(", "Base", ",", "true" ]

[ "(", "lshiftrt", ":", "I48MODE" ]

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

[ "if", "(", "FrameReg", "==", "ARM", "::", "SP", ")", "emitThumbRegPlusImmInReg", "(", "MBB", ",", "II", ",", "dl", ",", "TmpReg", ",", "FrameReg", ",", "Offset", ",", "false", ",", "TII", ",", "*", "this", ")", ";" ]

[ "Offset", "-=", "AFI", "->", "getFramePtrSpillOffset", "(", ")", ";", "}", "else", "FrameReg", "=", "BasePtr", ";", "}", "if", "(", "RS", "&&", "FrameReg", "==", "ARM", "::", "SP", "&&", "RS", "->", "isScavengingFrameIndex", "(", "FrameIndex", ")", ")", "{", "assert", "(", "MF", ".", "getTarget", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "getFrameLowering", "(", ")", "->", "hasReservedCallFrame", "(", "MF", ")", "&&", "<STR_LIT>", "Cannot use SP to access the emergency spill slot in ", "<STR_LIT>", "<STR_LIT>", "functions without a reserved call frame", "<STR_LIT>", ")", ";", "assert", "(", "!", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", "&&", "<STR_LIT>", "Cannot use SP to access the emergency spill slot in ", "<STR_LIT>", "<STR_LIT>", "functions with variable sized frame objects", "<STR_LIT>", ")", ";", "}", "if", "(", "MI", ".", "isDebugValue", "(", ")", ")", "{", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "<NUM_LIT>", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "assert", "(", "AFI", "->", "isThumbFunction", "(", ")", "&&", "<STR_LIT>", "This eliminateFrameIndex only supports Thumb1!", "<STR_LIT>", ")", ";", "if", "(", "rewriteFrameIndex", "(", "MI", ",", "FIOperandNum", ",", "FrameReg", ",", "Offset", ",", "TII", ")", ")", "return", ";", "assert", "(", "Offset", "&&", "<STR_LIT>", "This code isn't needed if offset already handled!", "<STR_LIT>", ")", ";", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "int", "PIdx", "=", "MI", ".", "findFirstPredOperandIdx", "(", ")", ";", "if", "(", "PIdx", "!=", "-", "<NUM_LIT>", ")", "removeOperands", "(", "MI", ",", "PIdx", ")", ";", "if", "(", "MI", ".", "mayLoad", "(", ")", ")", "{", "unsigned", "TmpReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "bool", "UseRR", "=", "false", ";", "if", "(", "Opcode", "==", "ARM", "::", "tLDRspi", ")", "{" ]

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

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

[ "}", ";" ]

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

[ "static", "bool", "optimizeCall", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineInstr", "&", "MI", ",", "const", "MachineRegisterInfo", "&", "MRI", ",", "MachineDominatorTree", "&", "MDT", ",", "LiveIntervals", "&", "LIS", ",", "const", "WebAssemblyTargetLowering", "&", "TLI", ",", "const", "TargetLibraryInfo", "&", "LibInfo", ")", "{", "MachineOperand", "&", "Op1", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "Op1", ".", "isSymbol", "(", ")", ")", "return", "false", ";", "StringRef", "Name", "(", "Op1", ".", "getSymbolName", "(", ")", ")", ";", "bool", "callReturnsInput", "=", "Name", "==", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMCPY", ")", "||", "Name", "==", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMMOVE", ")", "||", "Name", "==", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMSET", ")", ";", "if", "(", "!", "callReturnsInput", ")", "return", "false", ";", "LibFunc", "Func", ";", "if", "(", "!", "LibInfo", ".", "getLibFunc", "(", "Name", ",", "Func", ")", ")", "return", "false", ";", "unsigned", "FromReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "ToReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "MRI", ".", "getRegClass", "(", "FromReg", ")", "!=", "MRI", ".", "getRegClass", "(", "ToReg", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "Store results: call to builtin function with wrong ", "<STR_LIT>", "<STR_LIT>", "signature, from/to mismatch", "<STR_LIT>", ")", ";", "return", "ReplaceDominatedUses", "(", "MBB", ",", "MI", ",", "FromReg", ",", "ToReg", ",", "MRI", ",", "MDT", ",", "LIS", ")", ";", "}" ]

[ "optimizeCall", "-", "Take", "the", "given", "call", "instruction", "and", "return", "a", "more", "optimal", "value", "to", "replace", "the", "instruction", "with", "or", "0", "if", "a", "more", "optimal", "form", "ca", "n't", "be", "found", "." ]

[ "}" ]

[ "subrtx_ptr_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX_PTR", "(", "iter", ",", "array", ",", "&", "PATTERN", "(", "insn", ")", ",", "ALL", ")", "{", "rtx", "*", "loc", "=", "*", "iter", ";", "if", "(", "force_to_mem_operand", "(", "*", "loc", ",", "Pmode", ")", ")", "{", "rtx", "mem", "=", "force_const_mem", "(", "GET_MODE", "(", "*", "loc", ")", ",", "*", "loc", ")", ";", "validate_change", "(", "insn", ",", "loc", ",", "mem", ",", "false", ")", ";", "}", "if", "(", "MEM_P", "(", "*", "loc", ")", ")", "{", "mips16_rewrite_pool_constant", "(", "pool", ",", "&", "XEXP", "(", "*", "loc", ",", "<NUM_LIT>", ")", ")", ";", "iter", ".", "skip_subrtxes", "(", ")", ";", "}", "else", "{", "if", "(", "TARGET_MIPS16_TEXT_LOADS", ")", "mips16_rewrite_pool_constant", "(", "pool", ",", "loc", ")", ";", "if", "(", "GET_CODE", "(", "*", "loc", ")", "==", "CONST", "||", "(", "GET_CODE", "(", "*", "loc", ")", "==", "UNSPEC", "&&", "XINT", "(", "*", "loc", ",", "<NUM_LIT>", ")", "==", "UNSPEC_TLS_GET_TP", ")", ")", "iter", ".", "skip_subrtxes", "(", ")", ";", "}" ]

[ "}" ]

[ "return", "(", "uint32x4_t", ")", "(", "vabsq_f32", "(", "_", "_", "a", ")", "<", "vabsq_f32", "(", "_", "_", "b", ")", ")", ";", "return", "(", "uint32x4_t", ")", "_", "_", "builtin_neon_vcagtv4sf", "(", "_", "_", "b", ",", "_", "_", "a", ")", ";" ]

[ "<FIXS>", "return", "DAG", ".", "getMemIntrinsicNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "Op", "->", "getVTList", "(", ")", ",", "Ops", ",", "VT", ",", "AtomicNode", "->", "getMemOperand", "(", ")", ")", ";", "<FIXE>" ]

[ "SDValue", "NewOld", "=", "DAG", ".", "getBuildVector", "(", "VecType", ",", "DL", ",", "{", "New", ",", "Old", "}", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "ChainIn", ",", "Addr", ",", "NewOld", "}", ";", "<BUGS>", "SDVTList", "VTList", "=", "DAG", ".", "getVTList", "(", "VT", ",", "MVT", "::", "Other", ")", ";", "return", "DAG", ".", "getMemIntrinsicNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VTList", ",", "Ops", ",", "VT", ",", "AtomicNode", "->", "getMemOperand", "(", ")", ")", ";", "<BUGE>", "}" ]

[ ")", "return", "MCDisassembler", "::", "Fail", ";" ]

[ "static", "DecodeStatus", "DecodeMovePOperands", "(", "MCInst", "&", "Inst", ",", "unsigned", "Insn", ",", "uint64_t", "Address", ",", "const", "void", "*", "Decoder", ")", "{", "unsigned", "RegPair", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "if", "(", "DecodeMovePRegPair", "(", "Inst", ",", "RegPair", ",", "Address", ",", "Decoder", ")", "==", "MCDisassembler", "::", "Fail" ]

[ "plus_constant", "(", "ptr_mode", ",", "a_tramp", ",", "TRAMPOLINE_SIZE", ")", ",", "ptr_mode", ")", ";" ]

[ "mem", "=", "adjust_address", "(", "m_tramp", ",", "ptr_mode", ",", "tramp_code_sz", "+", "POINTER_BYTES", ")", ";", "emit_move_insn", "(", "mem", ",", "chain_value", ")", ";", "a_tramp", "=", "XEXP", "(", "m_tramp", ",", "<NUM_LIT>", ")", ";", "emit_library_call", "(", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "<STR_LIT>", "__clear_cache", "<STR_LIT>", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "a_tramp", ",", "ptr_mode", "," ]

[ "return", "static_cast", "<", "unsigned", ">", "(", "Offset", ")", ";" ]

[ "unsigned", "SPReg", ";", "int", "Offset", "=", "getFrameIndexReferencePreferSP", "(", "MF", ",", "Info", ".", "PSPSymFrameIdx", ",", "SPReg", ",", "true", ")", ";", "assert", "(", "Offset", ">=", "<NUM_LIT>", "&&", "SPReg", "==", "TRI", "->", "getStackRegister", "(", ")", ")", ";" ]

[ "<STR_LIT>", ")" ]

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

[ "<NUM_LIT>", ";" ]

[ "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseLongOffset", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "isExtended", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "DecoderNamespace", "=", "<STR_LIT>", ";", "let", "isExtendable", "=" ]

[ "}" ]

[ "else", "if", "(", "St", "->", "getValue", "(", ")", ".", "hasOneUse", "(", ")", "&&", "ChainVal", "->", "getOpcode", "(", ")", "==", "ISD", "::", "TokenFactor", ")", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "ChainVal", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "ChainVal", "->", "getOperand", "(", "i", ")", ".", "getNode", "(", ")", "==", "LdVal", ")", "{", "TokenFactorIndex", "=", "i", ";", "Ld", "=", "cast", "<", "LoadSDNode", ">", "(", "St", "->", "getValue", "(", ")", ")", ";", "}", "else", "Ops", ".", "push_back", "(", "ChainVal", "->", "getOperand", "(", "i", ")", ")", ";", "}", "}", "if", "(", "!", "Ld", "||", "!", "ISD", "::", "isNormalLoad", "(", "Ld", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "!", "VT", ".", "isVector", "(", ")", "&&", "!", "Ld", "->", "hasNUsesOfValue", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "return", "SDValue", "(", ")", ";", "DebugLoc", "LdDL", "=", "Ld", "->", "getDebugLoc", "(", ")", ";", "DebugLoc", "StDL", "=", "N", "->", "getDebugLoc", "(", ")", ";", "if", "(", "Subtarget", "->", "is64Bit", "(", ")", "||", "F64IsLegal", ")", "{", "EVT", "LdVT", "=", "Subtarget", "->", "is64Bit", "(", ")", "?", "MVT", "::", "i64", ":", "MVT", "::", "f64", ";", "SDValue", "NewLd", "=", "DAG", ".", "getLoad", "(", "LdVT", ",", "LdDL", ",", "Ld", "->", "getChain", "(", ")", ",", "Ld", "->", "getBasePtr", "(", ")", ",", "Ld", "->", "getPointerInfo", "(", ")", ",", "Ld", "->", "isVolatile", "(", ")", ",", "Ld", "->", "isNonTemporal", "(", ")", ",", "Ld", "->", "getAlignment", "(", ")", ")", ";", "SDValue", "NewChain", "=", "NewLd", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "if", "(", "TokenFactorIndex", "!=", "-", "<NUM_LIT>", ")", "{", "Ops", ".", "push_back", "(", "NewChain", ")", ";", "NewChain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "LdDL", ",", "MVT", "::", "Other", ",", "&", "Ops", "[", "<NUM_LIT>", "]", ",", "Ops", ".", "size", "(", ")", ")", ";", "}", "return", "DAG", ".", "getStore", "(", "NewChain", ",", "StDL", ",", "NewLd", ",", "St", "->", "getBasePtr", "(", ")", ",", "St", "->", "getPointerInfo", "(", ")", ",", "St", "->", "isVolatile", "(", ")", ",", "St", "->", "isNonTemporal", "(", ")", ",", "St", "->", "getAlignment", "(", ")", ")", ";" ]

[ "&", "getForwardedMustTailRegParms", "(", ")", "{" ]

[ "SmallVectorImpl", "<", "ForwardedRegister", ">" ]

[ "if", "(", "RC", "==", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";" ]

[ "DebugLoc", "dl", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";" ]

[ "<FIXS>", "void", "PPCPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "void", "PPCPassConfig", "::", "addPreSched2", "(", ")", "{", "addPass", "(", "createPPCVSXCopyCleanupPass", "(", ")", ",", "false", ")", ";", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "void", "PPCPassConfig", "::", "addPreEmitPass", "(", ")", "{", "<FIXE>", "<FIXS>", "addPass", "(", "createPPCEarlyReturnPass", "(", ")", ",", "false", ")", ";", "<FIXE>", "<FIXS>", "addPass", "(", "createPPCBranchSelectionPass", "(", ")", ",", "false", ")", ";", "<FIXE>" ]

[ "return", "false", ";", "}", "<BUGS>", "bool", "PPCPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "<BUGE>", "initializePPCVSXFMAMutatePass", "(", "*", "PassRegistry", "::", "getPassRegistry", "(", ")", ")", ";", "insertPass", "(", "VSXFMAMutateEarly", "?", "&", "RegisterCoalescerID", ":", "&", "MachineSchedulerID", ",", "&", "PPCVSXFMAMutateID", ")", ";", "<BUGS>", "return", "false", ";", "<BUGE>", "}", "<BUGS>", "bool", "PPCPassConfig", "::", "addPreSched2", "(", ")", "{", "addPass", "(", "createPPCVSXCopyCleanupPass", "(", ")", ")", ";", "<BUGE>", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "&", "IfConverterID", ")", ";", "<BUGS>", "return", "true", ";", "<BUGE>", "}", "<BUGS>", "bool", "PPCPassConfig", "::", "addPreEmitPass", "(", ")", "{", "<BUGE>", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "<BUGS>", "addPass", "(", "createPPCEarlyReturnPass", "(", ")", ")", ";", "<BUGE>", "<BUGS>", "addPass", "(", "createPPCBranchSelectionPass", "(", ")", ")", ";", "return", "false", ";", "<BUGE>", "}", "void", "PPCTargetMachine", "::", "addAnalysisPasses", "(", "PassManagerBase", "&", "PM", ")", "{" ]

[ "assert", "(", "RC", "->", "vt_end", "(", ")", "-", "RC", "->", "vt_begin", "(", ")", "==", "<NUM_LIT>", ")", ";" ]

[ "static", "MVT", "::", "SimpleValueType", "getRegTy", "(", "unsigned", "Reg", ",", "MachineFunction", "&", "MF", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "MF", ".", "getRegInfo", "(", ")", ".", "getRegClass", "(", "Reg", ")", ";" ]

[ "}" ]

[ "if", "(", "start", ">", "last", ")", "return", "insn", ";", "addr", "=", "plus_constant", "(", "Pmode", ",", "base", ",", "offset", "+", "(", "start", "-", "first", ")", "*", "UNITS_PER_LONG", ")", ";", "if", "(", "start", "==", "last", ")", "{", "if", "(", "TARGET_64BIT", ")", "not", "e", "=", "gen_movdi", "(", "gen_rtx_MEM", "(", "Pmode", ",", "addr", ")", ",", "gen_rtx_REG", "(", "Pmode", ",", "start", ")", ")", ";", "else", "not", "e", "=", "gen_movsi", "(", "gen_rtx_MEM", "(", "Pmode", ",", "addr", ")", ",", "gen_rtx_REG", "(", "Pmode", ",", "start", ")", ")", ";", "not", "e", "=", "PATTERN", "(", "not", "e", ")", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "not", "e", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "return", "insn", ";", "}", "not", "e", "=", "gen_store_multiple", "(", "gen_rtx_MEM", "(", "Pmode", ",", "addr", ")", ",", "gen_rtx_REG", "(", "Pmode", ",", "start", ")", ",", "GEN_INT", "(", "last", "-", "start", "+", "<NUM_LIT>", ")", ")", ";", "not", "e", "=", "PATTERN", "(", "not", "e", ")", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "not", "e", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "XVECLEN", "(", "not", "e", ",", "<NUM_LIT>", ")", ";", "i", "++", ")", "if", "(", "GET_CODE", "(", "XVECEXP", "(", "not", "e", ",", "<NUM_LIT>", ",", "i", ")", ")", "==", "SET", "&&", "!", "global_not_special_regno_p", "(", "REGNO", "(", "SET_SRC", "(", "XVECEXP", "(", "not", "e", ",", "<NUM_LIT>", ",", "i", ")", ")", ")", ")", ")", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "not", "e", ",", "<NUM_LIT>", ",", "i", ")", ")", "=", "<NUM_LIT>", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";" ]

[ "false", ";" ]

[ "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "getImm", "(", ")", ")", ";", "if", "(", "!", "CE", ")", "return" ]

[ "<FIXS>", "enum", "aarch_parse_opt_result", "ext_res", "<FIXE>", "<FIXS>", "if", "(", "ext_res", "!=", "AARCH_PARSE_OK", ")", "<FIXE>", "<FIXS>", "return", "AARCH_PARSE_OK", ";", "<FIXE>", "<FIXS>", "return", "AARCH_PARSE_INVALID_ARG", ";", "<FIXE>", "<FIXS>", "Return", "an", "aarch_parse_opt_result", "describing", "the", "parse", "result", ".", "<FIXE>", "<FIXS>", "static", "enum", "aarch_parse_opt_result", "<FIXE>" ]

[ "if", "(", "ext", "!=", "NULL", ")", "{", "<BUGS>", "enum", "aarch64_parse_opt_result", "ext_res", "<BUGE>", "aarch64_parse_extension", "(", "ext", ",", "&", "isa_temp", ",", "invalid_extension", ")", ";", "<BUGS>", "if", "(", "ext_res", "!=", "AARCH64_PARSE_OK", ")", "<BUGE>", "return", "ext_res", ";", "}", "*", "res", "=", "cpu", ";", "*", "isa_flags", "=", "isa_temp", ";", "<BUGS>", "return", "AARCH64_PARSE_OK", ";", "<BUGE>", "}", "}", "<BUGS>", "return", "AARCH64_PARSE_INVALID_ARG", ";", "<BUGE>", "}", "<BUGS>", "static", "enum", "aarch64_parse_opt_result", "<BUGE>", "aarch64_parse_tune", "(", "const", "char", "*", "to_parse", ",", "const", "struct", "processor", "*", "*", "res", ")", "{", "const", "struct", "processor", "*", "cpu", ";" ]

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

[ "def", "VBIFq", ":", "N3VX", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "QPR", ":", "$", "Vd", ")", ",", "(", "ins", "QPR", ":", "$", "src1", ",", "QPR", ":", "$", "Vn", ",", "QPR", ":", "$", "Vm", ")", ",", "N3RegFrm", ",", "IIC_VBINiQ", ",", "<STR_LIT>", "," ]

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

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

[ "<FIXS>", "case", "PPC", "::", "LXV", ":", "<FIXE>" ]

[ "case", "PPC", "::", "RESTORE_CRBIT", ":", "case", "PPC", "::", "LVX", ":", "case", "PPC", "::", "LXVD2X", ":", "<BUGS>", "case", "PPC", "::", "LXVX", ":", "<BUGE>", "case", "PPC", "::", "QVLFDX", ":", "case", "PPC", "::", "QVLFSXs", ":", "case", "PPC", "::", "QVLFDXb", ":" ]

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

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

[ "}" ]

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

[ "<FIXS>", "const", "APInt", "&", "Zeroable", ",", "const", "X86Subtarget", "&", "Subtarget", ",", "SelectionDAG", "&", "DAG", ")", "{", "<FIXE>" ]

[ "static", "SDValue", "lowerShuffleAsDecomposedShuffleMerge", "(", "const", "SDLoc", "&", "DL", ",", "MVT", "VT", ",", "SDValue", "V1", ",", "SDValue", "V2", ",", "ArrayRef", "int", ">", "Mask", ",", "<BUGS>", "const", "X86Subtarget", "&", "Subtarget", ",", "SelectionDAG", "&", "DAG", ")", "{", "<BUGE>", "int", "NumElts", "=", "Mask", ".", "size", "(", ")", ";", "int", "NumLanes", "=", "VT", ".", "getSizeInBits", "(", ")", "/", "<NUM_LIT>", ";", "int", "NumEltsPerLane", "=", "NumElts", "/", "NumLanes", ";" ]

[ "(", ")", ")", "return", "false", ";" ]

[ "auto", "I", "=", "TargetRegisterInfo", "::", "virtReg2Index", "(", "VReg", ")", ";", "if", "(", "I", ">=", "VRegStackified", ".", "size" ]

[ ")", ";" ]

[ "TargetRegistry", "::", "RegisterMCAsmInfo", "(", "TheOR1KTarget", ",", "createOR1KMCAsmInfo", ")", ";", "TargetRegistry", "::", "RegisterMCInstrInfo", "(", "TheOR1KTarget", ",", "createOR1KMCInstrInfo", ")", ";", "TargetRegistry", "::", "RegisterMCRegInfo", "(", "TheOR1KTarget", ",", "createOR1KMCRegisterInfo", ")", ";", "TargetRegistry", "::", "RegisterMCSubtargetInfo", "(", "TheOR1KTarget", ",", "createOR1KMCSubtargetInfo", ")", ";", "TargetRegistry", "::", "RegisterELFStreamer", "(", "TheOR1KTarget", ",", "createMCStreamer", ")", ";", "TargetRegistry", "::", "RegisterMCInstPrinter", "(", "TheOR1KTarget", ",", "createOR1KMCInstPrinter", ")", ";", "TargetRegistry", "::", "RegisterMCCodeEmitter", "(", "TheOR1KTarget", ",", "llvm", "::", "createOR1KMCCodeEmitter" ]

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

[ "union", "{", "int16x4x3_t", "_", "_", "i", ";", "_", "_", "builtin_neon_ei", "_", "_", "o", ";", "}", "_", "_", "rv", ";", "_", "_", "rv", ".", "_", "_", "o", "=", "_", "_", "builtin_neon_vld3v4hi", "(", "(", "const" ]

[ "<STR_LIT>", ";" ]

[ "const", "char", "*", "MipsTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "MipsISD::JmpLink", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "MipsISD::Hi", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "MipsISD::Lo", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "MipsISD::GPRel", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "MipsISD::Ret", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "MipsISD::SelectCC", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "MipsISD::FPSelectCC", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "MipsISD::FPBrcond", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "MipsISD::FPCmp", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "MipsISD::FPRound", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "MipsISD::MAdd", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "MipsISD::MAddu", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "MipsISD::MSub", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "MipsISD::MSubu" ]

[ "(", "instregex", "<STR_LIT>", ")", ">", ";" ]

[ "def", ":", "InstRW", "<", "[", "A64FXXWriteFSqrtSP", "]", "," ]

[ "}" ]

[ "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "return", "<NUM_LIT>", ";" ]

[ "}" ]

[ "vmulq_s32", "(", "int32x4_t", "_", "_", "a", ",", "int32x4_t", "_", "_", "b", ")", "{", "return", "_", "_", "a", "*", "_", "_", "b", ";" ]

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

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

[ "}" ]

[ "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "<STR_LIT>", "Z80old DAG->DAG Instruction Selection", "<STR_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", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "prefersSlot3", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "USR_OVF", "]", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "isCommutable", "=", "<NUM_LIT>", ";" ]

[ "bool", "WebAssemblyPrepareForLiveIntervals", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "{", "dbgs", "(", ")", "<<", "<STR_LIT>", "********** Prepare For LiveIntervals **********\\n", "<STR_LIT>", "<<", "<STR_LIT>", "********** Function: ", "<STR_LIT>", "<<", "MF", ".", "getName", "(", ")", "<<", "'", "\\n", "'", ";", "}", ")", ";", "bool", "Changed", "=", "false", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "auto", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "&", "Entry", "=", "*", "MF", ".", "begin", "(", ")", ";", "assert", "(", "!", "mustPreserveAnalysisID", "(", "LiveIntervalsID", ")", "&&", "<STR_LIT>", "LiveIntervals shouldn't be active yet!", "<STR_LIT>", ")", ";", "MRI", ".", "leaveSSA", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "MRI", ".", "getNumVirtRegs", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "TargetRegisterInfo", "::", "index2VirtReg", "(", "i", ")", ";", "if", "(", "MRI", ".", "use_nodbg_empty", "(", "Reg", ")", ")", "continue", ";", "if", "(", "HasArgumentDef", "(", "Reg", ",", "MRI", ")", ")", "continue", ";", "BuildMI", "(", "Entry", ",", "Entry", ".", "begin", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", ".", "get", "(", "WebAssembly", "::", "IMPLICIT_DEF", ")", ",", "Reg", ")", ";", "Changed", "=", "true", ";", "}", "for", "(", "auto", "MII", "=", "Entry", ".", "begin", "(", ")", ",", "MIE", "=", "Entry", ".", "end", "(", ")", ";", "MII", "!=", "MIE", ";", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MII", "++", ";", "if", "(", "WebAssembly", "::", "isArgument", "(", "MI", ")", ")", "{", "MI", ".", "removeFromParent", "(", ")", ";", "Entry", ".", "insert", "(", "Entry", ".", "begin", "(", ")", ",", "&", "MI", ")", ";", "}", "}", "MF", ".", "getProperties", "(", ")", ".", "set", "(", "MachineFunctionProperties", "::", "Property", "::", "TracksLiveness", ")", ";", "return", "Changed", ";", "}" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "{" ]

[ "unsigned", "Opc", "=", "LdSt", ".", "getOpcode", "(", ")", ";", "if", "(", "isDS", "(", "LdSt", ")", ")", "{", "const", "MachineOperand", "*", "OffsetImm", "=", "getNamedOperand", "(", "LdSt", ",", "AMDGPU", "::", "OpName", "::", "offset", ")", ";", "if", "(", "OffsetImm", ")", "{", "const", "MachineOperand", "*", "AddrReg", "=", "getNamedOperand", "(", "LdSt", ",", "AMDGPU", "::", "OpName", "::", "addr", ")", ";", "BaseReg", "=", "AddrReg", "->", "getReg", "(", ")", ";", "Offset", "=", "OffsetImm", "->", "getImm", "(", ")", ";", "return", "true", ";", "}", "const", "MachineOperand", "*", "Offset0Imm", "=", "getNamedOperand", "(", "LdSt", ",", "AMDGPU", "::", "OpName", "::", "offset0", ")", ";", "const", "MachineOperand", "*", "Offset1Imm", "=", "getNamedOperand", "(", "LdSt", ",", "AMDGPU", "::", "OpName", "::", "offset1", ")", ";", "uint8_t", "Offset0", "=", "Offset0Imm", "->", "getImm", "(", ")", ";", "uint8_t", "Offset1", "=", "Offset1Imm", "->", "getImm", "(", ")", ";", "if", "(", "Offset1", ">", "Offset0", "&&", "Offset1", "-", "Offset0", "==", "<NUM_LIT>", ")", "{", "unsigned", "EltSize", ";", "if", "(", "LdSt", ".", "mayLoad", "(", ")", ")", "EltSize", "=", "TRI", "->", "getRegSizeInBits", "(", "*", "getOpRegClass", "(", "LdSt", ",", "<NUM_LIT>", ")", ")", "/", "<NUM_LIT>", ";", "else", "{", "assert", "(", "LdSt", ".", "mayStore", "(", ")", ")", ";", "int", "Data0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "data0", ")", ";", "EltSize", "=", "TRI", "->", "getRegSizeInBits", "(", "*", "getOpRegClass", "(", "LdSt", ",", "Data0Idx", ")", ")", "/", "<NUM_LIT>", ";", "}", "if", "(", "isStride64", "(", "Opc", ")", ")", "EltSize", "*=", "<NUM_LIT>", ";", "const", "MachineOperand", "*", "AddrReg", "=", "getNamedOperand", "(", "LdSt", ",", "AMDGPU", "::", "OpName", "::", "addr", ")", ";", "BaseReg", "=", "AddrReg", "->", "getReg", "(", ")", ";", "Offset", "=", "EltSize", "*", "Offset0", ";", "return", "true", ";", "}", "return", "false", ";", "}", "if", "(", "isMUBUF", "(", "LdSt", ")", "||", "isMTBUF", "(", "LdSt", ")", ")", "{", "const", "MachineOperand", "*", "SOffset", "=", "getNamedOperand", "(", "LdSt", ",", "AMDGPU", "::", "OpName", "::", "soffset", ")", ";", "if", "(", "SOffset", "&&", "SOffset", "->", "isReg", "(", ")", ")", "return", "false", ";", "const", "MachineOperand", "*", "AddrReg", "=", "getNamedOperand", "(", "LdSt", ",", "AMDGPU", "::", "OpName", "::", "vaddr", ")", ";", "if", "(", "!", "AddrReg", ")", "return", "false", ";", "const", "MachineOperand", "*", "OffsetImm", "=", "getNamedOperand", "(", "LdSt", ",", "AMDGPU", "::", "OpName", "::", "offset", ")", ";", "BaseReg", "=", "AddrReg", "->", "getReg", "(", ")", ";", "Offset", "=", "OffsetImm", "->", "getImm", "(", ")", ";", "if", "(", "SOffset", ")", "Offset", "+=", "SOffset", "->", "getImm", "(", ")", ";", "return", "true", ";", "}", "if", "(", "isSMRD", "(", "LdSt", ")", ")", "{", "const", "MachineOperand", "*", "OffsetImm", "=", "getNamedOperand", "(", "LdSt", ",", "AMDGPU", "::", "OpName", "::", "offset", ")", ";", "if", "(", "!", "OffsetImm", ")", "return", "false", ";", "const", "MachineOperand", "*", "SBaseReg", "=", "getNamedOperand", "(", "LdSt", ",", "AMDGPU", "::", "OpName", "::", "sbase", ")", ";", "BaseReg", "=", "SBaseReg", "->", "getReg", "(", ")", ";", "Offset", "=", "OffsetImm", "->", "getImm", "(", ")", ";", "return", "true", ";", "}", "if", "(", "isFLAT", "(", "LdSt", ")", ")", "{", "const", "MachineOperand", "*", "VAddr", "=", "getNamedOperand", "(", "LdSt", ",", "AMDGPU", "::", "OpName", "::", "vaddr", ")", ";", "if", "(", "VAddr", ")", "{", "if", "(", "getNamedOperand", "(", "LdSt", ",", "AMDGPU", "::", "OpName", "::", "saddr", ")", ")", "return", "false", ";", "BaseReg", "=", "VAddr", "->", "getReg", "(", ")", ";", "}", "else" ]

[ ";" ]

[ "}", "if", "(", "!", "isImmTy", "(", "ImmTyNone", ")", ")", "{", "return", "false", ";", "}", "APInt", "Literal", "(", "<NUM_LIT>", ",", "Imm", ".", "Val", ")", ";", "if", "(", "Imm", ".", "IsFPImm", ")", "{", "if", "(", "type", "==", "MVT", "::", "f64", "||", "type", "==", "MVT", "::", "i64", ")", "{", "return", "AMDGPU", "::", "isInlinableLiteral64", "(", "Imm", ".", "Val", ",", "AsmParser", "->", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "APFloat", "FPLiteral", "(", "APFloat", "::", "IEEEdouble", "(", ")", ",", "APInt", "(", "<NUM_LIT>", ",", "Imm", ".", "Val", ")", ")", ";", "if", "(", "!", "canLosslesslyConvertToFPType", "(", "FPLiteral", ",", "type", ")", ")", "return", "false", ";", "if", "(", "type", ".", "getScalarSizeInBits", "(", ")", "==", "<NUM_LIT>", ")", "{", "return", "isInlineableLiteralOp16", "(", "static_cast", "<", "int16_t", ">", "(", "FPLiteral", ".", "bitcastToAPInt", "(", ")", ".", "getZExtValue", "(", ")", ")", ",", "type", ",", "AsmParser", "->", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "return", "AMDGPU", "::", "isInlinableLiteral32", "(", "static_cast", "<", "int32_t", ">", "(", "FPLiteral", ".", "bitcastToAPInt", "(", ")", ".", "getZExtValue", "(", ")", ")", ",", "AsmParser", "->", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "if", "(", "type", "==", "MVT", "::", "f64", "||", "type", "==", "MVT", "::", "i64", ")", "{", "return", "AMDGPU", "::", "isInlinableLiteral64", "(", "Imm", ".", "Val", ",", "AsmParser", "->", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "if", "(", "!", "isSafeTruncation", "(", "Imm", ".", "Val", ",", "type", ".", "getScalarSizeInBits", "(", ")", ")", ")", "{", "return", "false" ]

[ "PreservedAnalyses", "BPFASpaceCastSimplifyPass", "::", "run", "(", "Function", "&", "F", ",", "FunctionAnalysisManager", "&", "AM", ")", "{", "SmallVector", "<", "CastGEPCast", ",", "<NUM_LIT>", ">", "WorkList", ";", "bool", "Changed", "=", "false", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "{", "for", "(", "Instruction", "&", "I", ":", "BB", ")", "if", "(", "auto", "It", "=", "CastGEPCast", "::", "match", "(", "&", "I", ")", ")", "WorkList", ".", "push_back", "(", "It", ".", "value", "(", ")", ")", ";", "Changed", "|=", "!", "WorkList", ".", "empty", "(", ")", ";", "while", "(", "!", "WorkList", ".", "empty", "(", ")", ")", "{", "CastGEPCast", "InsnChain", "=", "WorkList", ".", "pop_back_val", "(", ")", ";", "GetElementPtrInst", "*", "NewGEP", "=", "InsnChain", ".", "rewrite", "(", ")", ";", "for", "(", "User", "*", "U", ":", "NewGEP", "->", "users", "(", ")", ")", "if", "(", "auto", "It", "=", "CastGEPCast", "::", "match", "(", "U", ")", ")", "WorkList", ".", "push_back", "(", "It", ".", "value", "(", ")", ")", ";", "}", "}", "return", "Changed", "?", "PreservedAnalyses", "::", "none", "(", ")", ":", "PreservedAnalyses", "::", "all", "(", ")", ";", "}" ]

[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]

[ ")", ")" ]

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

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

[ "OperandMatchResultTy", "Res", "=", "tryParseVectorRegister", "(", "RegNum", ",", "Kind", ",", "RegKind", "::", "SVEDataVector", ")", ";", "if", "(", "Res", "!=", "MatchOperand_Success", ")", "return", "Res", ";", "if", "(", "ParseSuffix", "&&", "Kind", ".", "empty", "(", ")", ")", "return", "MatchOperand_NoMatch", ";", "const", "auto", "&", "KindRes", "=", "parseVectorKind", "(", "Kind", ",", "RegKind", "::", "SVEDataVector", ")", ";", "if", "(", "!", "KindRes", ")", "return", "MatchOperand_NoMatch", ";", "unsigned", "ElementWidth", "=", "KindRes", "->", "second", ";", "if", "(", "!", "ParseShiftExtend", "||", "getParser", "(", ")", ".", "getTok", "(", ")", ".", "isNot", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Operands", ".", "push_back", "(", "AArch64Operand", "::", "CreateVectorReg", "(", "RegNum", ",", "RegKind", "::", "SVEDataVector", ",", "ElementWidth", ",", "S", ",", "S", ",", "getContext", "(", ")", ")", ")", ";", "return", "MatchOperand_Success", ";", "}", "getParser", "(", ")", ".", "Lex" ]

[ "}" ]

[ "else", "{", "ASM_OUTPUT_ALIGN", "(", "f", ",", "<NUM_LIT>", ")", ";", "fprintf", "(", "f", ",", "<STR_LIT>", "\\t.code\\t16\\n", "<STR_LIT>", ")", ";", "fprintf", "(", "f", ",", "<STR_LIT>", ".Ltrampoline_start:\\n", "<STR_LIT>", ")", ";", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "\\tpush\\t{r0, r1}\\n", "<STR_LIT>", ")", ";", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "\\tldr\\tr0, [%r, #8]\\n", "<STR_LIT>", ",", "PC_REGNUM", ")", ";", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "\\tmov\\t%r, r0\\n", "<STR_LIT>", ",", "STATIC_CHAIN_REGNUM", ")", ";", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "\\tldr\\tr0, [%r, #8]\\n", "<STR_LIT>", ",", "PC_REGNUM", ")", ";", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "\\tstr\\tr0, [%r, #4]\\n", "<STR_LIT>", ",", "SP_REGNUM", ")", ";", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "\\tpop\\t{r0, %r}\\n", "<STR_LIT>", ",", "PC_REGNUM", ")", ";", "}", "assemble_aligned_integer", "(", "UNITS_PER_WORD", ",", "const0_rtx", ")", ";", "assemble_aligned_integer", "(", "UNITS_PER_WORD", ",", "const0_rtx", ")", ";" ]

[ "<STR_LIT>" ]

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

[ "case", "X86", "::", "VPCMPUWZ128rrik", ":", "NewOpc", "=", "X86", "::", "VPCMPUWZ128rrik_alt", ";", "break", ";" ]

[ "case", "X86", "::", "VPCMPQZ128rmik", ":", "NewOpc", "=", "X86", "::", "VPCMPQZ128rmik_alt", ";", "break", ";", "case", "X86", "::", "VPCMPQZ128rri", ":", "NewOpc", "=", "X86", "::", "VPCMPQZ128rri_alt", ";", "break", ";", "case", "X86", "::", "VPCMPQZ128rrik", ":", "NewOpc", "=", "X86", "::", "VPCMPQZ128rrik_alt", ";", "break", ";", "case", "X86", "::", "VPCMPQZ256rmi", ":", "NewOpc", "=", "X86", "::", "VPCMPQZ256rmi_alt", ";", "break", ";", "case", "X86", "::", "VPCMPQZ256rmib", ":", "NewOpc", "=", "X86", "::", "VPCMPQZ256rmib_alt", ";", "break", ";", "case", "X86", "::", "VPCMPQZ256rmibk", ":", "NewOpc", "=", "X86", "::", "VPCMPQZ256rmibk_alt", ";", "break", ";", "case", "X86", "::", "VPCMPQZ256rmik", ":", "NewOpc", "=", "X86", "::", "VPCMPQZ256rmik_alt", ";", "break", ";", "case", "X86", "::", "VPCMPQZ256rri", ":", "NewOpc", "=", "X86", "::", "VPCMPQZ256rri_alt", ";", "break", ";", "case", "X86", "::", "VPCMPQZ256rrik", ":", "NewOpc", "=", "X86", "::", "VPCMPQZ256rrik_alt", ";", "break", ";", "case", "X86", "::", "VPCMPQZrmi", ":", "NewOpc", "=", "X86", "::", "VPCMPQZrmi_alt", ";", "break", ";", "case", "X86", "::", "VPCMPQZrmib", ":", "NewOpc", "=", "X86", "::", "VPCMPQZrmib_alt", ";", "break", ";", "case", "X86", "::", "VPCMPQZrmibk", ":", "NewOpc", "=", "X86", "::", "VPCMPQZrmibk_alt", ";", "break", ";", "case", "X86", "::", "VPCMPQZrmik", ":", "NewOpc", "=", "X86", "::", "VPCMPQZrmik_alt", ";", "break", ";", "case", "X86", "::", "VPCMPQZrri", ":", "NewOpc", "=", "X86", "::", "VPCMPQZrri_alt", ";", "break", ";", "case", "X86", "::", "VPCMPQZrrik", ":", "NewOpc", "=", "X86", "::", "VPCMPQZrrik_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUBZ128rmi", ":", "NewOpc", "=", "X86", "::", "VPCMPUBZ128rmi_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUBZ128rmik", ":", "NewOpc", "=", "X86", "::", "VPCMPUBZ128rmik_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUBZ128rri", ":", "NewOpc", "=", "X86", "::", "VPCMPUBZ128rri_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUBZ128rrik", ":", "NewOpc", "=", "X86", "::", "VPCMPUBZ128rrik_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUBZ256rmi", ":", "NewOpc", "=", "X86", "::", "VPCMPUBZ256rmi_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUBZ256rmik", ":", "NewOpc", "=", "X86", "::", "VPCMPUBZ256rmik_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUBZ256rri", ":", "NewOpc", "=", "X86", "::", "VPCMPUBZ256rri_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUBZ256rrik", ":", "NewOpc", "=", "X86", "::", "VPCMPUBZ256rrik_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUBZrmi", ":", "NewOpc", "=", "X86", "::", "VPCMPUBZrmi_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUBZrmik", ":", "NewOpc", "=", "X86", "::", "VPCMPUBZrmik_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUBZrri", ":", "NewOpc", "=", "X86", "::", "VPCMPUBZrri_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUBZrrik", ":", "NewOpc", "=", "X86", "::", "VPCMPUBZrrik_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUDZ128rmi", ":", "NewOpc", "=", "X86", "::", "VPCMPUDZ128rmi_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUDZ128rmib", ":", "NewOpc", "=", "X86", "::", "VPCMPUDZ128rmib_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUDZ128rmibk", ":", "NewOpc", "=", "X86", "::", "VPCMPUDZ128rmibk_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUDZ128rmik", ":", "NewOpc", "=", "X86", "::", "VPCMPUDZ128rmik_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUDZ128rri", ":", "NewOpc", "=", "X86", "::", "VPCMPUDZ128rri_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUDZ128rrik", ":", "NewOpc", "=", "X86", "::", "VPCMPUDZ128rrik_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUDZ256rmi", ":", "NewOpc", "=", "X86", "::", "VPCMPUDZ256rmi_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUDZ256rmib", ":", "NewOpc", "=", "X86", "::", "VPCMPUDZ256rmib_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUDZ256rmibk", ":", "NewOpc", "=", "X86", "::", "VPCMPUDZ256rmibk_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUDZ256rmik", ":", "NewOpc", "=", "X86", "::", "VPCMPUDZ256rmik_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUDZ256rri", ":", "NewOpc", "=", "X86", "::", "VPCMPUDZ256rri_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUDZ256rrik", ":", "NewOpc", "=", "X86", "::", "VPCMPUDZ256rrik_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUDZrmi", ":", "NewOpc", "=", "X86", "::", "VPCMPUDZrmi_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUDZrmib", ":", "NewOpc", "=", "X86", "::", "VPCMPUDZrmib_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUDZrmibk", ":", "NewOpc", "=", "X86", "::", "VPCMPUDZrmibk_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUDZrmik", ":", "NewOpc", "=", "X86", "::", "VPCMPUDZrmik_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUDZrri", ":", "NewOpc", "=", "X86", "::", "VPCMPUDZrri_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUDZrrik", ":", "NewOpc", "=", "X86", "::", "VPCMPUDZrrik_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUQZ128rmi", ":", "NewOpc", "=", "X86", "::", "VPCMPUQZ128rmi_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUQZ128rmib", ":", "NewOpc", "=", "X86", "::", "VPCMPUQZ128rmib_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUQZ128rmibk", ":", "NewOpc", "=", "X86", "::", "VPCMPUQZ128rmibk_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUQZ128rmik", ":", "NewOpc", "=", "X86", "::", "VPCMPUQZ128rmik_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUQZ128rri", ":", "NewOpc", "=", "X86", "::", "VPCMPUQZ128rri_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUQZ128rrik", ":", "NewOpc", "=", "X86", "::", "VPCMPUQZ128rrik_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUQZ256rmi", ":", "NewOpc", "=", "X86", "::", "VPCMPUQZ256rmi_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUQZ256rmib", ":", "NewOpc", "=", "X86", "::", "VPCMPUQZ256rmib_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUQZ256rmibk", ":", "NewOpc", "=", "X86", "::", "VPCMPUQZ256rmibk_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUQZ256rmik", ":", "NewOpc", "=", "X86", "::", "VPCMPUQZ256rmik_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUQZ256rri", ":", "NewOpc", "=", "X86", "::", "VPCMPUQZ256rri_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUQZ256rrik", ":", "NewOpc", "=", "X86", "::", "VPCMPUQZ256rrik_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUQZrmi", ":", "NewOpc", "=", "X86", "::", "VPCMPUQZrmi_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUQZrmib", ":", "NewOpc", "=", "X86", "::", "VPCMPUQZrmib_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUQZrmibk", ":", "NewOpc", "=", "X86", "::", "VPCMPUQZrmibk_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUQZrmik", ":", "NewOpc", "=", "X86", "::", "VPCMPUQZrmik_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUQZrri", ":", "NewOpc", "=", "X86", "::", "VPCMPUQZrri_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUQZrrik", ":", "NewOpc", "=", "X86", "::", "VPCMPUQZrrik_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUWZ128rmi", ":", "NewOpc", "=", "X86", "::", "VPCMPUWZ128rmi_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUWZ128rmik", ":", "NewOpc", "=", "X86", "::", "VPCMPUWZ128rmik_alt", ";", "break", ";", "case", "X86", "::", "VPCMPUWZ128rri", ":", "NewOpc", "=", "X86", "::", "VPCMPUWZ128rri_alt", ";", "break", ";" ]

[ "}" ]

[ "class", "BranchTarget", "<", "int", "N", ">", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", "#", "N", ";", "let", "DiagnosticType", "=", "<STR_LIT>", ";", "let", "PredicateMethod", "=", "<STR_LIT>", "#", "N", "#", "<STR_LIT>", ";" ]

[ "}" ]

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

[ ",", "Mask", ",", "PassThru", ")", ";" ]

[ "assert", "(", "!", "HVC", ".", "isUndef", "(", "Mask", ")", ")", ";", "if", "(", "HVC", ".", "isZero", "(", "Mask", ")", ")", "return", "PassThru", ";", "if", "(", "Mask", "==", "ConstantInt", "::", "getTrue", "(", "Mask", "->", "getType", "(", ")", ")", ")", "return", "Builder", ".", "CreateAlignedLoad", "(", "ValTy", ",", "Ptr", ",", "Align", "(", "Alignment", ")", ")", ";", "return", "Builder", ".", "CreateMaskedLoad", "(", "ValTy", ",", "Ptr", ",", "Align", "(", "Alignment", ")" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m512i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_maskz_cvttph_epu64", "(", "_", "_", "mmask8", "_", "_", "A", ",", "_", "_", "m128h", "_", "_", "B", ")", "{", "return", "_", "_", "builtin_ia32_vcvttph2uqq512_mask_round", "(", "_", "_", "B", ",", "_", "mm512_setzero_si512", "(", ")", ",", "_", "_", "A", ",", "_", "MM_FROUND_CUR_DIRECTION", ")", ";" ]

[ "if", "(", "!", "Check", "(", "S", ",", "DecodePredicateOperand", "(", "Inst", ",", "pred", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";" ]

[ "unsigned", "Rn", "=", "fieldFromInstruction32", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "unsigned", "Rt", "=", "fieldFromInstruction32", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "unsigned", "imm", "=", "fieldFromInstruction32", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "imm", "|=", "fieldFromInstruction32", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ";", "imm", "|=", "fieldFromInstruction32", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ";", "unsigned", "pred", "=", "fieldFromInstruction32", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "if", "(", "Rn", "==", "<NUM_LIT>", "||", "Rn", "==", "Rt", ")", "S", "=", "MCDisassembler", "::", "SoftFail", ";", "if", "(", "!", "Check", "(", "S", ",", "DecodeGPRRegisterClass", "(", "Inst", ",", "Rn", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "if", "(", "!", "Check", "(", "S", ",", "DecodeGPRRegisterClass", "(", "Inst", ",", "Rt", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "if", "(", "!", "Check", "(", "S", ",", "DecodeSORegMemOperand", "(", "Inst", ",", "imm", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";" ]

[ "<FIXS>", "EnclosedEdges", "[", "Reg", "]", "=", "C", ".", "getID", "(", ")", ";", "<FIXE>", "<FIXS>", "if", "(", "!", "encloseInstr", "(", "C", ",", "DefMI", ")", ")", "return", ";", "<FIXE>" ]

[ "if", "(", "!", "C", ".", "insertEdge", "(", "CurReg", ")", ")", "continue", ";", "<BUGS>", "EnclosedEdges", ".", "set", "(", "Register", "::", "virtReg2Index", "(", "Reg", ")", ")", ";", "<BUGE>", "MachineInstr", "*", "DefMI", "=", "MRI", "->", "getVRegDef", "(", "CurReg", ")", ";", "<BUGS>", "encloseInstr", "(", "C", ",", "DefMI", ")", ";", "<BUGE>" ]

[ ")", ",", "(", "v2f32", "VPR64", ":", "$", "src", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v2f32", "(", "bitconvert", "(", "v1i64", "VPR64", ":", "$", "src", ")", ")" ]

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

[ "def", "SImm9Operand", ":", "SImmOperand", "<" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Pg", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zd", ";" ]

[ "PPCTLSRegOperand", ";" ]

[ "def", "tlsreg32", ":", "Operand", "<", "i32", ">", "{", "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=" ]

[ "aarch64_neon_ld3lane", ":" ]

[ "return", "performAddSubLongCombine", "(", "N", ",", "DCI", ",", "DAG", ")", ";", "case", "ISD", "::", "XOR", ":", "return", "performXorCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "performMulCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "performIntToFpCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "case", "ISD", "::", "FP_TO_UINT", ":", "return", "performFpToIntCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "FDIV", ":", "return", "performFDivCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "OR", ":", "return", "performORCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SRL", ":", "return", "performSRLCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "performIntrinsicCombine", "(", "N", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "ANY_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND", ":", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "performExtendCombine", "(", "N", ",", "DCI", ",", "DAG", ")", ";", "case", "ISD", "::", "BITCAST", ":", "return", "performBitcastCombine", "(", "N", ",", "DCI", ",", "DAG", ")", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "performConcatVectorsCombine", "(", "N", ",", "DCI", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "performSelectCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "VSELECT", ":", "return", "performVSelectCombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "if", "(", "performTBISimplification", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "DCI", ",", "DAG", ")", ")", "return", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ";", "break", ";", "case", "ISD", "::", "STORE", ":", "return", "performSTORECombine", "(", "N", ",", "DCI", ",", "DAG", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "performBRCONDCombine", "(", "N", ",", "DCI", ",", "DAG", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "performTBZCombine", "(", "N", ",", "DCI", ",", "DAG", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "performCONDCombine", "(", "N", ",", "DCI", ",", "DAG", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "performPostLD1Combine", "(", "N", ",", "DCI", ",", "false", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "performNVCASTCombine", "(", "N", ")", ";", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "performPostLD1Combine", "(", "N", ",", "DCI", ",", "true", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "switch", "(", "cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ")", "{", "case", "Intrinsic", "::", "aarch64_neon_ld2", ":", "case", "Intrinsic", "::", "aarch64_neon_ld3", ":", "case", "Intrinsic", "::", "aarch64_neon_ld4", ":", "case", "Intrinsic", "::", "aarch64_neon_ld1x2", ":", "case", "Intrinsic", "::", "aarch64_neon_ld1x3", ":", "case", "Intrinsic", "::", "aarch64_neon_ld1x4", ":", "case", "Intrinsic", "::", "aarch64_neon_ld2lane", ":", "case", "Intrinsic", "::" ]

[ ")" ]

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