Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "}" ]

[ "for", "(", "Argument", "&", "Arg", ":", "Func", "->", "args", "(", ")", ")", "visitValue", "(", "&", "Arg", ",", "Arg", ".", "getType", "(", ")", ")", ";", "visit", "(", "Func", ")", ";" ]

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

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

[ "}" ]

[ "case", "ISD", "::", "MSTORE", ":", "return", "<NUM_LIT>", ";", "case", "ISD", "::", "MLOAD", ":", "return", "<NUM_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<NUM_LIT>", ";" ]

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

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

[ "}" ]

[ "let", "SrcA", "=", "src", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";", "let", "Switches", "=", "{", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ",", "dim", "}", ";", "let", "Switches", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Constraints", "=", "<STR_LIT>", ";" ]

[ "}" ]

[ "return", "false", ";", "}", "if", "(", "!", "TREE_ASM_WRITTEN", "(", "key", ")", ")", "{", "print_node_brief", "(", "stderr", ",", "<STR_LIT>", "<STR_LIT>", ",", "ctype", ",", "<NUM_LIT>", ")", ";", "fprintf", "(", "stderr", ",", "<STR_LIT>", " does NOT need to be EXPORTed [key function not defined]\\n", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "inline_ctor_dtor", "=", "false", ";", "dllimport_ctor_dtor", "=", "false", ";", "dllimport_member", "=", "false", ";", "method_vec", "=", "CLASSTYPE_METHOD_VEC", "(", "ctype", ")", ";", "len", "=", "method_vec", "?", "VEC_length", "(", "tree", ",", "method_vec", ")", ":", "<NUM_LIT>", ";", "for", "(", ";", "len", "--", ";", ")", "{", "tree", "member", "=", "VEC_index", "(", "tree", ",", "method_vec", ",", "len", ")", ";", "if", "(", "!", "member", ")", "continue", ";", "for", "(", "member", "=", "OVL_CURRENT", "(", "member", ")", ";", "member", ";", "member", "=", "OVL_NEXT", "(", "member", ")", ")", "{", "if", "(", "TREE_CODE", "(", "member", ")", "!=", "FUNCTION_DECL", ")", "continue", ";", "if", "(", "DECL_CONSTRUCTOR_P", "(", "member", ")", "||", "DECL_DESTRUCTOR_P", "(", "member", ")", ")", "{", "if", "(", "DECL_INLINE", "(", "member", ")", "&&", "(", "DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P", "(", "member", ")", "||", "DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P", "(", "member", ")", ")", ")", "inline_ctor_dtor", "=", "true", ";", "if", "(", "lookup_attribute", "(", "<STR_LIT>", "dllimport", "<STR_LIT>", ",", "DECL_ATTRIBUTES", "(", "member", ")", ")", ")", "dllimport_ctor_dtor", "=", "true", ";", "}", "else", "{", "if", "(", "DECL_PURE_VIRTUAL_P", "(", "member", ")", ")", "continue", ";", "if", "(", "!", "DECL_VIRTUAL_P", "(", "member", ")", ")", "continue", ";", "if", "(", "DECL_INLINE", "(", "member", ")", ")", "continue", ";", "if", "(", "lookup_attribute", "(", "<STR_LIT>", "dllimport", "<STR_LIT>", ",", "DECL_ATTRIBUTES", "(", "member", ")", ")", ")", "dllimport_member", "=", "true", ";", "}" ]

[ "return", "Base", ";" ]

[ "unsigned", "GetBase", "(", ")", "{", "assert", "(", "Base", ")", ";" ]

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

[ "(", "match_dup", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<BUGS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "reg", "<NUM_LIT>", ")" ]

[ "(", "eq_attr", "<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>", ")" ]

[ "<FIXS>", "case", "ARM", "::", "LDR_PRE_IMM", ":", "case", "ARM", "::", "LDR_PRE_REG", ":", "<FIXE>", "<FIXS>", "case", "ARM", "::", "LDRB_PRE_IMM", ":", "case", "ARM", "::", "LDRB_PRE_REG", ":", "<FIXE>" ]

[ "unsigned", "ARMInstrInfo", "::", "getUnindexedOpcode", "(", "unsigned", "Opc", ")", "const", "{", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "<BUGS>", "case", "ARM", "::", "LDR_PRE", ":", "<BUGE>", "case", "ARM", "::", "LDR_POST_IMM", ":", "case", "ARM", "::", "LDR_POST_REG", ":", "return", "ARM", "::", "LDRi12", ";", "case", "ARM", "::", "LDRH_PRE", ":", "case", "ARM", "::", "LDRH_POST", ":", "return", "ARM", "::", "LDRH", ";", "<BUGS>", "case", "ARM", "::", "LDRB_PRE", ":", "<BUGE>", "case", "ARM", "::", "LDRB_POST_IMM", ":", "case", "ARM", "::", "LDRB_POST_REG", ":", "return", "ARM", "::", "LDRBi12", ";" ]

[ "(", "sext_inreg", "R32C", ":", "$", "rA", ",", "i16", ")", ",", "(", "sext_inreg", "R32C", ":", "$", "rB", ",", "i16", ")", ")", ",", "R32C", ":", "$", "rC", ")", ")", "]", ">", ";" ]

[ "def", "MPYAr32_sextinreg", ":", "MPYAInst", "<", "(", "outs", "R32C", ":", "$", "rT", ")", ",", "(", "ins", "R32C", ":", "$", "rA", ",", "R32C", ":", "$", "rB", ",", "R32C", ":", "$", "rC", ")", ",", "[", "(", "set", "R32C", ":", "$", "rT", ",", "(", "add", "(", "mul" ]

[ "<STR_LIT>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "\t", "\t", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "plus", ":", "SI", "(", "ne", ":", "SI", "(", "reg", ":", "CC", "CSKY_CC_REGNUM", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "plus", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "(", "set", "(", "reg", ":", "CC", "CSKY_CC_REGNUM", ")", "(", "compare", ":", "CC", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>" ]

[ ";" ]

[ "if", "(", "GET_CODE", "(", "addr_op0", ")", "==", "REG", "&&", "CONSTANT_P", "(", "addr_op1", ")", ")", "{", "rtx", "reg", "=", "frv_ifcvt_load_value", "(", "addr_op1", ",", "insn", ")", ";", "if", "(", "!", "reg", ")", "return", "NULL_RTX", ";", "addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "addr_op0", ",", "reg", ")", ";", "}", "else", "return", "NULL_RTX", ";", "}", "else", "if", "(", "CONSTANT_P", "(", "addr", ")", ")", "addr", "=", "frv_ifcvt_load_value", "(", "addr", ",", "insn", ")", ";", "else", "return", "NULL_RTX" ]

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

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

[ "<STR_LIT>" ]

[ "UNSPEC_VUZP1", ")", ")", "(", "set", "(", "match_operand", ":", "VDQW", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "VDQW", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "UNSPEC_VUZP2", ")", ")", "]", ")", "]", "<STR_LIT>" ]

[ ":", "VDI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

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

[ ">", ";" ]

[ "def", "SImm4s3Operand", ":", "SImmScaledMemoryIndexed", "<", "<NUM_LIT>", ",", "<NUM_LIT>" ]

[ "!", "pa_cint_ok_for_move", "(", "UINTVAL", "(", "x", ")", ")", ")", "return", "false", ";" ]

[ "if", "(", "TARGET_64BIT", "&&", "HOST_BITS_PER_WIDE_INT", ">", "<NUM_LIT>", "&&", "GET_CODE", "(", "x", ")", "==", "CONST_INT", "&&", "!", "reload_in_progress", "&&", "!", "reload_completed", "&&", "!", "LEGITIMATE_64BIT_CONST_INT_P", "(", "INTVAL", "(", "x", ")", ")", "&&" ]

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

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

[ "DL", ",", "MVT", "::", "i32", ")", ",", "<NUM_LIT>", ",", "false", ",", "false", ",", "false", ",", "MachinePointerInfo", "(", "DestSV", ")", ",", "MachinePointerInfo", "(", "SrcSV", ")", ")", ";" ]

[ "return", "DAG", ".", "getMemcpy", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DL", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "VaListSize", "," ]

[ "bool", "arm_simd_check_vect_par_cnst_half_p", "(", "rtx", "op", ",", "machine_mode", "mode", ",", "bool", "high", ")", "{", "rtx", "ideal", "=", "arm_simd_vect_par_cnst_half", "(", "mode", ",", "high", ")", ";", "HOST_WIDE_INT", "count_op", "=", "XVECLEN", "(", "op", ",", "<NUM_LIT>", ")", ";", "HOST_WIDE_INT", "count_ideal", "=", "XVECLEN", "(", "ideal", ",", "<NUM_LIT>", ")", ";", "int", "i", "=", "<NUM_LIT>", ";", "if", "(", "!", "VECTOR_MODE_P", "(", "mode", ")", ")", "return", "false", ";", "if", "(", "count_op", "!=", "count_ideal", ")", "return", "false", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "count_ideal", ";", "i", "++", ")", "{", "rtx", "elt_op", "=", "XVECEXP", "(", "op", ",", "<NUM_LIT>", ",", "i", ")", ";", "rtx", "elt_ideal", "=", "XVECEXP", "(", "ideal", ",", "<NUM_LIT>", ",", "i", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "elt_op", ")", "||", "INTVAL", "(", "elt_ideal", ")", "!=", "INTVAL", "(", "elt_op", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "Check", "OP", "for", "validity", "as", "a", "PARALLEL", "RTX", "vector", "with", "elements", "numbering", "the", "lanes", "of", "either", "the", "high", "(", "HIGH", "==", "TRUE", ")", "or", "low", "lanes", ",", "from", "the", "perspective", "of", "the", "architecture", ".", "See", "the", "diagram", "above", "arm_simd_vect_par_cnst_half_p", "for", "more", "details", "." ]

[ ",", "<NUM_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "v4f32", ",", "v4i32", ",", "sint_to_fp", ">", ";" ]

[ "def", "VCVTs2fq", ":", "N2VQ", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>" ]

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

[ "void", "OptimizePICCall", "::", "incCntAndSetReg", "(", "const", "Value", "*", "Entry", ",", "unsigned", "Reg", ")", "{", "CntRegP", "P", "=", "ScopedHT", ".", "lookup", "(", "Entry", ")", ";", "ScopedHT", ".", "insert", "(", "Entry", ",", "std", "::", "make_pair", "(", "P", ".", "first", "+", "<NUM_LIT>", "," ]

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

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

[ "<STR_LIT>" ]

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

[ "<STR_LIT>", ")" ]

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

[ "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasPersonalityFn", "(", ")", ")", "{" ]

[ "bool", "WebAssemblyLateEHPrepare", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "********** Late EH Prepare **********\\n", "<STR_LIT>", "<STR_LIT>", "********** Function: ", "<STR_LIT>", "<<", "MF", ".", "getName", "(", ")", "<<", "'", "\\n", "'", ")", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", "->", "getExceptionHandlingType", "(", ")", "!=", "ExceptionHandling", "::", "Wasm", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";" ]

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

[ "set_optab_libfunc", "(", "sdiv_optab", ",", "TFmode", ",", "<STR_LIT>", "_U_Qfdiv", "<STR_LIT>", ")", ";", "set_optab_libfunc", "(", "neg_optab", ",", "TFmode", ",", "<STR_LIT>", "_U_Qfneg", "<STR_LIT>", ")", ";", "set_conv_libfunc", "(", "sext_optab", ",", "TFmode", ",", "SFmode", ",", "<STR_LIT>", "_U_Qfcnvff_sgl_to_quad", "<STR_LIT>", ")", ";", "set_conv_libfunc", "(", "sext_optab", ",", "TFmode", ",", "DFmode", ",", "<STR_LIT>", "_U_Qfcnvff_dbl_to_quad", "<STR_LIT>", ")", ";", "set_conv_libfunc", "(", "sext_optab", ",", "TFmode", ",", "XFmode", ",", "<STR_LIT>", "_U_Qfcnvff_f80_to_quad", "<STR_LIT>", ")", ";", "set_conv_libfunc", "(", "trunc_optab", ",", "SFmode", ",", "TFmode", ",", "<STR_LIT>", "_U_Qfcnvff_quad_to_sgl", "<STR_LIT>", ")", ";", "set_conv_libfunc", "(", "trunc_optab", ",", "DFmode", ",", "TFmode", ",", "<STR_LIT>", "_U_Qfcnvff_quad_to_dbl", "<STR_LIT>", ")", ";", "set_conv_libfunc", "(", "trunc_optab", ",", "XFmode", ",", "TFmode", ",", "<STR_LIT>", "_U_Qfcnvff_quad_to_f80", "<STR_LIT>", ")", ";", "set_conv_libfunc", "(", "sfix_optab", ",", "SImode", ",", "TFmode", ",", "<STR_LIT>", "_U_Qfcnvfxt_quad_to_sgl", "<STR_LIT>", ")", ";", "set_conv_libfunc", "(", "sfix_optab", ",", "DImode", ",", "TFmode", ",", "<STR_LIT>", "_U_Qfcnvfxt_quad_to_dbl", "<STR_LIT>", ")", ";", "set_conv_libfunc", "(", "sfix_optab", ",", "TImode", ",", "TFmode", ",", "<STR_LIT>", "_U_Qfcnvfxt_quad_to_quad", "<STR_LIT>", ")", ";", "set_conv_libfunc", "(", "ufix_optab", ",", "SImode", ",", "TFmode", ",", "<STR_LIT>", "_U_Qfcnvfxut_quad_to_sgl", "<STR_LIT>", ")", ";", "set_conv_libfunc", "(", "ufix_optab", ",", "DImode", ",", "TFmode", ",", "<STR_LIT>", "_U_Qfcnvfxut_quad_to_dbl", "<STR_LIT>", ")", ";", "set_conv_libfunc", "(", "sfloat_optab", ",", "TFmode", ",", "SImode", ",", "<STR_LIT>", "_U_Qfcnvxf_sgl_to_quad", "<STR_LIT>", ")", ";", "set_conv_libfunc", "(", "sfloat_optab", ",", "TFmode", ",", "DImode", ",", "<STR_LIT>", "_U_Qfcnvxf_dbl_to_quad", "<STR_LIT>", ")", ";", "set_conv_libfunc", "(", "sfloat_optab", ",", "TFmode", ",", "TImode", ",", "<STR_LIT>", "_U_Qfcnvxf_quad_to_quad", "<STR_LIT>", ")", ";", "set_conv_libfunc", "(", "ufloat_optab", ",", "TFmode", ",", "DImode", "," ]

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

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

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

[ "_", "_", "arm_vshlq_s16", "(", "int16x8_t", "_", "_", "a", ",", "int16x8_t", "_", "_", "b", ")", "{", "return", "_", "_", "builtin_mve_vshlq_sv8hi", "(", "_", "_", "a", ",", "_" ]

[ "_", "c", ")", ";" ]

[ "_", "_", "builtin_neon_vst1_lanev2di", "(", "(", "_", "_", "builtin_neon_di", "*", ")", "_", "_", "a", ",", "(", "int64x2_t", ")", "_", "_", "b", ",", "_" ]

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

[ "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "zero_extract", ":", "DI", "(", "subreg", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")" ]

[ "}" ]

[ "hsa_fns", ".", "hsa_region_get_info_fn", "(", "region", ",", "HSA_REGION_INFO_GLOBAL_FLAGS", ",", "&", "flags", ")", ";", "if", "(", "flags", "&", "HSA_REGION_GLOBAL_FLAG_KERNARG", ")", "{", "kernargs_region", "=", "region", ";", "return", "HSA_STATUS_INFO_BREAK", ";" ]

[ "static", "void", "s390_dump_pool", "(", "struct", "constant_pool", "*", "pool", ",", "bool", "remote_label", ")", "{", "struct", "constant", "*", "c", ";", "rtx", "insn", "=", "pool", "->", "pool_insn", ";", "int", "i", ";", "if", "(", "TARGET_CPU_ZARCH", ")", "{", "insn", "=", "emit_insn_after", "(", "gen_pool_section_start", "(", ")", ",", "insn", ")", ";", "INSN_ADDRESSES_NEW", "(", "insn", ",", "-", "<NUM_LIT>", ")", ";", "}", "if", "(", "TARGET_CPU_ZARCH", ")", "insn", "=", "emit_insn_after", "(", "gen_pool_align", "(", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ",", "insn", ")", ";", "else", "insn", "=", "emit_insn_after", "(", "gen_pool_align", "(", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ",", "insn", ")", ";", "INSN_ADDRESSES_NEW", "(", "insn", ",", "-", "<NUM_LIT>", ")", ";", "if", "(", "!", "remote_label", ")", "{", "insn", "=", "emit_label_after", "(", "pool", "->", "label", ",", "insn", ")", ";", "INSN_ADDRESSES_NEW", "(", "insn", ",", "-", "<NUM_LIT>", ")", ";", "}", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "NR_C_MODES", ";", "i", "++", ")", "for", "(", "c", "=", "pool", "->", "constants", "[", "i", "]", ";", "c", ";", "c", "=", "c", "->", "next", ")", "{", "rtx", "value", "=", "c", "->", "value", ";", "if", "(", "GET_CODE", "(", "value", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "value", ",", "<NUM_LIT>", ")", ")", "==", "UNSPEC", "&&", "XINT", "(", "XEXP", "(", "value", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", "==", "UNSPEC_LTREL_OFFSET", "&&", "XVECLEN", "(", "XEXP", "(", "value", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "{", "value", "=", "gen_rtx_MINUS", "(", "Pmode", ",", "XVECEXP", "(", "XEXP", "(", "value", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "pool", "->", "label", ")", ")", ";", "value", "=", "gen_rtx_CONST", "(", "VOIDmode", ",", "value", ")", ";", "}", "insn", "=", "emit_label_after", "(", "c", "->", "label", ",", "insn", ")", ";", "INSN_ADDRESSES_NEW", "(", "insn", ",", "-", "<NUM_LIT>", ")", ";", "value", "=", "gen_rtx_UNSPEC_VOLATILE", "(", "constant_modes", "[", "i", "]", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "value", ")", ",", "UNSPECV_POOL_ENTRY", ")", ";", "insn", "=", "emit_insn_after", "(", "value", ",", "insn", ")", ";", "INSN_ADDRESSES_NEW", "(", "insn", ",", "-", "<NUM_LIT>", ")", ";", "}", "insn", "=", "emit_insn_after", "(", "gen_pool_align", "(", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ",", "insn", ")", ";", "INSN_ADDRESSES_NEW", "(", "insn", ",", "-", "<NUM_LIT>", ")", ";", "for", "(", "c", "=", "pool", "->", "execute", ";", "c", ";", "c", "=", "c", "->", "next", ")", "{", "insn", "=", "emit_label_after", "(", "c", "->", "label", ",", "insn", ")", ";", "INSN_ADDRESSES_NEW", "(", "insn", ",", "-", "<NUM_LIT>", ")", ";", "insn", "=", "emit_insn_after", "(", "s390_execute_target", "(", "c", "->", "value", ")", ",", "insn", ")", ";", "INSN_ADDRESSES_NEW", "(", "insn", ",", "-", "<NUM_LIT>", ")", ";", "}", "if", "(", "TARGET_CPU_ZARCH", ")", "{", "insn", "=", "emit_insn_after", "(", "gen_pool_section_end", "(", ")", ",", "insn", ")", ";", "INSN_ADDRESSES_NEW", "(", "insn", ",", "-", "<NUM_LIT>", ")", ";", "}", "insn", "=", "emit_barrier_after", "(", "insn", ")", ";", "INSN_ADDRESSES_NEW", "(", "insn", ",", "-", "<NUM_LIT>", ")", ";", "remove_insn", "(", "pool", "->", "pool_insn", ")", ";", "}" ]

[ "Dump", "out", "the", "constants", "in", "POOL", ".", "If", "REMOTE_LABEL", "is", "true", ",", "do", "not", "emit", "the", "pool", "base", "label", "." ]

[ "<STR_LIT>", ")" ]

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

[ "void", "finishLayout", "(", "MCAssembler", "const", "&", "Asm", ",", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "for", "(", "auto", "I", ":", "Layout", ".", "getSectionOrder", "(", ")", ")", "{", "auto", "&", "Fragments", "=", "I", "->", "getFragmentList", "(", ")", ";", "for", "(", "auto", "&", "J", ":", "Fragments", ")", "{", "switch", "(", "J", ".", "getKind", "(", ")", ")", "{", "default", ":", "break", ";", "case", "MCFragment", "::", "FT_Align", ":", "{", "auto", "Size", "=", "Asm", ".", "computeFragmentSize", "(", "Layout", ",", "J", ")", ";", "for", "(", "auto", "K", "=", "J", ".", "getIterator", "(", ")", ";", "K", "!=", "Fragments", ".", "begin", "(", ")", "&&", "Size", ">=", "HEXAGON_PACKET_SIZE", ";", ")", "{", "--", "K", ";", "switch", "(", "K", "->", "getKind", "(", ")", ")", "{", "default", ":", "break", ";", "case", "MCFragment", "::", "FT_Align", ":", "{", "Size", "=", "<NUM_LIT>", ";", "break", ";", "}", "case", "MCFragment", "::", "FT_Relaxable", ":", "{", "MCContext", "&", "Context", "=", "Asm", ".", "getContext", "(", ")", ";", "auto", "&", "RF", "=", "cast", "<", "MCRelaxableFragment", ">", "(", "*", "K", ")", ";", "auto", "&", "Inst", "=", "const_cast", "<", "MCInst", "&", ">", "(", "RF", ".", "getInst", "(", ")", ")", ";", "while", "(", "Size", ">", "<NUM_LIT>", "&&", "HexagonMCInstrInfo", "::", "bundleSize", "(", "Inst", ")", "<", "<NUM_LIT>", ")", "{", "MCInst", "*", "Nop", "=", "new", "(", "Context", ")", "MCInst", ";", "Nop", "->", "setOpcode", "(", "Hexagon", "::", "A2_nop", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createInst", "(", "Nop", ")", ")", ";", "Size", "-=", "<NUM_LIT>", ";", "if", "(", "!", "HexagonMCChecker", "(", "Context", ",", "*", "MCII", ",", "RF", ".", "getSubtargetInfo", "(", ")", ",", "Inst", ",", "*", "Context", ".", "getRegisterInfo", "(", ")", ",", "false", ")", ".", "check", "(", ")", ")", "{", "Inst", ".", "erase", "(", "Inst", ".", "end", "(", ")", "-", "<NUM_LIT>", ")", ";", "Size", "=", "<NUM_LIT>", ";", "}", "}", "bool", "Error", "=", "HexagonMCShuffle", "(", "Context", ",", "true", ",", "*", "MCII", ",", "RF", ".", "getSubtargetInfo", "(", ")", ",", "Inst", ")", ";", "(", "void", ")", "Error", ";", "ReplaceInstruction", "(", "Asm", ".", "getEmitter", "(", ")", ",", "RF", ",", "Inst", ")", ";", "Layout", ".", "invalidateFragmentsFrom", "(", "&", "RF", ")", ";", "Size", "=", "<NUM_LIT>", ";", "break", ";", "}", "}", "}", "}", "}", "}", "}", "}" ]

[ "Give", "backend", "an", "opportunity", "to", "finish", "layout", "after", "relaxation", "." ]

[ ")", ";" ]

[ "SDValue", "Hint", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "unsigned", "HintVal", "=", "cast", "<", "ConstantSDNode", ">", "(", "Hint", ")", "->", "getZExtValue", "(", ")", ";", "assert", "(", "HintVal", "<", "<NUM_LIT>", "&&", "<STR_LIT>", "Wrong prefetch hint in intrinsic: should be 0 or 1", "<STR_LIT>", ")", ";", "unsigned", "Opcode", "=", "(", "HintVal", "?", "IntrData", "->", "Opc1", ":", "IntrData", "->", "Opc0", ")", ";", "SDValue", "Chain", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Mask", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Index", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Base", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Scale", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "return", "getPrefetchNode", "(", "Opcode", ",", "Op", ",", "DAG", ",", "Mask", ",", "Base", ",", "Index", ",", "Scale", ",", "Chain", ",", "Subtarget", ")", ";", "}", "case", "RDTSC", ":", "{", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Results", ";", "getReadTimeStampCounter", "(", "Op", ".", "getNode", "(", ")", ",", "dl", ",", "IntrData", "->", "Opc0", ",", "DAG", ",", "Subtarget", ",", "Results", ")", ";", "return", "DAG", ".", "getMergeValues", "(", "Results", ",", "dl", ")", ";", "}", "case", "RDPMC", ":", "{", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Results", ";", "getReadPerformanceCounter", "(", "Op", ".", "getNode", "(", ")", ",", "dl", ",", "DAG", ",", "Subtarget", ",", "Results", ")", ";", "return", "DAG", ".", "getMergeValues", "(", "Results", ",", "dl", ")", ";", "}", "case", "XTEST", ":", "{", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "Op", "->", "getValueType", "(", "<NUM_LIT>", ")", ",", "MVT", "::", "Other", ")", ";", "SDValue", "InTrans", "=", "DAG", ".", "getNode", "(", "IntrData", "->", "Opc0", ",", "dl", ",", "VTs", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "SetCC", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i8", ",", "DAG", ".", "getConstant", "(", "X86", "::", "COND_NE", ",", "dl", ",", "MVT", "::", "i8", ")", ",", "InTrans", ")", ";", "SDValue", "Ret", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "Op", "->", "getValueType", "(", "<NUM_LIT>", ")", ",", "SetCC", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "MERGE_VALUES", ",", "dl", ",", "Op", "->", "getVTList", "(", ")", ",", "Ret", ",", "SDValue", "(", "InTrans", ".", "getNode", "(", ")", ",", "<NUM_LIT>", ")", ")", ";", "}", "case", "ADX", ":", "{", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Results", ";", "SDVTList", "CFVTs", "=", "DAG", ".", "getVTList", "(", "Op", "->", "getValueType", "(", "<NUM_LIT>", ")", ",", "MVT", "::", "Other", ")", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", "->", "getValueType", "(", "<NUM_LIT>", ")", ",", "MVT", "::", "Other", ")", ";", "SDValue", "GenCF", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "CFVTs", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "-", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i8", ")", ")", ";", "SDValue", "Res", "=", "DAG", ".", "getNode", "(", "IntrData", "->", "Opc0", ",", "dl", ",", "VTs", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "GenCF", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "Store", "=", "DAG", ".", "getStore", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "dl", ",", "Res", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "SDValue", "SetCC", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i8", ",", "DAG", ".", "getConstant", "(", "X86", "::", "COND_B", ",", "dl", ",", "MVT", "::", "i8", ")", ",", "Res", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "Results", ".", "push_back", "(", "SetCC", ")", ";", "Results", ".", "push_back", "(", "Store", ")", ";", "return", "DAG", ".", "getMergeValues", "(", "Results", ",", "dl", ")", ";", "}", "case", "COMPRESS_TO_MEM", ":", "{", "SDValue", "Mask", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "DataToCompress", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Addr", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Chain", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "MVT", "VT", "=", "DataToCompress", ".", "getSimpleValueType", "(", ")", ";", "MemIntrinsicSDNode", "*", "MemIntr", "=", "dyn_cast", "<", "MemIntrinsicSDNode", ">", "(", "Op", ")", ";", "assert", "(", "MemIntr", "&&", "<STR_LIT>", "Expected MemIntrinsicSDNode!", "<STR_LIT>", ")", ";", "if", "(", "isAllOnesConstant", "(", "Mask", ")", ")", "return", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "DataToCompress", ",", "Addr", ",", "MemIntr", "->", "getMemOperand", "(", ")", ")", ";", "SDValue", "Compressed", "=", "getVectorMaskingNode", "(", "DAG", ".", "getNode", "(", "IntrData", "->", "Opc0", ",", "dl", ",", "VT", ",", "DataToCompress", ")", ",", "Mask", ",", "DAG", ".", "getUNDEF", "(", "VT", ")", ",", "Subtarget", ",", "DAG", ")", ";", "return", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "Compressed", ",", "Addr", ",", "MemIntr", "->", "getMemOperand", "(", ")", ")", ";", "}", "case", "TRUNCATE_TO_MEM_VI8", ":", "case", "TRUNCATE_TO_MEM_VI16", ":", "case", "TRUNCATE_TO_MEM_VI32", ":", "{", "SDValue", "Mask", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "DataToTruncate", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Addr", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Chain", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "MemIntrinsicSDNode", "*", "MemIntr", "=", "dyn_cast", "<", "MemIntrinsicSDNode", ">", "(", "Op", ")", ";", "assert", "(", "MemIntr", "&&", "<STR_LIT>", "Expected MemIntrinsicSDNode!", "<STR_LIT>", ")", ";", "EVT", "VT", "=", "MemIntr", "->", "getMemoryVT", "(" ]

[ "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".fpu", "<STR_LIT>", ")", "parseDirectiveFPU", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";" ]

[ "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".ltorg", "<STR_LIT>", "||", "IDVal", "==", "<STR_LIT>", ".pool", "<STR_LIT>", ")", "parseDirectiveLtorg", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".even", "<STR_LIT>", ")", "parseDirectiveEven", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".personalityindex", "<STR_LIT>", ")", "parseDirectivePersonalityIndex", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".unwind_raw", "<STR_LIT>", ")", "parseDirectiveUnwindRaw", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".movsp", "<STR_LIT>", ")", "parseDirectiveMovSP", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".arch_extension", "<STR_LIT>", ")", "parseDirectiveArchExtension", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".align", "<STR_LIT>", ")", "return", "parseDirectiveAlign", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".thumb_set", "<STR_LIT>", ")", "parseDirectiveThumbSet", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".inst", "<STR_LIT>", ")", "parseDirectiveInst", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".inst.n", "<STR_LIT>", ")", "parseDirectiveInst", "(", "DirectiveID", ".", "getLoc", "(", ")", ",", "'", "n", "'", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".inst.w", "<STR_LIT>", ")", "parseDirectiveInst", "(", "DirectiveID", ".", "getLoc", "(", ")", ",", "'", "w", "'", ")", ";", "else", "if", "(", "!", "IsMachO", "&&", "!", "IsCOFF", ")", "{", "if", "(", "IDVal", "==", "<STR_LIT>", ".arch", "<STR_LIT>", ")", "parseDirectiveArch", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".cpu", "<STR_LIT>", ")", "parseDirectiveCPU", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "<STR_LIT>", ".eabi_attribute", "<STR_LIT>", ")", "parseDirectiveEabiAttr", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";" ]

[ "}" ]

[ "bool", "SelectAddrPCRel", "(", "SDValue", "N", ",", "SDValue", "&", "Base", ")", "{", "return", "PPCLowering", "->", "SelectAddressPCRel", "(", "N", ",", "Base", ")", ";" ]

[ "CC", "VAX_PSL_REGNUM", ")", ")", "]" ]

[ "[", "(", "set", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "truncate", ":", "HI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":" ]

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

[ "<STR_LIT>", "<STR_LIT>", "[", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "xor", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "FLAGS_REG", ")", ")", "]", ")", "(", "parallel", "[", "(", "set", "(", "reg", ":", "CC", "FLAGS_REG", ")", "(", "unspec", ":", "CC", "[", "(", "match_dup", "<NUM_LIT>", ")", "]", "UNSPEC_PARITY", ")", ")", "(", "clobber", "(", "match_dup", "<NUM_LIT>", ")", ")" ]

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

[ "return", "Opc", "==", "<STR_LIT>" ]

[ "static", "void", "dump_target_flag_bits", "(", "const", "int", "flags", ")", "{", "if", "(", "flags", "&", "MASK_64BIT", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ")", ";", "if", "(", "flags", "&", "MASK_APP_REGS", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "APP_REGS ", "<STR_LIT>", ")", ";", "if", "(", "flags", "&", "MASK_FASTER_STRUCTS", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "FASTER_STRUCTS ", "<STR_LIT>", ")", ";", "if", "(", "flags", "&", "MASK_FLAT", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "FLAT ", "<STR_LIT>", ")", ";", "if", "(", "flags", "&", "MASK_FMAF", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "FMAF ", "<STR_LIT>", ")", ";", "if", "(", "flags", "&", "MASK_FPU", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "FPU ", "<STR_LIT>", ")", ";", "if", "(", "flags", "&", "MASK_HARD_QUAD", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "HARD_QUAD ", "<STR_LIT>", ")", ";", "if", "(", "flags", "&", "MASK_POPC", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "POPC ", "<STR_LIT>", ")", ";", "if", "(", "flags", "&", "MASK_PTR64", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "PTR64 ", "<STR_LIT>", ")", ";", "if", "(", "flags", "&", "MASK_STACK_BIAS", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "STACK_BIAS ", "<STR_LIT>", ")", ";", "if", "(", "flags", "&", "MASK_UNALIGNED_DOUBLES", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "UNALIGNED_DOUBLES ", "<STR_LIT>", ")", ";", "if", "(", "flags", "&", "MASK_V8PLUS", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "V8PLUS ", "<STR_LIT>", ")", ";", "if", "(", "flags", "&", "MASK_VIS", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "VIS ", "<STR_LIT>", ")", ";", "if", "(", "flags", "&", "MASK_VIS2", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "VIS2 ", "<STR_LIT>", ")", ";", "if", "(", "flags", "&", "MASK_VIS3", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "VIS3 ", "<STR_LIT>", ")", ";", "if", "(", "flags", "&", "MASK_CBCOND", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "CBCOND ", "<STR_LIT>", ")", ";", "if", "(", "flags", "&", "MASK_DEPRECATED_V8_INSNS", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "DEPRECATED_V8_INSNS ", "<STR_LIT>", ")", ";", "if", "(", "flags", "&", "MASK_SPARCLET", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "SPARCLET ", "<STR_LIT>", ")", ";", "if", "(", "flags", "&", "MASK_SPARCLITE", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "SPARCLITE ", "<STR_LIT>", ")", ";", "if", "(", "flags", "&", "MASK_V8", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "V8 ", "<STR_LIT>", ")", ";", "if", "(", "flags", "&", "MASK_V9", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "V9 ", "<STR_LIT>", ")", ";", "}" ]

[ "Helpers", "for", "TARGET_DEBUG_OPTIONS", "." ]

[ "}" ]

[ "_", "_", "arm_vsubq_x_n_u16", "(", "uint16x8_t", "_", "_", "a", ",", "uint16_t", "_", "_", "b", ",", "mve_pred16_t", "_", "_", "p", ")", "{", "return", "_", "_", "builtin_mve_vsubq_m_n_uv8hi", "(", "_", "_", "arm_vuninitializedq_u16", "(", ")", ",", "_", "_", "a", ",", "_", "_", "b", ",", "_", "_", "p", ")", ";" ]

[ ";" ]

[ "OperandMatchResultTy", "AArch64AsmParser", "::", "tryParseSVEPredicateVector", "(", "OperandVector", "&", "Operands", ")", "{", "const", "SMLoc", "S", "=", "getLoc", "(", ")", ";", "StringRef", "Kind", ";", "unsigned", "RegNum", ";", "auto", "Res", "=", "tryParseVectorRegister", "(", "RegNum", ",", "Kind", ",", "RegKind", "::", "SVEPredicateVector", ")", ";", "if", "(", "Res", "!=", "MatchOperand_Success", ")", "return", "Res", ";", "const", "auto", "&", "KindRes", "=", "parseVectorKind", "(", "Kind", ",", "RegKind", "::", "SVEPredicateVector", ")", ";", "if", "(", "!", "KindRes", ")", "return", "MatchOperand_NoMatch", ";", "unsigned", "ElementWidth", "=", "KindRes", "->", "second", ";", "Operands", ".", "push_back", "(", "AArch64Operand", "::", "CreateVectorReg", "(", "RegNum", ",", "RegKind", "::", "SVEPredicateVector", ",", "ElementWidth", ",", "S", ",", "getLoc", "(", ")", ",", "getContext", "(", ")", ")", ")", ";", "MCAsmParser", "&", "Parser", "=", "getParser", "(", ")", ";", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "isNot", "(", "AsmToken", "::", "Slash", ")", ")", "return", "MatchOperand_Success", ";", "if", "(", "!", "Kind", ".", "empty", "(", ")", ")", "{", "Error", "(", "S", ",", "<STR_LIT>", "not expecting size suffix", "<STR_LIT>", ")", ";", "return", "MatchOperand_ParseFail", ";", "}", "Operands", ".", "push_back", "(", "AArch64Operand", "::", "CreateToken", "(", "<STR_LIT>", "/", "<STR_LIT>", ",", "false", ",", "getLoc", "(", ")", ",", "getContext", "(", ")", ")", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "auto", "Pred", "=", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", ".", "lower", "(", ")", ";", "if", "(", "Pred", "!=", "<STR_LIT>", "z", "<STR_LIT>", "&&", "Pred", "!=", "<STR_LIT>", "m", "<STR_LIT>", ")", "{", "Error", "(", "getLoc", "(", ")", ",", "<STR_LIT>", "expecting 'm' or 'z' predication", "<STR_LIT>", ")", ";", "return", "MatchOperand_ParseFail", ";", "}", "const", "char", "*", "ZM", "=", "Pred", "==", "<STR_LIT>", "z", "<STR_LIT>", "?", "<STR_LIT>", "z", "<STR_LIT>", ":", "<STR_LIT>", "m", "<STR_LIT>", ";", "Operands", ".", "push_back", "(", "AArch64Operand", "::", "CreateToken", "(", "ZM", ",", "false", ",", "getLoc", "(", ")", ",", "getContext", "(", ")", ")", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "return", "MatchOperand_Success" ]

[ "DL", ",", "AS", ")", ";" ]

[ "MVT", "WebAssemblyTargetLowering", "::", "getPointerTy", "(", "const", "DataLayout", "&", "DL", ",", "uint32_t", "AS", ")", "const", "{", "if", "(", "AS", "==", "WebAssembly", "::", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "MVT", "::", "externref", ";", "if", "(", "AS", "==", "WebAssembly", "::", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "MVT", "::", "funcref", ";", "return", "TargetLowering", "::", "getPointerTy", "(" ]

[ "static", "rtx", "gen_sym_unspec", "(", "rtx", "x", ",", "int", "kind", ")", "{", "return", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "x", ")", ",", "kind", ")", ";", "}" ]

[ "Helper", "for", "or1k_legitimize_address_1", ".", "Wrap", "X", "in", "an", "unspec", "." ]

[ "}" ]

[ "void", "setBasePointerVreg", "(", "unsigned", "Reg", ")", "{", "BasePtrVreg", "=", "Reg", ";" ]

[ "<FIXS>", "multiclass", "IntSetP10RevSetBool", "SDNode", "SetCC", ",", "ValueType", "Ty", ",", "PatLeaf", "ZExtTy", ",", "ImmLeaf", "SExtTy", ",", "I", "Cmpi", ",", "I", "Cmpli", ",", "I", "Cmp", ",", "I", "Cmpl", ">", "{", "<FIXE>" ]

[ "(", "SETBCR8", "result", ")", ">", ";", "}", "<BUGS>", "multiclass", "IntSetP10RevSetBool", "SDNode", "SetCC", ",", "ValueType", "Ty", ",", "ImmLeaf", "ZExtTy", ",", "ImmLeaf", "SExtTy", ",", "PatLeaf", "Cmpi", ",", "PatLeaf", "Cmpli", ",", "PatLeaf", "Cmp", ",", "PatLeaf", "Cmpl", ">", "{", "<BUGE>", "defm", ":", "P10ReverseSetBool", "(", "i1", "(", "SetCC", "Ty", ":", "$", "s1", ",", "Ty", ":", "$", "s2", ",", "SETUGE", ")", ")", ",", "(", "EXTRACT_SUBREG", "(", "Cmpl", "$", "s1", ",", "$", "s2", ")", ",", "sub_lt", ")", ">", ";", "defm", ":", "P10ReverseSetBool", "(", "i1", "(", "SetCC", "Ty", ":", "$", "s1", ",", "Ty", ":", "$", "s2", ",", "SETGE", ")", ")", "," ]

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

[ "bits", "<", "<NUM_LIT>", ">", "base", ";", "bits", "<", "<NUM_LIT>", ">", "offset", ";", "bits", "<", "<NUM_LIT>", ">", "extend", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sz", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "V", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "offset", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "extend", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=" ]

[ "if", "(", "TARGET_INTERWORK", "||", "arm_arch4t", ")", "output_asm_insn", "(", "<STR_LIT>", "bx%?\\t%0", "<STR_LIT>", ",", "operands", ")", ";" ]

[ "gcc_assert", "(", "!", "arm_arch5", ")", ";", "if", "(", "REGNO", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "LR_REGNUM", ")", "{", "operands", "[", "<NUM_LIT>", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "IP_REGNUM", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "mov%?\\t%0, %|lr", "<STR_LIT>", ",", "operands", ")", ";", "}", "output_asm_insn", "(", "<STR_LIT>", "mov%?\\t%|lr, %|pc", "<STR_LIT>", ",", "operands", ")", ";" ]

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

[ "if", "(", "MIa", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIb", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIa", ".", "hasOrderedMemoryRef", "(", ")", "||", "MIb", ".", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "if", "(", "getMemOperandWithOffsetWidth", "(", "MIa", ",", "BaseOpA", ",", "OffsetA", ",", "WidthA", ",", "TRI", ")", "&&", "getMemOperandWithOffsetWidth", "(", "MIb", ",", "BaseOpB", ",", "OffsetB", ",", "WidthB", ",", "TRI", ")", ")", "{", "if", "(", "BaseOpA", "->", "isIdenticalTo", "(", "*", "BaseOpB", ")", ")", "{", "int", "LowOffset", "=", "OffsetA", "<", "OffsetB", "?", "OffsetA", ":", "OffsetB", ";", "int", "HighOffset", "=", "OffsetA", "<", "OffsetB", "?", "OffsetB", ":", "OffsetA", ";", "int", "LowWidth", "=", "(", "LowOffset", "==", "OffsetA", ")", "?", "WidthA", ":", "WidthB", ";", "if", "(", "LowOffset", "+", "LowWidth", "<=", "HighOffset", ")", "return", "true", ";", "}", "}" ]

[ "<FIXS>", "emitByte", "(", "<NUM_LIT>", ",", "OS", ")", ";", "+", "CurOp", ";", "<FIXE>", "<FIXS>", "emitSegmentOverridePrefix", "(", "<NUM_LIT>", ",", "MI", ",", "OS", ")", ";", "<FIXE>" ]

[ "if", "(", "(", "!", "STI", ".", "hasFeature", "(", "X86", "::", "Mode32Bit", ")", "&&", "siReg", "==", "X86", "::", "EDI", ")", "||", "(", "STI", ".", "hasFeature", "(", "X86", "::", "Mode32Bit", ")", "&&", "siReg", "==", "X86", "::", "DI", ")", ")", "<BUGS>", "emitByte", "(", "<NUM_LIT>", ",", "CurByte", ",", "OS", ")", ";", "<BUGE>", "break", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "<BUGS>", "emitSegmentOverridePrefix", "(", "CurByte", ",", "<NUM_LIT>", ",", "MI", ",", "OS", ")", ";", "<BUGE>", "break", ";", "}", "}" ]

[ "}" ]

[ "case", "Intrinsic", "::", "amdgcn_global_atomic_fadd", ":", "case", "Intrinsic", "::", "amdgcn_flat_atomic_fadd", ":", "case", "Intrinsic", "::", "amdgcn_flat_atomic_fmin", ":", "case", "Intrinsic", "::", "amdgcn_flat_atomic_fmax", ":", "case", "Intrinsic", "::", "amdgcn_global_atomic_csub", ":", "{", "Value", "*", "Ptr", "=", "II", "->", "getArgOperand", "(", "<NUM_LIT>", ")", ";", "AccessTy", "=", "II", "->", "getType", "(", ")", ";", "Ops", ".", "push_back", "(", "Ptr", ")", ";", "return", "true", ";", "}", "default", ":", "return", "false", ";", "}" ]

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

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

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

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

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

[ "[", "(", "set", "(", "match_operand", ":", "V2SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "zero_extend", ":", "V2SI", "(", "vec_select", ":", "V2QI", "(", "match_operand", ":", "V8QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

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

[ "MCAsmLexer", "&", "getLexer", "(", ")", "const", "{", "return", "Parser", ".", "getLexer" ]

[ "MEM_NOTRAP_P", "(", "mem", ")", "=", "<NUM_LIT>", ";" ]

[ "static", "rtx", "gen_varargs_mem", "(", "machine_mode", "mode", ",", "rtx", "addr", ")", "{", "rtx", "mem", "=", "gen_rtx_MEM", "(", "mode", ",", "addr", ")", ";" ]

[ "Ty", "}", ",", "Legal", ")", ";" ]

[ "const", "LLT", "v8s64", "=", "LLT", "::", "vector", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "for", "(", "unsigned", "BinOp", ":", "{", "G_ADD", ",", "G_SUB", "}", ")", "for", "(", "auto", "Ty", ":", "{", "v16s32", ",", "v8s64", "}", ")", "setAction", "(", "{", "BinOp", ",", "Ty", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_MUL", ",", "v16s32", "}", ",", "Legal", ")", ";", "for", "(", "unsigned", "MemOp", ":", "{", "G_LOAD", ",", "G_STORE", "}", ")", "for", "(", "auto", "Ty", ":", "{", "v16s32", ",", "v8s64", "}", ")", "setAction", "(", "{", "MemOp", ",", "Ty", "}", ",", "Legal", ")", ";", "if", "(", "!", "Subtarget", ".", "hasVLX", "(", ")", ")", "return", ";", "const", "LLT", "v4s32", "=", "LLT", "::", "vector", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "const", "LLT", "v8s32", "=", "LLT", "::", "vector", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "for", "(", "auto", "Ty", ":", "{", "v4s32", ",", "v8s32", "}", ")", "setAction", "(", "{", "G_MUL", "," ]

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

[ "class", "BaseSIMDFPCvtTwoVector", "<", "bit", "Q", ",", "bit", "U", ",", "bits", "<", "<NUM_LIT>", ">", "size", ",", "bits", "<", "<NUM_LIT>", ">", "opcode", ",", "RegisterOperand", "outtype", ",", "RegisterOperand", "intype", ",", "string", "asm", ",", "string", "VdTy", ",", "string", "VnTy", ",", "list", "<", "dag", ">", "pattern", ">", ":", "I", "<", "(", "outs", "outtype", ":", "$", "Rd", ")", ",", "(", "ins", "intype", ":", "$", "Rn", ")", ",", "asm", ",", "!", "strconcat", "(", "<STR_LIT>", ",", "VdTy", ",", "<STR_LIT>", ",", "VnTy", ")", ",", "<STR_LIT>", ",", "pattern", ">", ",", "Sched", "<", "[", "WriteVq", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Q", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "U", ";" ]

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

[ "void", "m32c_output_reg_push", "(", "FILE", "*", "s", ",", "int", "regno", ")", "{", "if", "(", "regno", "==", "FLG_REGNO", ")", "fprintf", "(", "s", ",", "<STR_LIT>", "\\tpushc\\tflg\\n", "<STR_LIT>", ")", ";", "else", "fprintf", "(", "s", ",", "<STR_LIT>", "\\tpush.%c\\t%s\\n", "<STR_LIT>", ",", "<STR_LIT>", " bwll", "<STR_LIT>", "[", "reg_push_size", "(", "regno", ")", "]", ",", "reg_names", "[", "regno" ]

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

[ "return", "std", "::", "make_unique", "<", "SystemZOperand", ">", "(", "KindInvalid", ",", "StartLoc", "," ]

[ "GBR_REG", ")" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "reg", ":", "SI" ]

[ "}" ]

[ "std", "::", "vector", "<", "Chain", "*", ">", "Cs", "(", "EC", ".", "member_begin", "(", "I", ")", ",", "EC", ".", "member_end", "(", ")", ")", ";", "if", "(", "Cs", ".", "empty", "(", ")", ")", "continue", ";", "V", ".", "push_back", "(", "std", "::", "move", "(", "Cs", ")", ")", ";", "}", "llvm", "::", "sort", "(", "V", ".", "begin", "(", ")", ",", "V", ".", "end", "(", ")", ",", "[", "]", "(", "const", "std", "::", "vector", "<", "Chain", "*", ">", "&", "A", ",", "const", "std", "::", "vector", "<", "Chain", "*", ">", "&", "B", ")", "{", "return", "A", ".", "front", "(", ")", "->", "startsBefore", "(", "B", ".", "front", "(", ")", ")", ";", "}", ")", ";", "int", "Parity", "=", "<NUM_LIT>", ";", "for", "(", "auto", "&", "I", ":", "V", ")", "Changed", "|=", "colorChainSet", "(", "std", "::", "move", "(", "I", ")", ",", "MBB", ",", "Parity", ")", ";", "return", "Changed", ";" ]

[ "static", "bool", "rs6000_slow_unaligned_access", "(", "machine_mode", "mode", ",", "unsigned", "int", "align", ")", "{", "return", "(", "STRICT_ALIGNMENT", "||", "(", "!", "TARGET_EFFICIENT_UNALIGNED_VSX", "&&", "(", "(", "SCALAR_FLOAT_MODE_NOT_VECTOR_P", "(", "mode", ")", "&&", "align", "<", "<NUM_LIT>", ")", "||", "(", "(", "VECTOR_MODE_P", "(", "mode", ")", "||", "FLOAT128_VECTOR_P", "(", "mode", ")", ")", "&&", "(", "int", ")", "align", "<", "VECTOR_ALIGN", "(", "mode", ")", ")", ")", ")", ")", ";", "}" ]

[ "Implement", "TARGET_SLOW_UNALIGNED_ACCESS", ".", "Altivec", "vector", "memory", "instructions", "simply", "ignore", "the", "low", "bits", ";", "VSX", "memory", "instructions", "are", "aligned", "to", "4", "or", "8", "bytes", "." ]

[ "}" ]

[ "unsigned", "ARMBaseInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "LDRrs", ":", "case", "ARM", "::", "t2LDRs", ":", "if", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "<NUM_LIT>", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "LDRi12", ":", "case", "ARM", "::", "t2LDRi12", ":", "case", "ARM", "::", "tLDRspi", ":", "case", "ARM", "::", "VLDRD", ":", "case", "ARM", "::", "VLDRS", ":", "if", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "VLDR_P0_off", ":", "if", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ";", "return", "ARM", "::", "P0", ";", "}", "break", ";", "case", "ARM", "::", "VLD1q64", ":", "case", "ARM", "::", "VLD1d8TPseudo", ":", "case", "ARM", "::", "VLD1d16TPseudo", ":", "case", "ARM", "::", "VLD1d32TPseudo", ":", "case", "ARM", "::", "VLD1d64TPseudo", ":", "case", "ARM", "::", "VLD1d8QPseudo", ":", "case", "ARM", "::", "VLD1d16QPseudo", ":", "case", "ARM", "::", "VLD1d32QPseudo", ":", "case", "ARM", "::", "VLD1d64QPseudo", ":", "if", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getSubReg", "(", ")", "==", "<NUM_LIT>", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "VLDMQIA", ":", "if", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getSubReg", "(", ")", "==", "<NUM_LIT>", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "}", "break", ";" ]

[ "<FIXS>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<FIXE>", "<FIXS>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<FIXE>", "<FIXS>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<FIXE>", "<FIXS>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<FIXE>", "<FIXS>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<FIXE>", "<FIXS>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<FIXE>", "<FIXS>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<FIXE>", "<FIXS>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<FIXE>" ]

[ "let", "ResourceCycles", "=", "[", "<NUM_LIT>", "]", ";", "}", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGS>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGE>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGS>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGE>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGS>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGE>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGS>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGE>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGS>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGE>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGS>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGE>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGS>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGE>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGS>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGE>", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "def", ":", "InstRW", "[", "BWWriteResGroup9", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";" ]

[ ";" ]

[ "const", "bool", "ArePtrs64bit", "=", "ABI", ".", "ArePtrs64bit", "(", ")", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "LL", ",", "SC", ",", "AND", ",", "NOR", ",", "ZERO", ",", "BEQ", ";", "if", "(", "Size", "==", "<NUM_LIT>", ")", "{", "if", "(", "isMicroMips", ")", "{", "LL", "=", "Mips", "::", "LL_MM", ";", "SC", "=", "Mips", "::", "SC_MM", ";", "}", "else", "{", "LL", "=", "Subtarget", ".", "hasMips32r6", "(", ")", "?", "(", "ArePtrs64bit", "?", "Mips", "::", "LL64_R6", ":", "Mips", "::", "LL_R6", ")", ":", "(", "ArePtrs64bit", "?", "Mips", "::", "LL64", ":", "Mips", "::", "LL", ")", ";", "SC", "=", "Subtarget", ".", "hasMips32r6", "(", ")", "?", "(", "ArePtrs64bit", "?", "Mips", "::", "SC64_R6", ":", "Mips", "::", "SC_R6", ")", ":", "(", "ArePtrs64bit", "?", "Mips", "::", "SC64", ":", "Mips", "::", "SC", ")", ";", "}", "AND", "=", "Mips", "::", "AND", ";", "NOR", "=", "Mips", "::", "NOR", ";", "ZERO", "=", "Mips", "::", "ZERO", ";", "BEQ", "=", "Mips", "::", "BEQ", ";", "}", "else", "{", "LL", "=", "Subtarget", ".", "hasMips64r6", "(", ")", "?", "Mips", "::", "LLD_R6", ":", "Mips", "::", "LLD", ";", "SC", "=", "Subtarget", ".", "hasMips64r6", "(", ")", "?", "Mips", "::", "SCD_R6", ":", "Mips", "::", "SCD", ";", "AND", "=", "Mips", "::", "AND64", ";", "NOR", "=", "Mips", "::", "NOR64", ";", "ZERO", "=", "Mips", "::", "ZERO_64", ";", "BEQ", "=", "Mips", "::", "BEQ64", ";", "}", "unsigned", "OldVal", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "Ptr", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "Incr", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "StoreVal", "=", "RegInfo", ".", "createVirtualRegister", "(", "RC", ")", ";", "unsigned", "AndRes", "=", "RegInfo", ".", "createVirtualRegister", "(", "RC", ")", ";", "unsigned", "Success", "=", "RegInfo", ".", "createVirtualRegister", "(", "RC", ")", ";", "const", "BasicBlock", "*", "LLVM_BB", "=", "BB", "->", "getBasicBlock", "(", ")", ";", "MachineBasicBlock", "*", "loopMBB", "=", "MF", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "exitMBB", "=", "MF", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineFunction", "::", "iterator", "It", "=", "++", "BB", "->", "getIterator", "(", ")", ";", "MF", "->", "insert", "(", "It", ",", "loopMBB", ")", ";", "MF", "->", "insert", "(", "It", ",", "exitMBB", ")", ";", "exitMBB", "->", "splice", "(", "exitMBB", "->", "begin", "(", ")", ",", "BB", ",", "std", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "BB", "->", "end", "(", ")", ")", ";", "exitMBB", "->", "transferSuccessorsAndUpdatePHIs", "(", "BB", ")", ";", "BB", "->", "addSuccessor", "(", "loopMBB", ")", ";", "loopMBB", "->", "addSuccessor", "(", "loopMBB", ")", ";", "loopMBB", "->", "addSuccessor", "(", "exitMBB", ")", ";", "BB", "=", "loopMBB" ]

[ ")", "]" ]

[ "(", "clobber", "(", "mem", ":", "BLK", "(", "scratch", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

[ ";" ]

[ "SDValue", "<STR_LIT>", "::", "<STR_LIT>", "(", "SDNode", "*", "N", ",", "SelectionDAG", "&", "DAG", ",", "MVT", "ValueType", ")", "{", "if", "(", "ConstantSDNode", "*", "CN", "=", "getVecImm", "(", "N", ")", ")", "{", "int", "Value", "=", "(", "int", ")", "CN", "->", "getZExtValue", "(", ")", ";", "if", "(", "ValueType", "==", "MVT", "::", "i16", "&&", "Value", "<=", "<NUM_LIT>", "&&", "(", "(", "short", ")", "Value", ">>", "<NUM_LIT>", ")", "==", "(", "(", "short", ")", "Value", "&", "<NUM_LIT>", ")", ")", "return", "DAG", ".", "getTargetConstant", "(", "Value", "&", "<NUM_LIT>", ",", "ValueType", ")", ";", "else", "if", "(", "ValueType", "==", "MVT", "::", "i8", "&&", "(", "Value", "&", "<NUM_LIT>", ")", "==", "Value", ")", "return", "DAG", ".", "getTargetConstant", "(", "Value", ",", "ValueType", ")", ";", "}", "return", "SDValue", "(", ")" ]

[ "A4_ext", ";" ]

[ "return", "MCI", ".", "getOpcode", "(", ")", "==", "Hexagon", "::" ]

[ "unsigned", "Align", "=", "TD", ".", "getPrefTypeAlignment", "(", "C", "->", "getType", "(", ")", ")", ";" ]

[ "unsigned", "ARMFastISel", "::", "ARMMaterializeInt", "(", "const", "Constant", "*", "C", ",", "MVT", "VT", ")", "{", "if", "(", "VT", "!=", "MVT", "::", "i32", "&&", "VT", "!=", "MVT", "::", "i16", "&&", "VT", "!=", "MVT", "::", "i8", "&&", "VT", "!=", "MVT", "::", "i1", ")", "return", "false", ";", "const", "ConstantInt", "*", "CI", "=", "cast", "<", "ConstantInt", ">", "(", "C", ")", ";", "if", "(", "Subtarget", "->", "hasV6T2Ops", "(", ")", "&&", "isUInt", "<", "<NUM_LIT>", ">", "(", "CI", "->", "getZExtValue", "(", ")", ")", ")", "{", "unsigned", "Opc", "=", "isThumb2", "?", "ARM", "::", "t2MOVi16", ":", "ARM", "::", "MOVi16", ";", "const", "TargetRegisterClass", "*", "RC", "=", "isThumb2", "?", "&", "ARM", "::", "rGPRRegClass", ":", "&", "ARM", "::", "GPRRegClass", ";", "unsigned", "ImmReg", "=", "createResultReg", "(", "RC", ")", ";", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "ImmReg", ")", ".", "addImm", "(", "CI", "->", "getZExtValue", "(", ")", ")", ")", ";", "return", "ImmReg", ";", "}", "if", "(", "VT", "==", "MVT", "::", "i32", "&&", "Subtarget", "->", "hasV6T2Ops", "(", ")", "&&", "CI", "->", "isNegative", "(", ")", ")", "{", "unsigned", "Imm", "=", "(", "unsigned", ")", "~", "(", "CI", "->", "getSExtValue", "(", ")", ")", ";", "bool", "UseImm", "=", "isThumb2", "?", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "Imm", ")", "!=", "-", "<NUM_LIT>", ")", ":", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "Imm", ")", "!=", "-", "<NUM_LIT>", ")", ";", "if", "(", "UseImm", ")", "{", "unsigned", "Opc", "=", "isThumb2", "?", "ARM", "::", "t2MVNi", ":", "ARM", "::", "MVNi", ";", "unsigned", "ImmReg", "=", "createResultReg", "(", "TLI", ".", "getRegClassFor", "(", "MVT", "::", "i32", ")", ")", ";", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "ImmReg", ")", ".", "addImm", "(", "Imm", ")", ")", ";", "return", "ImmReg", ";", "}", "}", "if", "(", "VT", "!=", "MVT", "::", "i32", ")", "return", "false", ";", "unsigned", "DestReg", "=", "createResultReg", "(", "TLI", ".", "getRegClassFor", "(", "VT", ")", ")", ";" ]

[ "<FIXS>", "{", "rtx", "addr", ",", "pool_ref", "=", "NULL_RTX", ";", "find_constant_pool_ref", "(", "PATTERN", "(", "insn", ")", ",", "&", "pool_ref", ")", ";", "if", "(", "pool_ref", ")", "{", "<FIXE>" ]

[ "continue", ";", "if", "(", "NONJUMP_INSN_P", "(", "insn", ")", "||", "CALL_P", "(", "insn", ")", ")", "<BUGS>", "{", "rtx", "addr", ",", "pool_ref", "=", "NULL_RTX", ";", "find_constant_pool_ref", "(", "PATTERN", "(", "insn", ")", ",", "&", "pool_ref", ")", ";", "if", "(", "pool_ref", ")", "{", "<BUGE>", "if", "(", "s390_execute_label", "(", "insn", ")", ")", "addr", "=", "s390_find_execute", "(", "curr_pool", ",", "insn", ")", ";", "else" ]

[ ">", ";" ]

[ "class", "FLOOR_W_S_MMR6_ENC", ":", "POOL32F_MATH_FM_MMR6", "<", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>" ]

[ "}" ]

[ "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "FramePtr", ":", "StackPtr", ";" ]

[ ",", "GENERAL_REGS", ")", ")", "{" ]

[ "int", "crx_memory_move_cost", "(", "enum", "machine_mode", "mode", ",", "enum", "reg_class", "class", "ATTRIBUTE_UNUSED", ",", "int", "in", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "reg_classes_intersect_p", "(", "class" ]

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

[ "MachineBasicBlock", "*", "StartMBB", "=", "MBB", ";", "MachineBasicBlock", "*", "DoneMBB", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", "MI", ",", "MBB", ")", ";", "MachineBasicBlock", "*", "LoopMBB", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", "StartMBB", ")", ";", "MBB", "=", "StartMBB", ";", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "LOpcode", ")", ",", "OrigVal", ")", ".", "add", "(", "Base", ")", ".", "addImm", "(", "Disp", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ";", "MBB", "->", "addSuccessor", "(", "LoopMBB", ")", ";", "MBB", "=", "LoopMBB", ";", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "OldVal", ")", ".", "addReg", "(", "OrigVal", ")", ".", "addMBB", "(", "StartMBB", ")", ".", "addReg", "(", "Dest", ")", ".", "addMBB", "(", "LoopMBB", ")", ";", "if", "(", "IsSubWord", ")", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "RotatedOldVal", ")", ".", "addReg", "(", "OldVal", ")", ".", "addReg", "(", "BitShift", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "if", "(", "Invert", ")", "{", "Register", "Tmp", "=", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ";", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "BinOpcode", ")", ",", "Tmp", ")", ".", "addReg", "(", "RotatedOldVal", ")", ".", "add", "(", "Src2", ")", ";", "if", "(", "BitSize", "<=", "<NUM_LIT>", ")", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "RotatedNewVal", ")", ".", "addReg", "(", "Tmp", ")", ".", "addImm", "(", "-", "<NUM_LIT>", "U", "<<", "(", "<NUM_LIT>", "-", "BitSize", ")", ")", ";", "else", "{", "Register", "Tmp2", "=", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ";", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "Tmp2", ")", ".", "addReg", "(", "Tmp", ")", ";", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "RotatedNewVal", ")", ".", "addReg", "(", "Tmp2", ")", ".", "addImm", "(", "-", "<NUM_LIT>", ")", ";", "}", "}", "else", "if", "(", "BinOpcode", ")", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "BinOpcode", ")", ",", "RotatedNewVal", ")", ".", "addReg", "(", "RotatedOldVal", ")", ".", "add", "(", "Src2", ")", ";", "else", "if", "(", "IsSubWord", ")", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "RotatedNewVal", ")", ".", "addReg", "(", "RotatedOldVal", ")", ".", "addReg", "(", "Src2", ".", "getReg", "(", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", "+", "BitSize", ")", ".", "addImm", "(", "<NUM_LIT>", "-", "BitSize", ")", ";", "if", "(", "IsSubWord", ")", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "NewVal", ")", ".", "addReg", "(", "RotatedNewVal", ")", ".", "addReg", "(", "NegBitShift", ")" ]

[ "}" ]

[ "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "MVT", "::", "i32", ")", ";", "if", "(", "N", "->", "hasOneUse", "(", ")", ")", "{", "return", "CurDAG", "->", "SelectNodeTo", "(", "N", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "MVT", "::", "i32", ",", "TFI", ",", "CurDAG", "->", "getTargetConstant", "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "}", "return", "CurDAG", "->", "getMachineNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i32", ",", "TFI", ",", "CurDAG", "->", "getTargetConstant", "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";" ]

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

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

[ "<FIXS>", "<STR_LIT>", "<FIXE>" ]

[ "(", "sign_extend", ":", "SI", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "mult", ":", "SI", "(", "sign_extend", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "sign_extend", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", ")" ]

[ "bytes", ")", "{" ]

[ "void", "setCalleeSavedFrameSize", "(", "unsigned" ]

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

[ "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "Node", "->", "setNodeId", "(", "-", "<NUM_LIT>", ")", ";", "return", ";", "}", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "MVT", "XLenVT", "=", "MVT", "::", "i16", ";", "SDLoc", "DL", "(", "Node", ")", ";", "EVT", "VT", "=", "Node", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "switch", "(", "Opcode", ")", "{", "case", "ISD", "::", "Constant", ":", "{", "auto", "ConstNode", "=", "cast", "<", "ConstantSDNode", ">", "(", "Node", ")", ";", "int64_t", "Imm", "=", "ConstNode", "->", "getSExtValue", "(", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i16", "||", "VT", "==", "MVT", "::", "i8", ")", "{", "ReplaceNode", "(", "Node", ",", "selectImm", "(", "CurDAG", ",", "SDLoc", "(", "Node", ")", ",", "Imm", ",", "VT", ")", ")", ";", "return", ";", "}", "break", ";", "}", "case", "ISD", "::", "FrameIndex", ":", "{", "int", "FI", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "Node", ")", "->", "getIndex", "(", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI" ]

[ "v2f64", ">", ";" ]

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

[ "Constraints", ";" ]

[ "let", "isCodeGenOnly", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "ps", ".", "Defs", ";", "let", "Uses", "=", "ps", ".", "Uses", ";", "let", "SchedRW", "=", "ps", ".", "SchedRW", ";", "let", "hasSideEffects", "=", "ps", ".", "hasSideEffects", ";", "let", "Constraints", "=", "ps", "." ]

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

[ "MVT", "WebAssemblyTargetLowering", "::", "getScalarShiftAmountTy", "(", "const", "DataLayout", "&", ",", "EVT", "VT", ")", "const", "{", "unsigned", "BitWidth", "=", "NextPowerOf2", "(", "VT", ".", "getSizeInBits", "(", ")", "-", "<NUM_LIT>", ")", ";", "if", "(", "BitWidth", ">", "<NUM_LIT>", "&&", "BitWidth", "<", "<NUM_LIT>", ")", "BitWidth", "=", "<NUM_LIT>", ";", "if", "(", "BitWidth", ">", "<NUM_LIT>", ")", "{" ]

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

[ "(", "define_insn", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "mem", ":", "QI", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<BUGE>", "(", "and", ":", "QI", "(", "mem", ":", "QI", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>" ]

[ "<FIXS>", "<STR_LIT>", ",", "IIC_IntGeneral", ">", ",", "SExt32To64", ";", "<FIXE>" ]

[ "def", "STOP", ":", "XForm_0", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", ")", ",", "<STR_LIT>", ",", "IIC_SprSTOP", ",", "[", "]", ">", ";", "def", "SETB", ":", "XForm_44", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "gprc", ":", "$", "RT", ")", ",", "(", "ins", "crrc", ":", "$", "BFA", ")", ",", "<BUGS>", "<STR_LIT>", ",", "IIC_IntGeneral", ">", ";", "<BUGE>", "}", "let", "Predicates", "=", "[", "IsISA3_0", "]", "in", "{" ]

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

[ "Kern", "[", "<STR_LIT>", ".kernarg_segment_size", "<STR_LIT>", "]", "=", "Kern", ".", "getDocument", "(", ")", "->", "getNode", "(", "STM", ".", "getKernArgSegmentSize", "(", "F", ",", "MaxKernArgAlign", ")", ")", ";", "Kern", "[", "<STR_LIT>", ".group_segment_fixed_size", "<STR_LIT>", "]", "=", "Kern", ".", "getDocument", "(", ")", "->", "getNode", "(", "ProgramInfo", ".", "LDSSize", ")", ";", "Kern", "[", "<STR_LIT>", ".private_segment_fixed_size", "<STR_LIT>", "]", "=", "Kern", ".", "getDocument", "(", ")", "->", "getNode", "(", "ProgramInfo", ".", "ScratchSize", ")", ";", "Kern", "[", "<STR_LIT>", ".kernarg_segment_align", "<STR_LIT>", "]", "=", "Kern", ".", "getDocument", "(", ")", "->", "getNode", "(", "std", "::", "max", "(", "Align", "(", "<NUM_LIT>", ")", ",", "MaxKernArgAlign", ")", ".", "value", "(", ")", ")", ";", "Kern", "[", "<STR_LIT>", ".wavefront_size", "<STR_LIT>", "]", "=", "Kern", ".", "getDocument", "(", ")", "->", "getNode", "(", "STM", ".", "getWavefrontSize", "(", ")", ")", ";", "Kern", "[", "<STR_LIT>", ".sgpr_count", "<STR_LIT>", "]", "=", "Kern", ".", "getDocument", "(", ")", "->", "getNode", "(", "ProgramInfo", ".", "NumSGPR", ")", ";", "Kern", "[", "<STR_LIT>", ".vgpr_count", "<STR_LIT>", "]", "=", "Kern", ".", "getDocument", "(", ")", "->", "getNode", "(", "ProgramInfo", ".", "NumVGPR", ")", ";", "if", "(", "STM", ".", "hasMAIInsts", "(", ")", ")", "{", "Kern", "[", "<STR_LIT>", ".agpr_count", "<STR_LIT>", "]", "=", "Kern", ".", "getDocument", "(", ")", "->", "getNode", "(", "ProgramInfo", ".", "NumAccVGPR", ")", ";", "}", "Kern", "[", "<STR_LIT>", ".max_flat_workgroup_size", "<STR_LIT>", "]", "=", "Kern", ".", "getDocument", "(", ")", "->", "getNode", "(", "MFI", ".", "getMaxFlatWorkGroupSize" ]

[ "hasOneUse", "(", ")", ")", "{" ]

[ "if", "(", "N1C", "&&", "N1C", "->", "isAllOnesValue", "(", ")", "&&", "N2C", "&&", "N2C", "->", "isNullValue", "(", ")", "&&", "RHSC", "&&", "RHSC", "->", "isNullValue", "(", ")", ")", "{", "SDValue", "CmpOp0", "=", "Cmp", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "Cmp", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i32", ",", "CmpOp0", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "CmpOp0", ".", "getValueType", "(", ")", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ",", "DAG", ".", "getConstant", "(", "X86", "::", "COND_B", ",", "MVT", "::", "i8", ")", ",", "Cmp", ")", ";", "}", "}", "}", "if", "(", "Cond", ".", "getOpcode", "(", ")", "==", "ISD", "::", "AND", "&&", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "C", "&&", "C", "->", "getAPIntValue", "(", ")", "==", "<NUM_LIT>", ")", "Cond", "=", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "}", "if", "(", "Cond", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Cond", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "CC", "=", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Cmp", "=", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "unsigned", "Opc", "=", "Cmp", ".", "getOpcode", "(", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "bool", "IllegalFPCMov", "=", "false", ";", "if", "(", "VT", ".", "isFloatingPoint", "(", ")", "&&", "!", "VT", ".", "isVector", "(", ")", "&&", "!", "isScalarFPTypeInSSEReg", "(", "VT", ")", ")", "IllegalFPCMov", "=", "!", "hasFPCMov", "(", "cast", "<", "ConstantSDNode", ">", "(", "CC", ")", "->", "getSExtValue", "(", ")", ")", ";", "if", "(", "(", "isX86LogicalCmp", "(", "Cmp", ")", "&&", "!", "IllegalFPCMov", ")", "||", "Opc", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "Cond", "=", "Cmp", ";", "addTest", "=", "false", ";", "}", "}", "if", "(", "addTest", ")", "{", "if", "(", "Cond", ".", "getOpcode", "(", ")", "==", "ISD", "::", "TRUNCATE", ")", "Cond", "=", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Cond", ".", "getOpcode", "(", ")", "==", "ISD", "::", "AND", "&&", "Cond", "." ]

[ "\\n", "'", ";" ]

[ "emitFunctionStart", "(", "MachineFunction", "&", "MF", ")", "{", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "SwitchToSection", "(", "TAI", "->", "SectionForGlobal", "(", "F", ")", ")", ";", "EmitAlignment", "(", "<NUM_LIT>", ",", "F", ")", ";", "O", "<<", "<STR_LIT>", "\\t.globl\\t", "<STR_LIT>", "<<", "CurrentFnName", "<<", "'", "\\n", "'", ";", "O", "<<", "<STR_LIT>", "\\t.ent\\t", "<STR_LIT>", "<<", "CurrentFnName", "<<", "'", "\\n", "'", ";", "printVisibility", "(", "CurrentFnName", ",", "F", "->", "getVisibility", "(", ")", ")", ";", "if", "(", "(", "TAI", "->", "hasDotTypeDotSizeDirective", "(", ")", ")", "&&", "Subtarget", "->", "isLinux", "(", ")", ")", "O", "<<", "<STR_LIT>", "\\t.type\\t", "<STR_LIT>", "<<", "CurrentFnName", "<<", "<STR_LIT>", ", @function\\n", "<STR_LIT>", ";", "O", "<<", "CurrentFnName", "<<", "<STR_LIT>", ":\\n", "<STR_LIT>", ";", "emitFrameDirective", "(", "MF", ")", ";", "printSavedRegsBitmask", "(", "MF", ")", ";", "O", "<<", "'" ]

[ ")", ";" ]

[ "vmax_f16", "(", "float16x4_t", "_", "_", "a", ",", "float16x4_t", "_", "_", "b", ")", "{", "return", "_", "_", "builtin_neon_vmaxfv4hf", "(", "_", "_", "a", ",", "_", "_", "b" ]

[ "USR_OVF", "]", ";" ]

[ "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", "=", "[" ]

[ ";" ]

[ "assert", "(", "(", "SrcBits", "<", "DestBits", ")", "&&", "<STR_LIT>", "can only extend to larger types", "<STR_LIT>", ")", ";", "assert", "(", "(", "DestBits", "==", "<NUM_LIT>", "||", "DestBits", "==", "<NUM_LIT>", "||", "DestBits", "==", "<NUM_LIT>", ")", "&&", "<STR_LIT>", "other sizes unimplemented", "<STR_LIT>", ")", ";", "assert", "(", "(", "SrcBits", "==", "<NUM_LIT>", "||", "SrcBits", "==", "<NUM_LIT>", "||", "SrcBits", "==", "<NUM_LIT>", ")", "&&", "<STR_LIT>", "other sizes unimplemented", "<STR_LIT>", ")", ";", "bool", "hasV6Ops", "=", "Subtarget", "->", "hasV6Ops", "(", ")", ";", "unsigned", "Bitness", "=", "SrcBits", "/", "<NUM_LIT>", ";", "assert", "(", "(", "Bitness", "<", "<NUM_LIT>", ")", "&&", "<STR_LIT>", "sanity-check table bounds", "<STR_LIT>", ")", ";", "bool", "isSingleInstr", "=", "isSingleInstrTbl", "[", "Bitness", "]", "[", "isThumb2", "]", "[", "hasV6Ops", "]", "[", "isZExt", "]", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RCTbl", "[", "isThumb2", "]", "[", "isSingleInstr", "]", ";", "const", "InstructionTable", "*", "ITP", "=", "&", "IT", "[", "isSingleInstr", "]", "[", "isThumb2", "]", "[", "Bitness", "]", "[", "isZExt", "]", ";", "unsigned", "Opc", "=", "ITP", "->", "Opc", ";", "assert", "(", "ARM", "::", "KILL", "!=", "Opc", "&&", "<STR_LIT>", "Invalid table entry", "<STR_LIT>", ")", ";", "unsigned", "hasS", "=", "ITP", "->", "hasS", ";", "<STR_LIT>", "::", "<STR_LIT>", "Shift", "=", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", "ITP", "->", "Shift", ";", "assert", "(", "(", "(", "Shift", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "==", "(", "Opc", "!=", "ARM", "::", "MOVsi", ")", ")", "&&", "<STR_LIT>", "only MOVsi has shift operand addressing mode", "<STR_LIT>", ")", ";", "unsigned", "Imm", "=", "ITP", "->", "Imm", ";", "bool", "setsCPSR", "=", "&", "ARM", "::", "tGPRRegClass", "==", "RC", ";", "unsigned", "LSLOpc", "=", "isThumb2", "?", "ARM", "::", "tLSLri", ":", "ARM", "::", "MOVsi", ";", "unsigned", "ResultReg", ";", "bool", "ImmIsSO", "=", "(", "Shift", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "unsigned", "NumInstrsEmitted", "=", "isSingleInstr", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "for", "(", "unsigned", "Instr", "=", "<NUM_LIT>", ";", "Instr", "!=", "NumInstrsEmitted", ";", "++", "Instr", ")", "{", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "bool", "isLsl", "=", "(", "<NUM_LIT>", "==", "Instr", ")", "&&", "!", "isSingleInstr", ";", "unsigned", "Opcode", "=", "isLsl", "?", "LSLOpc", ":", "Opc", ";", "<STR_LIT>", "::", "<STR_LIT>", "ShiftAM", "=", "isLsl", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "Shift", ";", "unsigned", "ImmEnc", "=", "ImmIsSO", "?", "<STR_LIT>", "::", "<STR_LIT>", "(", "ShiftAM", ",", "Imm", ")", ":", "Imm", ";", "bool", "isKill", "=", "<NUM_LIT>", "==", "Instr", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opcode", ")", ",", "ResultReg", ")", ";", "if", "(", "setsCPSR", ")", "MIB", ".", "addReg", "(", "ARM", "::", "CPSR", ",", "RegState", "::", "Define", ")", ";", "SrcReg", "=", "constrainOperandRegClass", "(", "TII", ".", "get", "(", "Opcode", ")", ",", "SrcReg", ",", "<NUM_LIT>", "+", "setsCPSR", ")", ";", "MIB", ".", "addReg", "(", "SrcReg", ",", "isKill", "*", "RegState", "::", "Kill", ")", ".", "addImm", "(", "ImmEnc", ")", ".", "add", "(", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "if", "(", "hasS", ")", "MIB", ".", "add", "(", "condCodeOp", "(", ")", ")", ";", "SrcReg", "=", "ResultReg", ";", "}", "return", "ResultReg", ";", "}", "bool", "ARMFastISel", "::", "SelectIntExt", "(", "const", "Instruction", "*", "I", ")", "{", "Type", "*", "DestTy", "=", "I", "->", "getType", "(", ")", ";", "Value", "*", "Src", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "Type", "*", "SrcTy", "=", "Src", "->", "getType", "(", ")", ";", "bool", "isZExt", "=", "isa", "<", "ZExtInst", ">", "(", "I", ")", ";", "Register", "SrcReg", "=", "getRegForValue", "(", "Src", ")", ";", "if", "(", "!", "SrcReg", ")", "return", "false", ";", "EVT", "SrcEVT", ",", "DestEVT", ";", "SrcEVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "SrcTy", ",", "true", ")", ";", "DestEVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "DestTy", ",", "true", ")", ";", "if", "(", "!", "SrcEVT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "if", "(", "!", "DestEVT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "MVT", "SrcVT", "=", "SrcEVT", ".", "getSimpleVT", "(", ")", ";", "MVT", "DestVT", "=", "DestEVT", ".", "getSimpleVT", "(", ")", ";", "unsigned", "ResultReg", "=", "ARMEmitIntExt", "(", "SrcVT", ",", "SrcReg", ",", "DestVT", ",", "isZExt", ")", ";", "if", "(", "ResultReg", "==", "<NUM_LIT>", ")", "return", "false", ";", "updateValueMap", "(", "I", ",", "ResultReg", ")", ";", "return", "true", ";", "}", "bool", "ARMFastISel", "::", "SelectShift", "(", "const", "Instruction", "*", "I", ",", "<STR_LIT>", "::", "<STR_LIT>", "ShiftTy", ")", "{", "if", "(", "isThumb2", ")", "return", "false", ";", "EVT", "DestVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "I", "->", "getType", "(", ")", ",", "true", ")", ";", "if", "(", "DestVT", "!=", "MVT", "::", "i32", ")", "return", "false", ";", "unsigned", "Opc", "=", "ARM", "::", "MOVsr", ";", "unsigned", "ShiftImm", ";", "Value", "*", "Src2Value", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "const", "ConstantInt", "*", "CI", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "Src2Value", ")", ")", "{", "ShiftImm", "=", "CI", "->", "getZExtValue", "(", ")", ";", "if", "(", "ShiftImm", "==", "<NUM_LIT>", "||", "ShiftImm", ">=", "<NUM_LIT>", ")", "return", "false", ";", "Opc", "=", "ARM", "::", "MOVsi", ";", "}", "Value", "*", "Src1Value", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "Register", "Reg1", "=", "getRegForValue", "(", "Src1Value", ")", ";", "if", "(", "Reg1", "==", "<NUM_LIT>", ")", "return", "false", ";", "unsigned", "Reg2", "=", "<NUM_LIT>", ";", "if", "(", "Opc", "==", "ARM", "::", "MOVsr", ")", "{", "Reg2", "=", "getRegForValue", "(", "Src2Value", ")", ";", "if", "(", "Reg2", "==", "<NUM_LIT>", ")", "return", "false", ";", "}", "Register", "ResultReg", "=", "createResultReg", "(", "&", "ARM", "::", "GPRnopcRegClass", ")", ";", "if", "(", "ResultReg", "==", "<NUM_LIT>", ")", "return", "false", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "ResultReg", ")", ".", "addReg", "(", "Reg1", ")", ";", "if", "(", "Opc", "==", "ARM", "::", "MOVsi", ")", "MIB", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "ShiftTy", ",", "ShiftImm", ")", ")", ";", "else", "if", "(", "Opc", "==", "ARM", "::", "MOVsr", ")", "{", "MIB", ".", "addReg", "(", "Reg2", ")", ";", "MIB", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "ShiftTy", ",", "<NUM_LIT>", ")", ")", ";", "}", "AddOptionalDefs", "(", "MIB", ")", ";", "updateValueMap", "(", "I", ",", "ResultReg", ")", ";", "return", "true", ";", "}", "bool", "ARMFastISel", "::", "fastSelectInstruction", "(", "const", "Instruction", "*", "I", ")", "{", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "case", "Instruction", "::", "Load", ":", "return", "SelectLoad", "(", "I", ")", ";", "case", "Instruction", "::", "Store", ":", "return", "SelectStore", "(", "I", ")", ";", "case", "Instruction", "::", "Br", ":", "return", "SelectBranch", "(", "I", ")", ";", "case", "Instruction", "::", "IndirectBr", ":", "return", "SelectIndirectBr", "(", "I", ")", ";", "case", "Instruction", "::", "ICmp", ":", "case", "Instruction", "::", "FCmp", ":", "return", "SelectCmp", "(", "I", ")", ";", "case", "Instruction", "::", "FPExt", ":", "return", "SelectFPExt", "(", "I", ")" ]

[ ")", "{" ]

[ "_", "_", "arm_vcmphiq_u32", "(", "uint32x4_t", "_", "_", "a", ",", "uint32x4_t", "_", "_", "b" ]

[ "_", "v8si", ")", "_", "_", "B", ",", "(", "_", "_", "v8si", ")", "_", "_", "C", ")", ";" ]

[ "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_ia32_vpshldv_v8si", "(", "(", "_", "_", "v8si", ")", "_", "_", "A", ",", "(", "_" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isMoveImm", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";" ]

[ "<NUM_LIT>", ",", "size", ",", "pred_basic_i", ">", "{" ]

[ "class", "MVE_VCMPqqi", "<", "string", "suffix", ",", "bits", "<", "<NUM_LIT>", ">", "size", ">", ":", "MVE_VCMPqq", "<", "suffix", "," ]

[ "emit_move_insn_1", "(", "adjust_address", "(", "operands", "[", "<NUM_LIT>", "]", ",", "SImode", ",", "<NUM_LIT>", ")", ",", "const0_rtx", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "VM64", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VM64", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "[", "(", "clobber", "(", "const_int", "<NUM_LIT>", ")", ")", "]", "{", "emit_move_insn_1", "(", "adjust_address", "(", "operands", "[", "<NUM_LIT>", "]", ",", "SImode", ",", "<NUM_LIT>", ")", ",", "const0_rtx", ")" ]

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

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