Datasets:

---

docz1105

/

ComBack

like 10

[ "<s>", "unsigned", "PPCTargetLowering", "::", "getExceptionSelectorRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "{", "return", "Subtarget", ".", "isPPC64", "(", ")", "?", "PPC", "::", "X4", ":", "PPC", "::", "R4", ";", "}", "</s>" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "typeid", "on", "entry", "to", "a", "landing", "pad", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::X4", "PPC::R4" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "Subtarget", "=", "&", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "addPass", "(", "createSIWholeQuadModePass", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "static", "rtx", "paired_expand_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "bool", "*", "expandedp", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ";", "enum", "rs6000_builtins", "fcode", "=", "(", "enum", "rs6000_builtins", ")", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ";", "const", "struct", "builtin_description", "*", "d", ";", "size_t", "i", ";", "*", "expandedp", "=", "true", ";", "switch", "(", "fcode", ")", "{", "case", "PAIRED_BUILTIN_STX", ":", "return", "paired_expand_stv_builtin", "(", "CODE_FOR_paired_stx", ",", "exp", ")", ";", "case", "PAIRED_BUILTIN_LX", ":", "return", "paired_expand_lv_builtin", "(", "CODE_FOR_paired_lx", ",", "exp", ",", "target", ")", ";", "default", ":", "break", ";", "}", "d", "=", "bdesc_paired_preds", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "bdesc_paired_preds", ")", ";", "i", "++", ",", "d", "++", ")", "if", "(", "d", "->", "code", "==", "fcode", ")", "return", "paired_expand_predicate_builtin", "(", "d", "->", "icode", ",", "exp", ",", "target", ")", ";", "*", "expandedp", "=", "false", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Expand", "the", "builtin", "in", "EXP", "and", "store", "the", "result", "in", "TARGET", ".", "Store", "true", "in", "*", "EXPANDEDP", "if", "we", "found", "a", "builtin", "to", "expand", "." ]

[ "powerpcspe", "0", "0" ]

[]

[ "<s>", "bool", "AArch64AsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "if", "(", "!", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNum", ",", "AsmVariant", ",", "ExtraCode", ",", "O", ")", ")", "return", "false", ";", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'w'", ":", "case", "'x'", ":", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "printAsmMRegister", "(", "MO", ",", "ExtraCode", "[", "0", "]", ",", "O", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", "&&", "MO", ".", "getImm", "(", ")", "==", "0", ")", "{", "unsigned", "Reg", "=", "ExtraCode", "[", "0", "]", "==", "'w'", "?", "AArch64", "::", "WZR", ":", "AArch64", "::", "XZR", ";", "O", "<<", "AArch64InstPrinter", "::", "getRegisterName", "(", "Reg", ")", ";", "return", "false", ";", "}", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "case", "'b'", ":", "case", "'h'", ":", "case", "'s'", ":", "case", "'d'", ":", "case", "'q'", ":", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "const", "TargetRegisterClass", "*", "RC", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "case", "'b'", ":", "RC", "=", "&", "AArch64", "::", "FPR8RegClass", ";", "break", ";", "case", "'h'", ":", "RC", "=", "&", "AArch64", "::", "FPR16RegClass", ";", "break", ";", "case", "'s'", ":", "RC", "=", "&", "AArch64", "::", "FPR32RegClass", ";", "break", ";", "case", "'d'", ":", "RC", "=", "&", "AArch64", "::", "FPR64RegClass", ";", "break", ";", "case", "'q'", ":", "RC", "=", "&", "AArch64", "::", "FPR128RegClass", ";", "break", ";", "default", ":", "return", "true", ";", "}", "return", "printAsmRegInClass", "(", "MO", ",", "RC", ",", "false", ",", "O", ")", ";", "}", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "}", "}", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "AArch64", "::", "GPR32allRegClass", ".", "contains", "(", "Reg", ")", "||", "AArch64", "::", "GPR64allRegClass", ".", "contains", "(", "Reg", ")", ")", "return", "printAsmMRegister", "(", "MO", ",", "'x'", ",", "O", ")", ";", "return", "printAsmRegInClass", "(", "MO", ",", "&", "AArch64", "::", "FPR128RegClass", ",", "true", ",", "O", ")", ";", "}", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

[ "AArch64", "AArch64", "0", "1", "0", "0", "0", "0", "0", "AArch64::WZR", "AArch64::XZR", "AArch64", "0", "AArch64::FPR8RegClass", "AArch64::FPR16RegClass", "AArch64::FPR32RegClass", "AArch64::FPR64RegClass", "AArch64::FPR128RegClass", "AArch64::GPR32allRegClass", "AArch64::GPR64allRegClass", "AArch64::FPR128RegClass" ]

[]

[ "<s>", "static", "int", "need_to_save", "(", "int", "regno", ")", "{", "if", "(", "fixed_regs", "[", "regno", "]", ")", "return", "0", ";", "if", "(", "cfun", "->", "calls_eh_return", ")", "return", "1", ";", "if", "(", "regno", "==", "FP_REGNO", ")", "return", "0", ";", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", "&&", "(", "!", "cfun", "->", "machine", "->", "is_leaf", "||", "regno", "==", "A0_REGNO", ")", ")", "return", "1", ";", "if", "(", "regs_ever_live", "[", "regno", "]", "&&", "(", "!", "call_used_regs", "[", "regno", "]", "||", "cfun", "->", "machine", "->", "is_interrupt", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "given", "register", "needs", "to", "be", "saved", "by", "the", "current", "function", "." ]

[ "m32c", "0", "1", "0", "1", "1", "0" ]

[]

[ "<s>", "static", "void", "c6x_init_builtins", "(", "void", ")", "{", "tree", "V4QI_type_node", "=", "build_vector_type", "(", "unsigned_intQI_type_node", ",", "4", ")", ";", "tree", "V2HI_type_node", "=", "build_vector_type", "(", "intHI_type_node", ",", "2", ")", ";", "tree", "V2SI_type_node", "=", "build_vector_type", "(", "intSI_type_node", ",", "2", ")", ";", "tree", "int_ftype_int", "=", "build_function_type_list", "(", "integer_type_node", ",", "integer_type_node", ",", "NULL_TREE", ")", ";", "tree", "int_ftype_int_int", "=", "build_function_type_list", "(", "integer_type_node", ",", "integer_type_node", ",", "integer_type_node", ",", "NULL_TREE", ")", ";", "tree", "v2hi_ftype_v2hi", "=", "build_function_type_list", "(", "V2HI_type_node", ",", "V2HI_type_node", ",", "NULL_TREE", ")", ";", "tree", "v4qi_ftype_v4qi_v4qi", "=", "build_function_type_list", "(", "V4QI_type_node", ",", "V4QI_type_node", ",", "V4QI_type_node", ",", "NULL_TREE", ")", ";", "tree", "v2hi_ftype_v2hi_v2hi", "=", "build_function_type_list", "(", "V2HI_type_node", ",", "V2HI_type_node", ",", "V2HI_type_node", ",", "NULL_TREE", ")", ";", "tree", "v2si_ftype_v2hi_v2hi", "=", "build_function_type_list", "(", "V2SI_type_node", ",", "V2HI_type_node", ",", "V2HI_type_node", ",", "NULL_TREE", ")", ";", "def_builtin", "(", "\"__builtin_c6x_sadd\"", ",", "int_ftype_int_int", ",", "C6X_BUILTIN_SADD", ")", ";", "def_builtin", "(", "\"__builtin_c6x_ssub\"", ",", "int_ftype_int_int", ",", "C6X_BUILTIN_SSUB", ")", ";", "def_builtin", "(", "\"__builtin_c6x_add2\"", ",", "v2hi_ftype_v2hi_v2hi", ",", "C6X_BUILTIN_ADD2", ")", ";", "def_builtin", "(", "\"__builtin_c6x_sub2\"", ",", "v2hi_ftype_v2hi_v2hi", ",", "C6X_BUILTIN_SUB2", ")", ";", "def_builtin", "(", "\"__builtin_c6x_add4\"", ",", "v4qi_ftype_v4qi_v4qi", ",", "C6X_BUILTIN_ADD4", ")", ";", "def_builtin", "(", "\"__builtin_c6x_sub4\"", ",", "v4qi_ftype_v4qi_v4qi", ",", "C6X_BUILTIN_SUB4", ")", ";", "def_builtin", "(", "\"__builtin_c6x_mpy2\"", ",", "v2si_ftype_v2hi_v2hi", ",", "C6X_BUILTIN_MPY2", ")", ";", "def_builtin", "(", "\"__builtin_c6x_sadd2\"", ",", "v2hi_ftype_v2hi_v2hi", ",", "C6X_BUILTIN_SADD2", ")", ";", "def_builtin", "(", "\"__builtin_c6x_ssub2\"", ",", "v2hi_ftype_v2hi_v2hi", ",", "C6X_BUILTIN_SSUB2", ")", ";", "def_builtin", "(", "\"__builtin_c6x_saddu4\"", ",", "v4qi_ftype_v4qi_v4qi", ",", "C6X_BUILTIN_SADDU4", ")", ";", "def_builtin", "(", "\"__builtin_c6x_smpy2\"", ",", "v2si_ftype_v2hi_v2hi", ",", "C6X_BUILTIN_SMPY2", ")", ";", "def_builtin", "(", "\"__builtin_c6x_smpy\"", ",", "int_ftype_int_int", ",", "C6X_BUILTIN_SMPY", ")", ";", "def_builtin", "(", "\"__builtin_c6x_smpyh\"", ",", "int_ftype_int_int", ",", "C6X_BUILTIN_SMPYH", ")", ";", "def_builtin", "(", "\"__builtin_c6x_smpyhl\"", ",", "int_ftype_int_int", ",", "C6X_BUILTIN_SMPYHL", ")", ";", "def_builtin", "(", "\"__builtin_c6x_smpylh\"", ",", "int_ftype_int_int", ",", "C6X_BUILTIN_SMPYLH", ")", ";", "def_builtin", "(", "\"__builtin_c6x_sshl\"", ",", "int_ftype_int_int", ",", "C6X_BUILTIN_SSHL", ")", ";", "def_builtin", "(", "\"__builtin_c6x_subc\"", ",", "int_ftype_int_int", ",", "C6X_BUILTIN_SUBC", ")", ";", "def_builtin", "(", "\"__builtin_c6x_avg2\"", ",", "v2hi_ftype_v2hi_v2hi", ",", "C6X_BUILTIN_AVG2", ")", ";", "def_builtin", "(", "\"__builtin_c6x_avgu4\"", ",", "v4qi_ftype_v4qi_v4qi", ",", "C6X_BUILTIN_AVGU4", ")", ";", "def_builtin", "(", "\"__builtin_c6x_clrr\"", ",", "int_ftype_int_int", ",", "C6X_BUILTIN_CLRR", ")", ";", "def_builtin", "(", "\"__builtin_c6x_extr\"", ",", "int_ftype_int_int", ",", "C6X_BUILTIN_EXTR", ")", ";", "def_builtin", "(", "\"__builtin_c6x_extru\"", ",", "int_ftype_int_int", ",", "C6X_BUILTIN_EXTRU", ")", ";", "def_builtin", "(", "\"__builtin_c6x_abs\"", ",", "int_ftype_int", ",", "C6X_BUILTIN_ABS", ")", ";", "def_builtin", "(", "\"__builtin_c6x_abs2\"", ",", "v2hi_ftype_v2hi", ",", "C6X_BUILTIN_ABS2", ")", ";", "}", "</s>" ]

[ "Set", "up", "all", "builtin", "functions", "for", "this", "target", "." ]

[ "c6x", "4", "2", "2", "\"__builtin_c6x_sadd\"", "\"__builtin_c6x_ssub\"", "\"__builtin_c6x_add2\"", "\"__builtin_c6x_sub2\"", "\"__builtin_c6x_add4\"", "\"__builtin_c6x_sub4\"", "\"__builtin_c6x_mpy2\"", "\"__builtin_c6x_sadd2\"", "\"__builtin_c6x_ssub2\"", "\"__builtin_c6x_saddu4\"", "\"__builtin_c6x_smpy2\"", "\"__builtin_c6x_smpy\"", "\"__builtin_c6x_smpyh\"", "\"__builtin_c6x_smpyhl\"", "\"__builtin_c6x_smpylh\"", "\"__builtin_c6x_sshl\"", "\"__builtin_c6x_subc\"", "\"__builtin_c6x_avg2\"", "\"__builtin_c6x_avgu4\"", "\"__builtin_c6x_clrr\"", "\"__builtin_c6x_extr\"", "\"__builtin_c6x_extru\"", "\"__builtin_c6x_abs\"", "\"__builtin_c6x_abs2\"" ]

[]

[ "<s>", "tree", "ix86_valid_target_attribute_tree", "(", "tree", "fndecl", ",", "tree", "args", ",", "struct", "gcc_options", "*", "opts", ",", "struct", "gcc_options", "*", "opts_set", ",", "bool", "target_clone_attr", ")", "{", "const", "char", "*", "orig_arch_string", "=", "opts", "->", "x_ix86_arch_string", ";", "const", "char", "*", "orig_tune_string", "=", "opts", "->", "x_ix86_tune_string", ";", "enum", "fpmath_unit", "orig_fpmath_set", "=", "opts_set", "->", "x_ix86_fpmath", ";", "enum", "prefer_vector_width", "orig_pvw_set", "=", "opts_set", "->", "x_prefer_vector_width_type", ";", "enum", "prefer_vector_width", "orig_ix86_move_max_set", "=", "opts_set", "->", "x_ix86_move_max", ";", "enum", "prefer_vector_width", "orig_ix86_store_max_set", "=", "opts_set", "->", "x_ix86_store_max", ";", "int", "orig_tune_defaulted", "=", "ix86_tune_defaulted", ";", "int", "orig_arch_specified", "=", "ix86_arch_specified", ";", "char", "*", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_MAX", "]", "=", "{", "NULL", ",", "NULL", "}", ";", "tree", "t", "=", "NULL_TREE", ";", "struct", "cl_target_option", "*", "def", "=", "TREE_TARGET_OPTION", "(", "target_option_default_node", ")", ";", "struct", "gcc_options", "enum_opts_set", ";", "memset", "(", "&", "enum_opts_set", ",", "0", ",", "sizeof", "(", "enum_opts_set", ")", ")", ";", "if", "(", "!", "ix86_valid_target_attribute_inner_p", "(", "fndecl", ",", "args", ",", "option_strings", ",", "opts", ",", "opts_set", ",", "&", "enum_opts_set", ",", "target_clone_attr", ")", ")", "return", "error_mark_node", ";", "if", "(", "opts", "->", "x_ix86_isa_flags", "!=", "def", "->", "x_ix86_isa_flags", "||", "opts", "->", "x_ix86_isa_flags2", "!=", "def", "->", "x_ix86_isa_flags2", "||", "opts", "->", "x_target_flags", "!=", "def", "->", "x_target_flags", "||", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_ARCH", "]", "||", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_TUNE", "]", "||", "enum_opts_set", ".", "x_ix86_fpmath", "||", "enum_opts_set", ".", "x_prefer_vector_width_type", ")", "{", "if", "(", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_ARCH", "]", ")", "opts", "->", "x_ix86_arch_string", "=", "ggc_strdup", "(", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_ARCH", "]", ")", ";", "else", "if", "(", "!", "orig_arch_specified", ")", "opts", "->", "x_ix86_arch_string", "=", "NULL", ";", "if", "(", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_TUNE", "]", ")", "opts", "->", "x_ix86_tune_string", "=", "ggc_strdup", "(", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_TUNE", "]", ")", ";", "else", "if", "(", "orig_tune_defaulted", ")", "opts", "->", "x_ix86_tune_string", "=", "NULL", ";", "if", "(", "enum_opts_set", ".", "x_ix86_fpmath", ")", "opts_set", "->", "x_ix86_fpmath", "=", "(", "enum", "fpmath_unit", ")", "1", ";", "if", "(", "enum_opts_set", ".", "x_prefer_vector_width_type", ")", "opts_set", "->", "x_prefer_vector_width_type", "=", "(", "enum", "prefer_vector_width", ")", "1", ";", "bool", "r", "=", "ix86_option_override_internal", "(", "false", ",", "opts", ",", "opts_set", ")", ";", "if", "(", "!", "r", ")", "{", "release_options_strings", "(", "option_strings", ")", ";", "return", "error_mark_node", ";", "}", "ix86_add_new_builtins", "(", "opts", "->", "x_ix86_isa_flags", ",", "opts", "->", "x_ix86_isa_flags2", ")", ";", "enum", "excess_precision", "orig_ix86_excess_precision", "=", "opts", "->", "x_ix86_excess_precision", ";", "bool", "orig_ix86_unsafe_math_optimizations", "=", "opts", "->", "x_ix86_unsafe_math_optimizations", ";", "opts", "->", "x_ix86_excess_precision", "=", "opts", "->", "x_flag_excess_precision", ";", "opts", "->", "x_ix86_unsafe_math_optimizations", "=", "opts", "->", "x_flag_unsafe_math_optimizations", ";", "t", "=", "build_target_option_node", "(", "opts", ",", "opts_set", ")", ";", "opts", "->", "x_ix86_arch_string", "=", "orig_arch_string", ";", "opts", "->", "x_ix86_tune_string", "=", "orig_tune_string", ";", "opts_set", "->", "x_ix86_fpmath", "=", "orig_fpmath_set", ";", "opts_set", "->", "x_prefer_vector_width_type", "=", "orig_pvw_set", ";", "opts_set", "->", "x_ix86_move_max", "=", "orig_ix86_move_max_set", ";", "opts_set", "->", "x_ix86_store_max", "=", "orig_ix86_store_max_set", ";", "opts", "->", "x_ix86_excess_precision", "=", "orig_ix86_excess_precision", ";", "opts", "->", "x_ix86_unsafe_math_optimizations", "=", "orig_ix86_unsafe_math_optimizations", ";", "release_options_strings", "(", "option_strings", ")", ";", "}", "return", "t", ";", "}", "</s>" ]

[ "Return", "a", "TARGET_OPTION_NODE", "tree", "of", "the", "target", "options", "listed", "or", "NULL", "." ]

[ "i386", "0", "1", "1" ]

[]

[ "<s>", "bool", "AArch64Subtarget", "::", "supportsAddressTopByteIgnored", "(", ")", "const", "{", "if", "(", "!", "UseAddressTopByteIgnored", ")", "return", "false", ";", "if", "(", "TargetTriple", ".", "isiOS", "(", ")", ")", "{", "unsigned", "Major", ",", "Minor", ",", "Micro", ";", "TargetTriple", ".", "getiOSVersion", "(", "Major", ",", "Minor", ",", "Micro", ")", ";", "return", "Major", ">=", "8", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "CPU", "has", "TBI", "(", "top", "byte", "of", "addresses", "is", "ignored", "during", "HW", "address", "translation", ")", "and", "OS", "enables", "it", "." ]

[ "AArch64", "AArch64", "8" ]

[]

[ "<s>", "SDValue", "ARMSelectionDAGInfo", "::", "EmitTargetCodeForMemset", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "MachinePointerInfo", "DstPtrInfo", ")", "const", "{", "return", "EmitSpecializedLibcall", "(", "DAG", ",", "dl", ",", "Chain", ",", "Dst", ",", "Src", ",", "Size", ",", "Align", ",", "RTLIB", "::", "MEMSET", ")", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memset", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "output_ascii", "(", "FILE", "*", "file", ",", "const", "char", "*", "p", ",", "int", "n", ")", "{", "char", "c", ";", "int", "i", ",", "count_string", ";", "const", "char", "*", "for_string", "=", "\"\\t.byte \\\"\"", ";", "const", "char", "*", "for_decimal", "=", "\"\\t.byte \"", ";", "const", "char", "*", "to_close", "=", "NULL", ";", "count_string", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "{", "c", "=", "*", "p", "++", ";", "if", "(", "c", ">=", "' '", "&&", "c", "<", "0177", ")", "{", "if", "(", "for_string", ")", "fputs", "(", "for_string", ",", "file", ")", ";", "putc", "(", "c", ",", "file", ")", ";", "if", "(", "c", "==", "'\"'", ")", "{", "putc", "(", "c", ",", "file", ")", ";", "++", "count_string", ";", "}", "for_string", "=", "NULL", ";", "for_decimal", "=", "\"\\\"\\n\\t.byte \"", ";", "to_close", "=", "\"\\\"\\n\"", ";", "++", "count_string", ";", "if", "(", "count_string", ">=", "512", ")", "{", "fputs", "(", "to_close", ",", "file", ")", ";", "for_string", "=", "\"\\t.byte \\\"\"", ";", "for_decimal", "=", "\"\\t.byte \"", ";", "to_close", "=", "NULL", ";", "count_string", "=", "0", ";", "}", "}", "else", "{", "if", "(", "for_decimal", ")", "fputs", "(", "for_decimal", ",", "file", ")", ";", "fprintf", "(", "file", ",", "\"%d\"", ",", "c", ")", ";", "for_string", "=", "\"\\n\\t.byte \\\"\"", ";", "for_decimal", "=", "\", \"", ";", "to_close", "=", "\"\\n\"", ";", "count_string", "=", "0", ";", "}", "}", "if", "(", "to_close", ")", "fputs", "(", "to_close", ",", "file", ")", ";", "}", "</s>" ]

[ "Output", "an", "assembler", "pseudo-op", "to", "write", "an", "ASCII", "string", "of", "N", "characters", "starting", "at", "P", "to", "FILE", ".", "On", "the", "RS/6000", ",", "we", "have", "to", "do", "this", "using", "the", ".byte", "operation", "and", "write", "out", "special", "characters", "outside", "the", "quoted", "string", ".", "Also", ",", "the", "assembler", "is", "broken", ";", "very", "long", "strings", "are", "truncated", ",", "so", "we", "must", "artificially", "break", "them", "up", "early", "." ]

[ "powerpcspe", "\"\\t.byte \\\"\"", "\"\\t.byte \"", "0", "0", "0177", "\"\\\"\\n\\t.byte \"", "\"\\\"\\n\"", "512", "\"\\t.byte \\\"\"", "\"\\t.byte \"", "0", "\"%d\"", "\"\\n\\t.byte \\\"\"", "\", \"", "\"\\n\"", "0" ]

[]

[ "<s>", "static", "void", "csky_output_constpool_label", "(", "FILE", "*", "stream", ",", "rtx", "x", ")", "{", "char", "buf", "[", "15", "]", ";", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC_VOLATILE", "&&", "XINT", "(", "x", ",", "1", ")", "==", "VUNSPEC_POOL_LABEL", ")", "{", "ASM_GENERATE_INTERNAL_LABEL", "(", "buf", ",", "CSKY_CONSTPOOL_LABEL_PREFIX", ",", "INTVAL", "(", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ")", ")", ";", "assemble_name", "(", "stream", ",", "buf", ")", ";", "}", "}", "</s>" ]

[ "Output", "the", "constpool", "label", "according", "to", "the", "rtx", "expression", "X", "." ]

[ "csky", "15", "0", "1", "0", "0" ]

[]

[ "<s>", "HOST_WIDE_INT", "ix86_convert_const_vector_to_integer", "(", "rtx", "op", ",", "machine_mode", "mode", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", ")", "gcc_unreachable", "(", ")", ";", "int", "nunits", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "wide_int", "val", "=", "wi", "::", "zero", "(", "GET_MODE_BITSIZE", "(", "mode", ")", ")", ";", "machine_mode", "innermode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "unsigned", "int", "innermode_bits", "=", "GET_MODE_BITSIZE", "(", "innermode", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_V2QImode", ":", "case", "E_V4QImode", ":", "case", "E_V2HImode", ":", "case", "E_V8QImode", ":", "case", "E_V4HImode", ":", "case", "E_V2SImode", ":", "for", "(", "int", "i", "=", "0", ";", "i", "<", "nunits", ";", "++", "i", ")", "{", "int", "v", "=", "INTVAL", "(", "XVECEXP", "(", "op", ",", "0", ",", "i", ")", ")", ";", "wide_int", "wv", "=", "wi", "::", "shwi", "(", "v", ",", "innermode_bits", ")", ";", "val", "=", "wi", "::", "insert", "(", "val", ",", "wv", ",", "innermode_bits", "*", "i", ",", "innermode_bits", ")", ";", "}", "break", ";", "case", "E_V2HFmode", ":", "case", "E_V2BFmode", ":", "case", "E_V4HFmode", ":", "case", "E_V4BFmode", ":", "case", "E_V2SFmode", ":", "for", "(", "int", "i", "=", "0", ";", "i", "<", "nunits", ";", "++", "i", ")", "{", "rtx", "x", "=", "XVECEXP", "(", "op", ",", "0", ",", "i", ")", ";", "int", "v", "=", "real_to_target", "(", "NULL", ",", "CONST_DOUBLE_REAL_VALUE", "(", "x", ")", ",", "REAL_MODE_FORMAT", "(", "innermode", ")", ")", ";", "wide_int", "wv", "=", "wi", "::", "shwi", "(", "v", ",", "innermode_bits", ")", ";", "val", "=", "wi", "::", "insert", "(", "val", ",", "wv", ",", "innermode_bits", "*", "i", ",", "innermode_bits", ")", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "val", ".", "to_shwi", "(", ")", ";", "}", "</s>" ]

[ "Return", "HOST_WIDE_INT", "for", "const", "vector", "OP", "in", "MODE", "." ]

[ "i386", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "shouldSinkOperands", "(", "Instruction", "*", "I", ",", "SmallVectorImpl", "<", "Use", "*", ">", "&", "Ops", ")", "const", "{", "if", "(", "!", "I", "->", "getType", "(", ")", "->", "isVectorTy", "(", ")", ")", "return", "false", ";", "if", "(", "Subtarget", "->", "hasNEON", "(", ")", ")", "{", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "case", "Instruction", "::", "Sub", ":", "case", "Instruction", "::", "Add", ":", "{", "if", "(", "!", "areExtractExts", "(", "I", "->", "getOperand", "(", "0", ")", ",", "I", "->", "getOperand", "(", "1", ")", ")", ")", "return", "false", ";", "Ops", ".", "push_back", "(", "&", "I", "->", "getOperandUse", "(", "0", ")", ")", ";", "Ops", ".", "push_back", "(", "&", "I", "->", "getOperandUse", "(", "1", ")", ")", ";", "return", "true", ";", "}", "default", ":", "return", "false", ";", "}", "}", "if", "(", "!", "Subtarget", "->", "hasMVEIntegerOps", "(", ")", ")", "return", "false", ";", "auto", "IsSinker", "=", "[", "]", "(", "Instruction", "*", "I", ",", "int", "Operand", ")", "{", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "case", "Instruction", "::", "Add", ":", "case", "Instruction", "::", "Mul", ":", "return", "true", ";", "case", "Instruction", "::", "Sub", ":", "return", "Operand", "==", "1", ";", "default", ":", "return", "false", ";", "}", "}", ";", "int", "Op", "=", "0", ";", "if", "(", "!", "isa", "<", "ShuffleVectorInst", ">", "(", "I", "->", "getOperand", "(", "Op", ")", ")", ")", "Op", "=", "1", ";", "if", "(", "!", "IsSinker", "(", "I", ",", "Op", ")", ")", "return", "false", ";", "if", "(", "!", "match", "(", "I", "->", "getOperand", "(", "Op", ")", ",", "m_ShuffleVector", "(", "m_InsertElement", "(", "m_Undef", "(", ")", ",", "m_Value", "(", ")", ",", "m_ZeroInt", "(", ")", ")", ",", "m_Undef", "(", ")", ",", "m_Zero", "(", ")", ")", ")", ")", "{", "return", "false", ";", "}", "Instruction", "*", "Shuffle", "=", "cast", "<", "Instruction", ">", "(", "I", "->", "getOperand", "(", "Op", ")", ")", ";", "for", "(", "Use", "&", "U", ":", "Shuffle", "->", "uses", "(", ")", ")", "{", "Instruction", "*", "Insn", "=", "cast", "<", "Instruction", ">", "(", "U", ".", "getUser", "(", ")", ")", ";", "if", "(", "!", "IsSinker", "(", "Insn", ",", "U", ".", "getOperandNo", "(", ")", ")", ")", "return", "false", ";", "}", "Ops", ".", "push_back", "(", "&", "Shuffle", "->", "getOperandUse", "(", "0", ")", ")", ";", "Ops", ".", "push_back", "(", "&", "I", "->", "getOperandUse", "(", "Op", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "sinking", "I", "'s", "operands", "to", "the", "same", "basic", "block", "as", "I", "is", "profitable", ",", "e.g", "." ]

[ "ARM", "ARM", "0", "1", "0", "1", "1", "0", "1", "0" ]

[]

[ "<s>", "unsigned", "X86TargetLowering", "::", "getVectorTypeBreakdownForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ",", "EVT", "&", "IntermediateVT", ",", "unsigned", "&", "NumIntermediates", ",", "MVT", "&", "RegisterVT", ")", "const", "{", "if", "(", "VT", ".", "isVector", "(", ")", "&&", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", "&&", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "(", "!", "isPowerOf2_32", "(", "VT", ".", "getVectorNumElements", "(", ")", ")", "||", "(", "VT", ".", "getVectorNumElements", "(", ")", ">", "16", "&&", "!", "Subtarget", ".", "hasBWI", "(", ")", ")", "||", "(", "VT", ".", "getVectorNumElements", "(", ")", ">", "64", "&&", "Subtarget", ".", "hasBWI", "(", ")", ")", ")", ")", "{", "RegisterVT", "=", "MVT", "::", "i8", ";", "IntermediateVT", "=", "MVT", "::", "i1", ";", "NumIntermediates", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "return", "NumIntermediates", ";", "}", "return", "TargetLowering", "::", "getVectorTypeBreakdownForCallingConv", "(", "Context", ",", "CC", ",", "VT", ",", "IntermediateVT", ",", "NumIntermediates", ",", "RegisterVT", ")", ";", "}", "</s>" ]

[ "Certain", "targets", "such", "as", "MIPS", "require", "that", "some", "types", "such", "as", "vectors", "are", "always", "broken", "down", "into", "scalars", "in", "some", "contexts", "." ]

[ "X86", "X86", "MVT::i1", "16", "64", "MVT::i8", "MVT::i1" ]

[]

[ "<s>", "static", "rtx", "rs6000_function_value", "(", "const_tree", "valtype", ",", "const_tree", "fn_decl_or_type", "ATTRIBUTE_UNUSED", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "machine_mode", "mode", ";", "unsigned", "int", "regno", ";", "machine_mode", "elt_mode", ";", "int", "n_elts", ";", "if", "(", "TARGET_MACHO", "&&", "rs6000_darwin64_struct_check_p", "(", "TYPE_MODE", "(", "valtype", ")", ",", "valtype", ")", ")", "{", "CUMULATIVE_ARGS", "valcum", ";", "rtx", "valret", ";", "valcum", ".", "words", "=", "0", ";", "valcum", ".", "fregno", "=", "FP_ARG_MIN_REG", ";", "valcum", ".", "vregno", "=", "ALTIVEC_ARG_MIN_REG", ";", "valret", "=", "rs6000_darwin64_record_arg", "(", "&", "valcum", ",", "valtype", ",", "true", ",", "true", ")", ";", "if", "(", "valret", ")", "return", "valret", ";", "}", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "if", "(", "rs6000_discover_homogeneous_aggregate", "(", "mode", ",", "valtype", ",", "&", "elt_mode", ",", "&", "n_elts", ")", ")", "{", "int", "first_reg", ",", "n_regs", ";", "if", "(", "SCALAR_FLOAT_MODE_NOT_VECTOR_P", "(", "elt_mode", ")", ")", "{", "first_reg", "=", "(", "elt_mode", "==", "TDmode", ")", "?", "FP_ARG_RETURN", "+", "1", ":", "FP_ARG_RETURN", ";", "n_regs", "=", "(", "GET_MODE_SIZE", "(", "elt_mode", ")", "+", "7", ")", ">>", "3", ";", "}", "else", "{", "first_reg", "=", "ALTIVEC_ARG_RETURN", ";", "n_regs", "=", "1", ";", "}", "return", "rs6000_parallel_return", "(", "mode", ",", "n_elts", ",", "elt_mode", ",", "first_reg", ",", "n_regs", ")", ";", "}", "if", "(", "TARGET_32BIT", "&&", "TARGET_POWERPC64", ")", "switch", "(", "mode", ")", "{", "default", ":", "break", ";", "case", "DImode", ":", "case", "SCmode", ":", "case", "DCmode", ":", "case", "TCmode", ":", "int", "count", "=", "GET_MODE_SIZE", "(", "mode", ")", "/", "4", ";", "return", "rs6000_parallel_return", "(", "mode", ",", "count", ",", "SImode", ",", "GP_ARG_RETURN", ",", "1", ")", ";", "}", "if", "(", "(", "INTEGRAL_TYPE_P", "(", "valtype", ")", "&&", "GET_MODE_BITSIZE", "(", "mode", ")", "<", "(", "TARGET_32BIT", "?", "32", ":", "64", ")", ")", "||", "POINTER_TYPE_P", "(", "valtype", ")", ")", "mode", "=", "TARGET_32BIT", "?", "SImode", ":", "DImode", ";", "if", "(", "DECIMAL_FLOAT_MODE_P", "(", "mode", ")", "&&", "TARGET_HARD_FLOAT", "&&", "TARGET_FPRS", ")", "regno", "=", "(", "mode", "==", "TDmode", ")", "?", "FP_ARG_RETURN", "+", "1", ":", "FP_ARG_RETURN", ";", "else", "if", "(", "SCALAR_FLOAT_MODE_NOT_VECTOR_P", "(", "mode", ")", "&&", "TARGET_HARD_FLOAT", "&&", "TARGET_FPRS", "&&", "(", "(", "TARGET_SINGLE_FLOAT", "&&", "(", "mode", "==", "SFmode", ")", ")", "||", "TARGET_DOUBLE_FLOAT", ")", ")", "regno", "=", "FP_ARG_RETURN", ";", "else", "if", "(", "TREE_CODE", "(", "valtype", ")", "==", "COMPLEX_TYPE", "&&", "targetm", ".", "calls", ".", "split_complex_arg", ")", "return", "rs6000_complex_function_value", "(", "mode", ")", ";", "else", "if", "(", "(", "TREE_CODE", "(", "valtype", ")", "==", "VECTOR_TYPE", "||", "FLOAT128_VECTOR_P", "(", "mode", ")", ")", "&&", "TARGET_ALTIVEC", "&&", "TARGET_ALTIVEC_ABI", "&&", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "mode", ")", ")", "regno", "=", "ALTIVEC_ARG_RETURN", ";", "else", "if", "(", "TARGET_E500_DOUBLE", "&&", "TARGET_HARD_FLOAT", "&&", "(", "mode", "==", "DFmode", "||", "mode", "==", "DCmode", "||", "FLOAT128_IBM_P", "(", "mode", ")", "||", "mode", "==", "TCmode", ")", ")", "return", "spe_build_register_parallel", "(", "mode", ",", "GP_ARG_RETURN", ")", ";", "else", "regno", "=", "GP_ARG_RETURN", ";", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "}", "</s>" ]

[ "Define", "how", "to", "find", "the", "value", "returned", "by", "a", "function", ".", "VALTYPE", "is", "the", "data", "type", "of", "the", "value", "(", "as", "a", "tree", ")", ".", "If", "the", "precise", "function", "being", "called", "is", "known", ",", "FUNC", "is", "its", "FUNCTION_DECL", ";", "otherwise", ",", "FUNC", "is", "0", ".", "On", "the", "SPE", ",", "both", "FPs", "and", "vectors", "are", "returned", "in", "r3", ".", "On", "RS/6000", "an", "integer", "value", "is", "in", "r3", "and", "a", "floating-point", "value", "is", "in", "fp1", ",", "unless", "-msoft-float", "." ]

[ "rs6000", "0", "1", "7", "3", "1", "4", "1", "32", "64", "1" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "isTruncateFree", "(", "EVT", "SrcVT", ",", "EVT", "DstVT", ")", "const", "{", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", "||", "SrcVT", ".", "isVector", "(", ")", "||", "DstVT", ".", "isVector", "(", ")", "||", "!", "SrcVT", ".", "isInteger", "(", ")", "||", "!", "DstVT", ".", "isInteger", "(", ")", ")", "return", "false", ";", "unsigned", "SrcBits", "=", "SrcVT", ".", "getSizeInBits", "(", ")", ";", "unsigned", "DestBits", "=", "DstVT", ".", "getSizeInBits", "(", ")", ";", "return", "(", "SrcBits", "==", "64", "&&", "DestBits", "==", "32", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "free", "to", "truncate", "a", "value", "of", "type", "Ty1", "to", "type", "Ty2", "." ]

[ "RISCV", "RISCV", "64", "32" ]

[]

[ "<s>", "static", "rtx", "emit_insxl", "(", "enum", "machine_mode", "mode", ",", "rtx", "op1", ",", "rtx", "op2", ")", "{", "rtx", "ret", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "rtx", "(", "*", "fn", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "if", "(", "WORDS_BIG_ENDIAN", ")", "{", "if", "(", "mode", "==", "QImode", ")", "fn", "=", "gen_insbl_be", ";", "else", "fn", "=", "gen_inswl_be", ";", "}", "else", "{", "if", "(", "mode", "==", "QImode", ")", "fn", "=", "gen_insbl_le", ";", "else", "fn", "=", "gen_inswl_le", ";", "}", "emit_insn", "(", "fn", "(", "ret", ",", "op1", ",", "op2", ")", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "the", "atomic", "operation", "splitters", ".", "Emit", "an", "insxl", "instruction", "in", "MODE", "." ]

[ "alpha" ]

[]

[ "<s>", "unsigned", "PPCTTIImpl", "::", "getIntImmCost", "(", "unsigned", "Opcode", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "{", "if", "(", "DisablePPCConstHoist", ")", "return", "BaseT", "::", "getIntImmCost", "(", "Opcode", ",", "Idx", ",", "Imm", ",", "Ty", ")", ";", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "BitSize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "BitSize", "==", "0", ")", "return", "~", "0U", ";", "unsigned", "ImmIdx", "=", "~", "0U", ";", "bool", "ShiftedFree", "=", "false", ",", "RunFree", "=", "false", ",", "UnsignedFree", "=", "false", ",", "ZeroFree", "=", "false", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "GetElementPtr", ":", "if", "(", "Idx", "==", "0", ")", "return", "2", "*", "TTI", "::", "TCC_Basic", ";", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "And", ":", "RunFree", "=", "true", ";", "case", "Instruction", "::", "Add", ":", "case", "Instruction", "::", "Or", ":", "case", "Instruction", "::", "Xor", ":", "ShiftedFree", "=", "true", ";", "case", "Instruction", "::", "Sub", ":", "case", "Instruction", "::", "Mul", ":", "case", "Instruction", "::", "Shl", ":", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "ImmIdx", "=", "1", ";", "break", ";", "case", "Instruction", "::", "ICmp", ":", "UnsignedFree", "=", "true", ";", "ImmIdx", "=", "1", ";", "case", "Instruction", "::", "Select", ":", "ZeroFree", "=", "true", ";", "break", ";", "case", "Instruction", "::", "PHI", ":", "case", "Instruction", "::", "Call", ":", "case", "Instruction", "::", "Ret", ":", "case", "Instruction", "::", "Load", ":", "case", "Instruction", "::", "Store", ":", "break", ";", "}", "if", "(", "ZeroFree", "&&", "Imm", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "Idx", "==", "ImmIdx", "&&", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", ")", "{", "if", "(", "isInt", "<", "16", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "RunFree", ")", "{", "if", "(", "Imm", ".", "getBitWidth", "(", ")", "<=", "32", "&&", "(", "isShiftedMask_32", "(", "Imm", ".", "getZExtValue", "(", ")", ")", "||", "isShiftedMask_32", "(", "~", "Imm", ".", "getZExtValue", "(", ")", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "ST", "->", "isPPC64", "(", ")", "&&", "(", "isShiftedMask_64", "(", "Imm", ".", "getZExtValue", "(", ")", ")", "||", "isShiftedMask_64", "(", "~", "Imm", ".", "getZExtValue", "(", ")", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "}", "if", "(", "UnsignedFree", "&&", "isUInt", "<", "16", ">", "(", "Imm", ".", "getZExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "ShiftedFree", "&&", "(", "Imm", ".", "getZExtValue", "(", ")", "&", "0xFFFF", ")", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "}", "return", "PPCTTIImpl", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "materializing", "a", "64-bit", "value", "." ]

[ "PowerPC", "PPC", "PPC", "0", "0U", "0U", "0", "2", "1", "1", "0", "64", "16", "32", "PPC", "16", "0xFFFF", "0", "PPC" ]

[]

[ "<s>", "static", "void", "mips_expand_vi_broadcast", "(", "machine_mode", "vmode", ",", "rtx", "target", ",", "rtx", "elt", ")", "{", "struct", "expand_vec_perm_d", "d", ";", "rtx", "t1", ";", "bool", "ok", ";", "if", "(", "elt", "!=", "const0_rtx", ")", "elt", "=", "force_reg", "(", "GET_MODE_INNER", "(", "vmode", ")", ",", "elt", ")", ";", "if", "(", "REG_P", "(", "elt", ")", ")", "elt", "=", "gen_lowpart", "(", "DImode", ",", "elt", ")", ";", "t1", "=", "gen_reg_rtx", "(", "vmode", ")", ";", "switch", "(", "vmode", ")", "{", "case", "E_V8QImode", ":", "emit_insn", "(", "gen_loongson_vec_init1_v8qi", "(", "t1", ",", "elt", ")", ")", ";", "break", ";", "case", "E_V4HImode", ":", "emit_insn", "(", "gen_loongson_vec_init1_v4hi", "(", "t1", ",", "elt", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "memset", "(", "&", "d", ",", "0", ",", "sizeof", "(", "d", ")", ")", ";", "d", ".", "target", "=", "target", ";", "d", ".", "op0", "=", "t1", ";", "d", ".", "op1", "=", "t1", ";", "d", ".", "vmode", "=", "vmode", ";", "d", ".", "nelt", "=", "GET_MODE_NUNITS", "(", "vmode", ")", ";", "d", ".", "one_vector_p", "=", "true", ";", "ok", "=", "mips_expand_vec_perm_const_1", "(", "&", "d", ")", ";", "gcc_assert", "(", "ok", ")", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "mips_expand_vec_init", ",", "expand", "via", "broadcast", "." ]

[ "mips", "0" ]

[]

[ "<s>", "bool", "AArch64AsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "if", "(", "!", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNum", ",", "ExtraCode", ",", "O", ")", ")", "return", "false", ";", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'w'", ":", "case", "'x'", ":", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "printAsmMRegister", "(", "MO", ",", "ExtraCode", "[", "0", "]", ",", "O", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", "&&", "MO", ".", "getImm", "(", ")", "==", "0", ")", "{", "unsigned", "Reg", "=", "ExtraCode", "[", "0", "]", "==", "'w'", "?", "AArch64", "::", "WZR", ":", "AArch64", "::", "XZR", ";", "O", "<<", "AArch64InstPrinter", "::", "getRegisterName", "(", "Reg", ")", ";", "return", "false", ";", "}", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "case", "'b'", ":", "case", "'h'", ":", "case", "'s'", ":", "case", "'d'", ":", "case", "'q'", ":", "case", "'z'", ":", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "const", "TargetRegisterClass", "*", "RC", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "case", "'b'", ":", "RC", "=", "&", "AArch64", "::", "FPR8RegClass", ";", "break", ";", "case", "'h'", ":", "RC", "=", "&", "AArch64", "::", "FPR16RegClass", ";", "break", ";", "case", "'s'", ":", "RC", "=", "&", "AArch64", "::", "FPR32RegClass", ";", "break", ";", "case", "'d'", ":", "RC", "=", "&", "AArch64", "::", "FPR64RegClass", ";", "break", ";", "case", "'q'", ":", "RC", "=", "&", "AArch64", "::", "FPR128RegClass", ";", "break", ";", "case", "'z'", ":", "RC", "=", "&", "AArch64", "::", "ZPRRegClass", ";", "break", ";", "default", ":", "return", "true", ";", "}", "return", "printAsmRegInClass", "(", "MO", ",", "RC", ",", "AArch64", "::", "NoRegAltName", ",", "O", ")", ";", "}", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "}", "}", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "Register", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "AArch64", "::", "GPR32allRegClass", ".", "contains", "(", "Reg", ")", "||", "AArch64", "::", "GPR64allRegClass", ".", "contains", "(", "Reg", ")", ")", "return", "printAsmMRegister", "(", "MO", ",", "'x'", ",", "O", ")", ";", "unsigned", "AltName", "=", "AArch64", "::", "NoRegAltName", ";", "const", "TargetRegisterClass", "*", "RegClass", ";", "if", "(", "AArch64", "::", "ZPRRegClass", ".", "contains", "(", "Reg", ")", ")", "{", "RegClass", "=", "&", "AArch64", "::", "ZPRRegClass", ";", "}", "else", "{", "RegClass", "=", "&", "AArch64", "::", "FPR128RegClass", ";", "AltName", "=", "AArch64", "::", "vreg", ";", "}", "return", "printAsmRegInClass", "(", "MO", ",", "RegClass", ",", "AltName", ",", "O", ")", ";", "}", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

[ "AArch64", "AArch64", "0", "1", "0", "0", "0", "0", "0", "AArch64::WZR", "AArch64::XZR", "AArch64", "0", "AArch64::FPR8RegClass", "AArch64::FPR16RegClass", "AArch64::FPR32RegClass", "AArch64::FPR64RegClass", "AArch64::FPR128RegClass", "AArch64::ZPRRegClass", "AArch64::NoRegAltName", "AArch64::GPR32allRegClass", "AArch64::GPR64allRegClass", "AArch64::NoRegAltName", "AArch64::ZPRRegClass", "AArch64::ZPRRegClass", "AArch64::FPR128RegClass", "AArch64::vreg" ]

[]

[ "<s>", "rtx", "sparc_builtin_saveregs", "(", ")", "{", "int", "first_reg", "=", "current_function_args_info", ".", "words", ";", "rtx", "address", ";", "int", "regno", ";", "for", "(", "regno", "=", "first_reg", ";", "regno", "<", "NPARM_REGS", "(", "word_mode", ")", ";", "regno", "++", ")", "emit_move_insn", "(", "gen_rtx_MEM", "(", "word_mode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "frame_pointer_rtx", ",", "GEN_INT", "(", "FIRST_PARM_OFFSET", "(", "0", ")", "+", "(", "UNITS_PER_WORD", "*", "regno", ")", ")", ")", ")", ",", "gen_rtx_REG", "(", "word_mode", ",", "BASE_INCOMING_ARG_REG", "(", "word_mode", ")", "+", "regno", ")", ")", ";", "address", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "frame_pointer_rtx", ",", "GEN_INT", "(", "FIRST_PARM_OFFSET", "(", "0", ")", "+", "UNITS_PER_WORD", "*", "first_reg", ")", ")", ";", "return", "address", ";", "}", "</s>" ]

[ "Do", "what", "is", "necessary", "for", "`", "va_start", "'", ".", "We", "look", "at", "the", "current", "function", "to", "determine", "if", "stdarg", "or", "varargs", "is", "used", "and", "return", "the", "address", "of", "the", "first", "unnamed", "parameter", "." ]

[ "sparc", "0", "0" ]

[]

[ "<s>", "MCDisassembler", "::", "DecodeStatus", "X86GenericDisassembler", "::", "getInstruction", "(", "MCInst", "&", "Instr", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "VStream", ",", "raw_ostream", "&", "CStream", ")", "const", "{", "CommentStream", "=", "&", "CStream", ";", "InternalInstruction", "InternalInstr", ";", "dlog_t", "LoggerFn", "=", "logger", ";", "if", "(", "&", "VStream", "==", "&", "nulls", "(", ")", ")", "LoggerFn", "=", "nullptr", ";", "Region", "R", "(", "Bytes", ",", "Address", ")", ";", "int", "Ret", "=", "decodeInstruction", "(", "&", "InternalInstr", ",", "regionReader", ",", "(", "const", "void", "*", ")", "&", "R", ",", "LoggerFn", ",", "(", "void", "*", ")", "&", "VStream", ",", "(", "const", "void", "*", ")", "MII", ".", "get", "(", ")", ",", "Address", ",", "fMode", ")", ";", "if", "(", "Ret", ")", "{", "Size", "=", "InternalInstr", ".", "readerCursor", "-", "Address", ";", "return", "Fail", ";", "}", "else", "{", "Size", "=", "InternalInstr", ".", "length", ";", "bool", "Ret", "=", "translateInstruction", "(", "Instr", ",", "InternalInstr", ",", "this", ")", ";", "if", "(", "!", "Ret", ")", "{", "unsigned", "Flags", "=", "X86", "::", "IP_NO_PREFIX", ";", "if", "(", "InternalInstr", ".", "hasAdSize", ")", "Flags", "|=", "X86", "::", "IP_HAS_AD_SIZE", ";", "if", "(", "!", "InternalInstr", ".", "mandatoryPrefix", ")", "{", "if", "(", "InternalInstr", ".", "hasOpSize", ")", "Flags", "|=", "X86", "::", "IP_HAS_OP_SIZE", ";", "if", "(", "InternalInstr", ".", "repeatPrefix", "==", "0xf2", ")", "Flags", "|=", "X86", "::", "IP_HAS_REPEAT_NE", ";", "else", "if", "(", "InternalInstr", ".", "repeatPrefix", "==", "0xf3", "&&", "InternalInstr", ".", "opcode", "!=", "0x90", ")", "Flags", "|=", "X86", "::", "IP_HAS_REPEAT", ";", "if", "(", "InternalInstr", ".", "hasLockPrefix", ")", "Flags", "|=", "X86", "::", "IP_HAS_LOCK", ";", "}", "Instr", ".", "setFlags", "(", "Flags", ")", ";", "}", "return", "(", "!", "Ret", ")", "?", "Success", ":", "Fail", ";", "}", "}", "</s>" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "X86", "X86", "X86::IP_NO_PREFIX", "X86::IP_HAS_AD_SIZE", "X86::IP_HAS_OP_SIZE", "0xf2", "X86::IP_HAS_REPEAT_NE", "0xf3", "0x90", "X86::IP_HAS_REPEAT", "X86::IP_HAS_LOCK" ]

[]

[ "<s>", "bool", "mips_const_vector_shuffle_set_p", "(", "rtx", "op", ",", "machine_mode", "mode", ")", "{", "int", "nunits", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "int", "nsets", "=", "nunits", "/", "4", ";", "int", "set", "=", "0", ";", "int", "i", ",", "j", ";", "for", "(", "j", "=", "0", ";", "j", "<", "nsets", ";", "j", "++", ",", "set", "=", "4", "*", "j", ")", "for", "(", "i", "=", "0", ";", "i", "<", "4", ";", "i", "++", ")", "if", "(", "(", "INTVAL", "(", "XVECEXP", "(", "op", ",", "0", ",", "i", ")", ")", "!=", "(", "INTVAL", "(", "XVECEXP", "(", "op", ",", "0", ",", "set", "+", "i", ")", ")", "-", "set", ")", ")", "||", "!", "IN_RANGE", "(", "INTVAL", "(", "XVECEXP", "(", "op", ",", "0", ",", "set", "+", "i", ")", ")", ",", "0", ",", "set", "+", "3", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "a", "constant", "vector", "with", "repeated", "4-element", "sets", "in", "mode", "MODE", "." ]

[ "mips", "4", "0", "0", "4", "0", "4", "0", "0", "0", "0", "3" ]

[]

[ "<s>", "bool", "ARMTTIImpl", "::", "preferPredicateOverEpilogue", "(", "Loop", "*", "L", ",", "LoopInfo", "*", "LI", ",", "ScalarEvolution", "&", "SE", ",", "AssumptionCache", "&", "AC", ",", "TargetLibraryInfo", "*", "TLI", ",", "DominatorTree", "*", "DT", ",", "const", "LoopAccessInfo", "*", "LAI", ")", "{", "if", "(", "!", "EnableTailPredication", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Tail-predication not enabled.\\n\"", ")", ";", "return", "false", ";", "}", "if", "(", "!", "ST", "->", "hasMVEIntegerOps", "(", ")", ")", "return", "false", ";", "if", "(", "L", "->", "getNumBlocks", "(", ")", ">", "1", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"preferPredicateOverEpilogue: not a single block \"", "\"loop.\\n\"", ")", ";", "return", "false", ";", "}", "assert", "(", "L", "->", "isInnermost", "(", ")", "&&", "\"preferPredicateOverEpilogue: inner-loop expected\"", ")", ";", "HardwareLoopInfo", "HWLoopInfo", "(", "L", ")", ";", "if", "(", "!", "HWLoopInfo", ".", "canAnalyze", "(", "*", "LI", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"preferPredicateOverEpilogue: hardware-loop is not \"", "\"analyzable.\\n\"", ")", ";", "return", "false", ";", "}", "if", "(", "!", "isHardwareLoopProfitable", "(", "L", ",", "SE", ",", "AC", ",", "TLI", ",", "HWLoopInfo", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"preferPredicateOverEpilogue: hardware-loop is not \"", "\"profitable.\\n\"", ")", ";", "return", "false", ";", "}", "if", "(", "!", "HWLoopInfo", ".", "isHardwareLoopCandidate", "(", "SE", ",", "*", "LI", ",", "*", "DT", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"preferPredicateOverEpilogue: hardware-loop is not \"", "\"a candidate.\\n\"", ")", ";", "return", "false", ";", "}", "return", "canTailPredicateLoop", "(", "L", ",", "LI", ",", "SE", ",", "DL", ",", "LAI", ")", ";", "}", "</s>" ]

[ "Query", "the", "target", "whether", "it", "would", "be", "prefered", "to", "create", "a", "predicated", "vector", "loop", ",", "which", "can", "avoid", "the", "need", "to", "emit", "a", "scalar", "epilogue", "loop", "." ]

[ "ARM", "ARM", "\"Tail-predication not enabled.\\n\"", "1", "\"preferPredicateOverEpilogue: not a single block \"", "\"loop.\\n\"", "\"preferPredicateOverEpilogue: inner-loop expected\"", "\"preferPredicateOverEpilogue: hardware-loop is not \"", "\"analyzable.\\n\"", "\"preferPredicateOverEpilogue: hardware-loop is not \"", "\"profitable.\\n\"", "\"preferPredicateOverEpilogue: hardware-loop is not \"", "\"a candidate.\\n\"" ]

[]

[ "<s>", "X86TargetLowering", "::", "ConstraintType", "X86TargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'R'", ":", "case", "'q'", ":", "case", "'Q'", ":", "case", "'f'", ":", "case", "'t'", ":", "case", "'u'", ":", "case", "'y'", ":", "case", "'x'", ":", "case", "'v'", ":", "case", "'Y'", ":", "case", "'l'", ":", "return", "C_RegisterClass", ";", "case", "'k'", ":", "case", "'a'", ":", "case", "'b'", ":", "case", "'c'", ":", "case", "'d'", ":", "case", "'S'", ":", "case", "'D'", ":", "case", "'A'", ":", "return", "C_Register", ";", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'L'", ":", "case", "'M'", ":", "case", "'N'", ":", "case", "'G'", ":", "case", "'C'", ":", "case", "'e'", ":", "case", "'Z'", ":", "return", "C_Other", ";", "default", ":", "break", ";", "}", "}", "else", "if", "(", "Constraint", ".", "size", "(", ")", "==", "2", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'Y'", ":", "switch", "(", "Constraint", "[", "1", "]", ")", "{", "default", ":", "break", ";", "case", "'k'", ":", "return", "C_Register", ";", "}", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]

[ "X86", "X86", "X86", "1", "0", "2", "0", "1" ]

[]

[ "<s>", "static", "bool", "multiple_operation_profitable_p", "(", "bool", "is_store", "ATTRIBUTE_UNUSED", ",", "int", "nops", ",", "HOST_WIDE_INT", "add_offset", ")", "{", "if", "(", "nops", "==", "2", "&&", "arm_ld_sched", "&&", "add_offset", "!=", "0", ")", "return", "false", ";", "if", "(", "nops", "<=", "2", "&&", "arm_tune_xscale", "&&", "!", "optimize_size", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "iff", "it", "would", "be", "profitable", "to", "turn", "a", "sequence", "of", "NOPS", "loads", "or", "stores", "(", "depending", "on", "IS_STORE", ")", "into", "a", "load-multiple", "or", "store-multiple", "instruction", ".", "ADD_OFFSET", "is", "nonzero", "if", "the", "base", "address", "register", "needs", "to", "be", "modified", "with", "an", "add", "instruction", "before", "we", "can", "use", "it", "." ]

[ "arm", "2", "0", "2" ]

[]

[ "<s>", "static", "bool", "arm_function_value_regno_p", "(", "const", "unsigned", "int", "regno", ")", "{", "if", "(", "regno", "==", "ARG_REGISTER", "(", "1", ")", "||", "(", "TARGET_32BIT", "&&", "TARGET_AAPCS_BASED", "&&", "TARGET_HARD_FLOAT", "&&", "regno", "==", "FIRST_VFP_REGNUM", ")", "||", "(", "TARGET_IWMMXT_ABI", "&&", "regno", "==", "FIRST_IWMMXT_REGNUM", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_VALUE_REGNO_P", "." ]

[ "arm", "1" ]

[]

[ "<s>", "const", "TPCSubtarget", "*", "getSubtarget", "(", ")", "const", "{", "return", "Subtarget", ";", "}", "</s>" ]

[ "getSubtarget", "-", "Return", "the", "subtarget", "for", "which", "this", "machine", "code", "is", "being", "compiled", "." ]

[ "TPC", "TPC" ]

[]

[ "<s>", "const", "RegisterBank", "&", "AArch64RegisterBankInfo", "::", "getRegBankFromRegClass", "(", "const", "TargetRegisterClass", "&", "RC", ",", "LLT", ")", "const", "{", "switch", "(", "RC", ".", "getID", "(", ")", ")", "{", "case", "AArch64", "::", "FPR8RegClassID", ":", "case", "AArch64", "::", "FPR16RegClassID", ":", "case", "AArch64", "::", "FPR32RegClassID", ":", "case", "AArch64", "::", "FPR64RegClassID", ":", "case", "AArch64", "::", "FPR128RegClassID", ":", "case", "AArch64", "::", "FPR128_loRegClassID", ":", "case", "AArch64", "::", "DDRegClassID", ":", "case", "AArch64", "::", "DDDRegClassID", ":", "case", "AArch64", "::", "DDDDRegClassID", ":", "case", "AArch64", "::", "QQRegClassID", ":", "case", "AArch64", "::", "QQQRegClassID", ":", "case", "AArch64", "::", "QQQQRegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "FPRRegBankID", ")", ";", "case", "AArch64", "::", "GPR32commonRegClassID", ":", "case", "AArch64", "::", "GPR32RegClassID", ":", "case", "AArch64", "::", "GPR32spRegClassID", ":", "case", "AArch64", "::", "GPR32sponlyRegClassID", ":", "case", "AArch64", "::", "GPR32argRegClassID", ":", "case", "AArch64", "::", "GPR32allRegClassID", ":", "case", "AArch64", "::", "GPR64commonRegClassID", ":", "case", "AArch64", "::", "GPR64RegClassID", ":", "case", "AArch64", "::", "GPR64spRegClassID", ":", "case", "AArch64", "::", "GPR64sponlyRegClassID", ":", "case", "AArch64", "::", "GPR64argRegClassID", ":", "case", "AArch64", "::", "GPR64allRegClassID", ":", "case", "AArch64", "::", "GPR64noipRegClassID", ":", "case", "AArch64", "::", "GPR64common_and_GPR64noipRegClassID", ":", "case", "AArch64", "::", "GPR64noip_and_tcGPR64RegClassID", ":", "case", "AArch64", "::", "tcGPR64RegClassID", ":", "case", "AArch64", "::", "WSeqPairsClassRegClassID", ":", "case", "AArch64", "::", "XSeqPairsClassRegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "GPRRegBankID", ")", ";", "case", "AArch64", "::", "CCRRegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "CCRegBankID", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Register class not supported\"", ")", ";", "}", "}", "</s>" ]

[ "Get", "a", "register", "bank", "that", "covers", "RC", "." ]

[ "AArch64", "AArch64", "AArch64::FPR8RegClassID", "AArch64::FPR16RegClassID", "AArch64::FPR32RegClassID", "AArch64::FPR64RegClassID", "AArch64::FPR128RegClassID", "AArch64::FPR128_loRegClassID", "AArch64::DDRegClassID", "AArch64::DDDRegClassID", "AArch64::DDDDRegClassID", "AArch64::QQRegClassID", "AArch64::QQQRegClassID", "AArch64::QQQQRegClassID", "AArch64::FPRRegBankID", "AArch64::GPR32commonRegClassID", "AArch64::GPR32RegClassID", "AArch64::GPR32spRegClassID", "AArch64::GPR32sponlyRegClassID", "AArch64::GPR32argRegClassID", "AArch64::GPR32allRegClassID", "AArch64::GPR64commonRegClassID", "AArch64::GPR64RegClassID", "AArch64::GPR64spRegClassID", "AArch64::GPR64sponlyRegClassID", "AArch64::GPR64argRegClassID", "AArch64::GPR64allRegClassID", "AArch64::GPR64noipRegClassID", "AArch64::GPR64common_and_GPR64noipRegClassID", "AArch64::GPR64noip_and_tcGPR64RegClassID", "AArch64::tcGPR64RegClassID", "AArch64::WSeqPairsClassRegClassID", "AArch64::XSeqPairsClassRegClassID", "AArch64::GPRRegBankID", "AArch64::CCRRegClassID", "AArch64::CCRegBankID", "\"Register class not supported\"" ]

[]

[ "<s>", "bool", "empty", "(", ")", "const", "{", "return", "TopLevelExceptions", ".", "empty", "(", ")", ";", "}", "</s>" ]

[ "Determine", "whether", "this", "version", "information", "is", "empty", "(", "e.g.", ",", "all", "version", "components", "are", "zero", ")", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "SITargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "AtomicRMWInst", "*", "RMW", ")", "const", "{", "auto", "ReportUnsafeHWInst", "=", "[", "&", "]", "(", "TargetLowering", "::", "AtomicExpansionKind", "Kind", ")", "{", "OptimizationRemarkEmitter", "ORE", "(", "RMW", "->", "getFunction", "(", ")", ")", ";", "LLVMContext", "&", "Ctx", "=", "RMW", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "SmallVector", "<", "StringRef", ">", "SSNs", ";", "Ctx", ".", "getSyncScopeNames", "(", "SSNs", ")", ";", "auto", "MemScope", "=", "SSNs", "[", "RMW", "->", "getSyncScopeID", "(", ")", "]", ".", "empty", "(", ")", "?", "\"system\"", ":", "SSNs", "[", "RMW", "->", "getSyncScopeID", "(", ")", "]", ";", "ORE", ".", "emit", "(", "[", "&", "]", "(", ")", "{", "return", "OptimizationRemark", "(", "DEBUG_TYPE", ",", "\"Passed\"", ",", "RMW", ")", "<<", "\"Hardware instruction generated for atomic \"", "<<", "RMW", "->", "getOperationName", "(", "RMW", "->", "getOperation", "(", ")", ")", "<<", "\" operation at memory scope \"", "<<", "MemScope", "<<", "\" due to an unsafe request.\"", ";", "}", ")", ";", "return", "Kind", ";", "}", ";", "switch", "(", "RMW", "->", "getOperation", "(", ")", ")", "{", "case", "AtomicRMWInst", "::", "FAdd", ":", "{", "Type", "*", "Ty", "=", "RMW", "->", "getType", "(", ")", ";", "if", "(", "Ty", "->", "isHalfTy", "(", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "if", "(", "!", "Ty", "->", "isFloatTy", "(", ")", "&&", "(", "!", "Subtarget", "->", "hasGFX90AInsts", "(", ")", "||", "!", "Ty", "->", "isDoubleTy", "(", ")", ")", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "unsigned", "AS", "=", "RMW", "->", "getPointerAddressSpace", "(", ")", ";", "if", "(", "(", "AS", "==", "AMDGPUAS", "::", "GLOBAL_ADDRESS", "||", "AS", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", ")", "&&", "Subtarget", "->", "hasAtomicFaddInsts", "(", ")", ")", "{", "if", "(", "Subtarget", "->", "hasGFX940Insts", "(", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "if", "(", "RMW", "->", "getFunction", "(", ")", "->", "getFnAttribute", "(", "\"amdgpu-unsafe-fp-atomics\"", ")", ".", "getValueAsString", "(", ")", "!=", "\"true\"", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "if", "(", "Subtarget", "->", "hasGFX90AInsts", "(", ")", ")", "{", "if", "(", "Ty", "->", "isFloatTy", "(", ")", "&&", "AS", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "auto", "SSID", "=", "RMW", "->", "getSyncScopeID", "(", ")", ";", "if", "(", "SSID", "==", "SyncScope", "::", "System", "||", "SSID", "==", "RMW", "->", "getContext", "(", ")", ".", "getOrInsertSyncScopeID", "(", "\"one-as\"", ")", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "return", "ReportUnsafeHWInst", "(", "AtomicExpansionKind", "::", "None", ")", ";", "}", "if", "(", "AS", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "return", "RMW", "->", "use_empty", "(", ")", "?", "ReportUnsafeHWInst", "(", "AtomicExpansionKind", "::", "None", ")", ":", "AtomicExpansionKind", "::", "CmpXChg", ";", "}", "if", "(", "AS", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", "&&", "Subtarget", "->", "hasLDSFPAtomicAdd", "(", ")", ")", "{", "if", "(", "!", "Ty", "->", "isDoubleTy", "(", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "if", "(", "fpModeMatchesGlobalFPAtomicMode", "(", "RMW", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "return", "RMW", "->", "getFunction", "(", ")", "->", "getFnAttribute", "(", "\"amdgpu-unsafe-fp-atomics\"", ")", ".", "getValueAsString", "(", ")", "==", "\"true\"", "?", "ReportUnsafeHWInst", "(", "AtomicExpansionKind", "::", "None", ")", ":", "AtomicExpansionKind", "::", "CmpXChg", ";", "}", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "}", "default", ":", "break", ";", "}", "return", "AMDGPUTargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "RMW", ")", ";", "}", "</s>" ]

[ "Returns", "how", "the", "IR-level", "AtomicExpand", "pass", "should", "expand", "the", "given", "AtomicRMW", ",", "if", "at", "all", "." ]

[ "AMDGPU", "SI", "\"system\"", "\"Passed\"", "\"Hardware instruction generated for atomic \"", "\" operation at memory scope \"", "\" due to an unsafe request.\"", "AMDGPU", "AMDGPU", "\"amdgpu-unsafe-fp-atomics\"", "\"true\"", "AMDGPU", "SI", "SI", "SI", "\"one-as\"", "AMDGPU", "AMDGPU", "\"amdgpu-unsafe-fp-atomics\"", "\"true\"", "AMDGPU" ]

[]

[ "<s>", "DecodeStatus", "M88kDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "CS", ")", "const", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "Size", "=", "4", ";", "uint32_t", "Inst", "=", "0", ";", "for", "(", "uint32_t", "I", "=", "0", ";", "I", "<", "Size", ";", "++", "I", ")", "Inst", "=", "(", "Inst", "<<", "8", ")", "|", "Bytes", "[", "I", "]", ";", "return", "decodeInstruction", "(", "DecoderTableM88k32", ",", "MI", ",", "Inst", ",", "Address", ",", "this", ",", "STI", ")", ";", "}", "</s>" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "M88k", "M88k", "4", "0", "4", "0", "0", "8", "M88k" ]

[]

[ "<s>", "bool", "TPCSubtarget", "::", "enableSubRegLiveness", "(", ")", "const", "{", "return", "EnableSubRegLiveness", ";", "}", "</s>" ]

[ "Enable", "tracking", "of", "subregister", "liveness", "in", "register", "allocator", "." ]

[ "TPC", "TPC" ]

[]

[ "<s>", "VariantKind", "getKind", "(", ")", "const", "{", "return", "Kind", ";", "}", "</s>" ]

[ "Returns", "the", "Kind", "of", "lane", "offset", "." ]

[ "M88k" ]

[]

[ "<s>", "SDNode", "*", "SparcDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "SDLoc", "dl", "(", "N", ")", ";", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", "nullptr", ";", "}", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "SPISD", "::", "GLOBAL_BASE_REG", ":", "return", "getGlobalBaseReg", "(", ")", ";", "case", "ISD", "::", "SDIV", ":", "case", "ISD", "::", "UDIV", ":", "{", "if", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i64", ")", "break", ";", "SDValue", "DivLHS", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "DivRHS", "=", "N", "->", "getOperand", "(", "1", ")", ";", "SDValue", "TopPart", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SDIV", ")", "{", "TopPart", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "SP", "::", "SRAri", ",", "dl", ",", "MVT", "::", "i32", ",", "DivLHS", ",", "CurDAG", "->", "getTargetConstant", "(", "31", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ",", "0", ")", ";", "}", "else", "{", "TopPart", "=", "CurDAG", "->", "getRegister", "(", "SP", "::", "G0", ",", "MVT", "::", "i32", ")", ";", "}", "TopPart", "=", "CurDAG", "->", "getCopyToReg", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "dl", ",", "SP", "::", "Y", ",", "TopPart", ",", "SDValue", "(", ")", ")", ".", "getValue", "(", "1", ")", ";", "unsigned", "Opcode", "=", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SDIV", "?", "SP", "::", "SDIVrr", ":", "SP", "::", "UDIVrr", ";", "return", "CurDAG", "->", "SelectNodeTo", "(", "N", ",", "Opcode", ",", "MVT", "::", "i32", ",", "DivLHS", ",", "DivRHS", ",", "TopPart", ")", ";", "}", "case", "ISD", "::", "MULHU", ":", "case", "ISD", "::", "MULHS", ":", "{", "SDValue", "MulLHS", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "MulRHS", "=", "N", "->", "getOperand", "(", "1", ")", ";", "unsigned", "Opcode", "=", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "MULHU", "?", "SP", "::", "UMULrr", ":", "SP", "::", "SMULrr", ";", "SDNode", "*", "Mul", "=", "CurDAG", "->", "getMachineNode", "(", "Opcode", ",", "dl", ",", "MVT", "::", "i32", ",", "MVT", "::", "i32", ",", "MulLHS", ",", "MulRHS", ")", ";", "SDValue", "ResultHigh", "=", "SDValue", "(", "Mul", ",", "1", ")", ";", "ReplaceUses", "(", "SDValue", "(", "N", ",", "0", ")", ",", "ResultHigh", ")", ";", "return", "nullptr", ";", "}", "}", "return", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]

[ "Sparc", "Sparc", "1", "SPISD::GLOBAL_BASE_REG", "ISD::SDIV", "ISD::UDIV", "0", "MVT::i64", "0", "1", "ISD::SDIV", "SP::SRAri", "MVT::i32", "31", "MVT::i32", "0", "SP::G0", "MVT::i32", "SP::Y", "1", "ISD::SDIV", "SP::SDIVrr", "SP::UDIVrr", "MVT::i32", "ISD::MULHU", "ISD::MULHS", "0", "1", "ISD::MULHU", "SP::UMULrr", "SP::SMULrr", "MVT::i32", "MVT::i32", "1", "0" ]

[]

[ "<s>", "DEBUG_FUNCTION", "void", "rs6000_debug_print_mode", "(", "ssize_t", "m", ")", "{", "ssize_t", "rc", ";", "int", "spaces", "=", "0", ";", "fprintf", "(", "stderr", ",", "\"Mode: %-5s\"", ",", "GET_MODE_NAME", "(", "m", ")", ")", ";", "for", "(", "rc", "=", "0", ";", "rc", "<", "N_RELOAD_REG", ";", "rc", "++", ")", "fprintf", "(", "stderr", ",", "\" %s: %s\"", ",", "reload_reg_map", "[", "rc", "]", ".", "name", ",", "rs6000_debug_addr_mask", "(", "reg_addr", "[", "m", "]", ".", "addr_mask", "[", "rc", "]", ",", "true", ")", ")", ";", "if", "(", "(", "reg_addr", "[", "m", "]", ".", "reload_store", "!=", "CODE_FOR_nothing", ")", "||", "(", "reg_addr", "[", "m", "]", ".", "reload_load", "!=", "CODE_FOR_nothing", ")", ")", "{", "fprintf", "(", "stderr", ",", "\"%*s Reload=%c%c\"", ",", "spaces", ",", "\"\"", ",", "(", "reg_addr", "[", "m", "]", ".", "reload_store", "!=", "CODE_FOR_nothing", ")", "?", "'s'", ":", "'*'", ",", "(", "reg_addr", "[", "m", "]", ".", "reload_load", "!=", "CODE_FOR_nothing", ")", "?", "'l'", ":", "'*'", ")", ";", "spaces", "=", "0", ";", "}", "else", "spaces", "+=", "sizeof", "(", "\" Reload=sl\"", ")", "-", "1", ";", "if", "(", "reg_addr", "[", "m", "]", ".", "scalar_in_vmx_p", ")", "{", "fprintf", "(", "stderr", ",", "\"%*s Upper=y\"", ",", "spaces", ",", "\"\"", ")", ";", "spaces", "=", "0", ";", "}", "else", "spaces", "+=", "sizeof", "(", "\" Upper=y\"", ")", "-", "1", ";", "if", "(", "rs6000_vector_unit", "[", "m", "]", "!=", "VECTOR_NONE", "||", "rs6000_vector_mem", "[", "m", "]", "!=", "VECTOR_NONE", ")", "{", "fprintf", "(", "stderr", ",", "\"%*s vector: arith=%-10s mem=%s\"", ",", "spaces", ",", "\"\"", ",", "rs6000_debug_vector_unit", "(", "rs6000_vector_unit", "[", "m", "]", ")", ",", "rs6000_debug_vector_unit", "(", "rs6000_vector_mem", "[", "m", "]", ")", ")", ";", "}", "fputs", "(", "\"\\n\"", ",", "stderr", ")", ";", "}", "</s>" ]

[ "Print", "the", "address", "masks", "in", "a", "human", "readble", "fashion", "." ]

[ "rs6000", "0", "\"Mode: %-5s\"", "0", "\" %s: %s\"", "\"%*s Reload=%c%c\"", "\"\"", "0", "\" Reload=sl\"", "1", "\"%*s Upper=y\"", "\"\"", "0", "\" Upper=y\"", "1", "\"%*s vector: arith=%-10s mem=%s\"", "\"\"", "\"\\n\"" ]

[]

[ "<s>", "void", "XCoreAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "unsigned", "src", ",", "dst", ",", "srcSR", ",", "dstSR", ";", "if", "(", "TM", ".", "getInstrInfo", "(", ")", "->", "isMoveInstr", "(", "*", "MI", ",", "src", ",", "dst", ",", "srcSR", ",", "dstSR", ")", ")", "{", "O", "<<", "\"\\tmov \"", "<<", "getRegisterName", "(", "dst", ")", "<<", "\", \"", ";", "O", "<<", "getRegisterName", "(", "src", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "return", ";", "}", "printInstruction", "(", "MI", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "XCore", "XCore", "\"\\tmov \"", "\", \"" ]

[]

[ "<s>", "StringRef", "AArch64NamedImmMapper", "::", "toString", "(", "uint32_t", "Value", ",", "bool", "&", "Valid", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "NumMappings", ";", "++", "i", ")", "{", "if", "(", "Mappings", "[", "i", "]", ".", "Value", "==", "Value", ")", "{", "Valid", "=", "true", ";", "return", "Mappings", "[", "i", "]", ".", "Name", ";", "}", "}", "Valid", "=", "false", ";", "return", "StringRef", "(", ")", ";", "}", "</s>" ]

[ "Convert", "to", "a", "decimal", "representation", "in", "a", "string", "." ]

[ "AArch64", "AArch64", "0" ]

[]

[ "<s>", "bool", "HexagonFixupHwLoops", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "return", "fixupLoopInstrs", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "virtual", "const", "TOYSubtarget", "*", "getSubtargetImpl", "(", ")", "const", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "TOY", "TOY" ]

[]

[ "<s>", "void", "CAHPInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "O", ",", "unsigned", "RegNo", ")", "const", "{", "O", "<<", "getRegisterName", "(", "RegNo", ")", ";", "}", "</s>" ]

[ "Print", "the", "assembler", "register", "name", "." ]

[ "CAHP", "CAHP" ]

[]

[ "<s>", "const", "MCExpr", "*", "WebAssemblyAsmPrinter", "::", "lowerConstant", "(", "const", "Constant", "*", "CV", ")", "{", "if", "(", "const", "auto", "*", "GV", "=", "dyn_cast", "<", "GlobalValue", ">", "(", "CV", ")", ")", "if", "(", "GV", "->", "getValueType", "(", ")", "->", "isFunctionTy", "(", ")", ")", "{", "return", "MCSymbolRefExpr", "::", "create", "(", "getSymbol", "(", "GV", ")", ",", "MCSymbolRefExpr", "::", "VK_WebAssembly_FUNCTION", ",", "OutContext", ")", ";", "}", "return", "AsmPrinter", "::", "lowerConstant", "(", "CV", ")", ";", "}", "</s>" ]

[ "Lower", "the", "specified", "LLVM", "Constant", "to", "an", "MCExpr", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "void", "PPCRegisterInfo", "::", "lowerCRSpilling", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "unsigned", "FrameIndex", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "const", "TargetRegisterClass", "*", "G8RC", "=", "&", "PPC", "::", "G8RCRegClass", ";", "const", "TargetRegisterClass", "*", "GPRC", "=", "&", "PPC", "::", "GPRCRegClass", ";", "const", "TargetRegisterClass", "*", "RC", "=", "Subtarget", ".", "isPPC64", "(", ")", "?", "G8RC", ":", "GPRC", ";", "unsigned", "Reg", "=", "findScratchRegister", "(", "II", ",", "RS", ",", "RC", ",", "SPAdj", ")", ";", "unsigned", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "bool", "LP64", "=", "Subtarget", ".", "isPPC64", "(", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFCRpseud", ")", ",", "Reg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "isKill", "(", ")", ")", ")", ";", "if", "(", "SrcReg", "!=", "PPC", "::", "CR0", ")", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "RLWINM", ")", ",", "Reg", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "getPPCRegisterNumbering", "(", "SrcReg", ")", "*", "4", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "31", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "LP64", "?", "PPC", "::", "STW8", ":", "PPC", "::", "STW", ")", ")", ".", "addReg", "(", "Reg", ",", "getKillRegState", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", ")", ",", "FrameIndex", ")", ";", "MBB", ".", "erase", "(", "II", ")", ";", "}", "</s>" ]

[ "lowerCRSpilling", "-", "Generate", "the", "code", "for", "spilling", "a", "CR", "register", "." ]

[ "PowerPC", "PPC", "PPC::G8RCRegClass", "PPC::GPRCRegClass", "PPC", "0", "PPC", "PPC::MFCRpseud", "0", "PPC::CR0", "PPC::RLWINM", "PPC", "4", "0", "31", "PPC::STW8", "PPC::STW", "1" ]

[]

[ "<s>", "bool", "MVETPAndVPTOptimisations", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "const", "ARMSubtarget", "&", "STI", "=", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ")", ";", "if", "(", "!", "STI", ".", "isThumb2", "(", ")", "||", "!", "STI", ".", "hasLOB", "(", ")", ")", "return", "false", ";", "TII", "=", "static_cast", "<", "const", "Thumb2InstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "MachineLoopInfo", "*", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "MachineDominatorTree", "*", "DT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** ARM MVE VPT Optimisations **********\\n\"", "<<", "\"********** Function: \"", "<<", "Fn", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineLoop", "*", "ML", ":", "MLI", "->", "getBase", "(", ")", ".", "getLoopsInPreorder", "(", ")", ")", "{", "Modified", "|=", "LowerWhileLoopStart", "(", "ML", ")", ";", "Modified", "|=", "MergeLoopEnd", "(", "ML", ")", ";", "Modified", "|=", "ConvertTailPredLoop", "(", "ML", ",", "DT", ")", ";", "}", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "Fn", ")", "{", "Modified", "|=", "HintDoLoopStartReg", "(", "MBB", ")", ";", "Modified", "|=", "ReplaceConstByVPNOTs", "(", "MBB", ",", "DT", ")", ";", "Modified", "|=", "ReplaceVCMPsByVPNOTs", "(", "MBB", ")", ";", "Modified", "|=", "ReduceOldVCCRValueUses", "(", "MBB", ")", ";", "Modified", "|=", "ConvertVPSEL", "(", "MBB", ")", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"**************************************\\n\"", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "\"********** ARM MVE VPT Optimisations **********\\n\"", "\"********** Function: \"", "\"**************************************\\n\"" ]

[]

[ "<s>", "MCSymbol", "*", "WebAssemblyMCInstLower", "::", "GetExternalSymbolSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "const", "char", "*", "Name", "=", "MO", ".", "getSymbolName", "(", ")", ";", "auto", "*", "WasmSym", "=", "cast", "<", "MCSymbolWasm", ">", "(", "Printer", ".", "GetExternalSymbolSymbol", "(", "Name", ")", ")", ";", "const", "WebAssemblySubtarget", "&", "Subtarget", "=", "Printer", ".", "getSubtarget", "(", ")", ";", "if", "(", "strcmp", "(", "Name", ",", "\"__stack_pointer\"", ")", "==", "0", ")", "{", "WasmSym", "->", "setType", "(", "wasm", "::", "WASM_SYMBOL_TYPE_GLOBAL", ")", ";", "WasmSym", "->", "setGlobalType", "(", "wasm", "::", "WasmGlobalType", "{", "uint8_t", "(", "Subtarget", ".", "hasAddr64", "(", ")", "?", "wasm", "::", "WASM_TYPE_I64", ":", "wasm", "::", "WASM_TYPE_I32", ")", ",", "true", "}", ")", ";", "return", "WasmSym", ";", "}", "SmallVector", "<", "wasm", "::", "ValType", ",", "4", ">", "Returns", ";", "SmallVector", "<", "wasm", "::", "ValType", ",", "4", ">", "Params", ";", "if", "(", "strcmp", "(", "Name", ",", "\"__cpp_exception\"", ")", "==", "0", ")", "{", "WasmSym", "->", "setType", "(", "wasm", "::", "WASM_SYMBOL_TYPE_EVENT", ")", ";", "WasmSym", "->", "setEventType", "(", "{", "wasm", "::", "WASM_EVENT_ATTRIBUTE_EXCEPTION", ",", "0", "}", ")", ";", "WasmSym", "->", "setWeak", "(", "true", ")", ";", "WasmSym", "->", "setExternal", "(", "true", ")", ";", "Params", ".", "push_back", "(", "Subtarget", ".", "hasAddr64", "(", ")", "?", "wasm", "::", "ValType", "::", "I64", ":", "wasm", "::", "ValType", "::", "I32", ")", ";", "}", "else", "{", "WasmSym", "->", "setType", "(", "wasm", "::", "WASM_SYMBOL_TYPE_FUNCTION", ")", ";", "getLibcallSignature", "(", "Subtarget", ",", "Name", ",", "Returns", ",", "Params", ")", ";", "}", "auto", "Signature", "=", "make_unique", "<", "wasm", "::", "WasmSignature", ">", "(", "std", "::", "move", "(", "Returns", ")", ",", "std", "::", "move", "(", "Params", ")", ")", ";", "WasmSym", "->", "setSignature", "(", "Signature", ".", "get", "(", ")", ")", ";", "Printer", ".", "addSignature", "(", "std", "::", "move", "(", "Signature", ")", ")", ";", "return", "WasmSym", ";", "}", "</s>" ]

[ "Return", "the", "MCSymbol", "for", "the", "specified", "ExternalSymbol", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly", "\"__stack_pointer\"", "0", "wasm::WASM_SYMBOL_TYPE_GLOBAL", "wasm::WasmGlobalType", "wasm::WASM_TYPE_I64", "wasm::WASM_TYPE_I32", "wasm::ValType", "4", "wasm::ValType", "4", "\"__cpp_exception\"", "0", "wasm::WASM_SYMBOL_TYPE_EVENT", "wasm::WASM_EVENT_ATTRIBUTE_EXCEPTION", "0", "wasm::ValType", "wasm::ValType", "wasm::WASM_SYMBOL_TYPE_FUNCTION", "wasm::WasmSignature" ]

[]

[ "<s>", "CSKYConstantPoolJT", "*", "CSKYConstantPoolJT", "::", "Create", "(", "Type", "*", "Ty", ",", "int", "JTI", ",", "unsigned", "PCAdj", ",", "CSKYCP", "::", "CSKYCPModifier", "Modifier", ")", "{", "return", "new", "CSKYConstantPoolJT", "(", "Ty", ",", "JTI", ",", "PCAdj", ",", "Modifier", ",", "false", ")", ";", "}", "</s>" ]

[ "Construct", "a", "unary", "instruction", ",", "given", "the", "opcode", "and", "an", "operand", "." ]

[ "CSKY", "CSKY", "CSKY", "CSKYCP::CSKYCPModifier", "CSKY" ]

[]

[ "<s>", "static", "void", "rl78_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "static_chain", ")", "{", "rtx", "mov_addr", ",", "thunk_addr", ";", "rtx", "function", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "mov_addr", "=", "adjust_address", "(", "m_tramp", ",", "HImode", ",", "0", ")", ";", "thunk_addr", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "function", "=", "force_reg", "(", "HImode", ",", "function", ")", ";", "static_chain", "=", "force_reg", "(", "HImode", ",", "static_chain", ")", ";", "emit_insn", "(", "gen_trampoline_init", "(", "thunk_addr", ",", "function", ",", "static_chain", ")", ")", ";", "emit_move_insn", "(", "mov_addr", ",", "thunk_addr", ")", ";", "cfun", "->", "machine", "->", "trampolines_used", "=", "1", ";", "}", "</s>" ]

[ "Note", "that", "the", "RL78", "'s", "addressing", "makes", "it", "very", "difficult", "to", "do", "trampolines", "on", "the", "stack", ".", "So", ",", "libgcc", "has", "a", "small", "pool", "of", "trampolines", "from", "which", "one", "is", "allocated", "to", "this", "task", "." ]

[ "rl78", "0", "0", "1" ]

[]

[ "<s>", "int", "ARMFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "return", "ResolveFrameIndexReference", "(", "MF", ",", "FI", ",", "FrameReg", ",", "0", ")", ";", "}", "</s>" ]

[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

[ "ARM", "ARM", "0" ]

[]

[ "<s>", "static", "int", "riscv_memory_move_cost", "(", "machine_mode", "mode", ",", "reg_class_t", "rclass", ",", "bool", "in", ")", "{", "return", "(", "tune_param", "->", "memory_cost", "+", "memory_move_secondary_cost", "(", "mode", ",", "rclass", ",", "in", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_MEMORY_MOVE_COST", "." ]

[ "riscv" ]

[]

[ "<s>", "static", "bool", "classof", "(", "const", "DiagnosticInfo", "*", "DI", ")", "{", "return", "DI", "->", "getKind", "(", ")", "==", "getKindID", "(", ")", ";", "}", "</s>" ]

[ "Methods", "for", "support", "type", "inquiry", "through", "isa", ",", "cast", ",", "and", "dyn_cast", ":" ]

[ "R600" ]

[]

[ "<s>", "void", "TOYAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ")", "const", "{", "unsigned", "NumBytes", "=", "4", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "{", "return", ";", "}", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "TOY", "TOY", "4", "\"Invalid fixup offset!\"", "0", "8", "0xff" ]

[]

[ "<s>", "void", "aarch64_sve_op_count", "::", "dump", "(", ")", "const", "{", "aarch64_vec_op_count", "::", "dump", "(", ")", ";", "dump_printf_loc", "(", "MSG_NOTE", ",", "vect_location", ",", "\" predicate operations = %d\\n\"", ",", "pred_ops", ")", ";", "}", "</s>" ]

[ "Dump", "information", "about", "the", "structure", "." ]

[ "aarch64", "aarch64_vec_op_count::dump", "\" predicate operations = %d\\n\"" ]

[]

[ "<s>", "bool", "SystemZAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "MatchResult", ";", "FeatureBitset", "MissingFeatures", ";", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MissingFeatures", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "case", "Match_Success", ":", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "emitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "{", "assert", "(", "MissingFeatures", ".", "any", "(", ")", "&&", "\"Unknown missing feature!\"", ")", ";", "std", "::", "string", "Msg", "=", "\"instruction requires:\"", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "MissingFeatures", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "MissingFeatures", "[", "I", "]", ")", "{", "Msg", "+=", "\" \"", ";", "Msg", "+=", "getSubtargetFeatureName", "(", "I", ")", ";", "}", "}", "return", "Error", "(", "IDLoc", ",", "Msg", ")", ";", "}", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "SystemZOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_MnemonicFail", ":", "{", "FeatureBitset", "FBS", "=", "ComputeAvailableFeatures", "(", "getSTI", "(", ")", ".", "getFeatureBits", "(", ")", ")", ";", "std", "::", "string", "Suggestion", "=", "SystemZMnemonicSpellCheck", "(", "(", "(", "SystemZOperand", "&", ")", "*", "Operands", "[", "0", "]", ")", ".", "getToken", "(", ")", ",", "FBS", ")", ";", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", "+", "Suggestion", ",", "(", "(", "SystemZOperand", "&", ")", "*", "Operands", "[", "0", "]", ")", ".", "getLocRange", "(", ")", ")", ";", "}", "}", "llvm_unreachable", "(", "\"Unexpected match type\"", ")", ";", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "SystemZ", "SystemZ", "\"Unknown missing feature!\"", "\"instruction requires:\"", "0", "\" \"", "0ULL", "\"too few operands for instruction\"", "SystemZ", "\"invalid operand for instruction\"", "SystemZ", "SystemZ", "0", "\"invalid instruction\"", "SystemZ", "0", "\"Unexpected match type\"" ]

[]

[ "<s>", "SDValue", "MBlazeTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_MBlaze", ")", ";", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "if", "(", "RVLocs", "[", "i", "]", ".", "isRegLoc", "(", ")", ")", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "unsigned", "Ret", "=", "(", "CallConv", "==", "CallingConv", "::", "MBLAZE_INTR", ")", "?", "MBlazeISD", "::", "IRet", ":", "MBlazeISD", "::", "Ret", ";", "unsigned", "Reg", "=", "(", "CallConv", "==", "CallingConv", "::", "MBLAZE_INTR", ")", "?", "MBlaze", "::", "R14", ":", "MBlaze", "::", "R15", ";", "SDValue", "DReg", "=", "DAG", ".", "getRegister", "(", "Reg", ",", "MVT", "::", "i32", ")", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "Ret", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "DReg", ",", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Ret", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "DReg", ")", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "ISD::OutputArg", "16", "MBlaze", "0", "0", "\"Can only return in registers!\"", "1", "MBlazeISD::IRet", "MBlazeISD::Ret", "MBlaze::R14", "MBlaze::R15", "MVT::i32", "MVT::Other", "MVT::Other" ]

[]

[ "<s>", "virtual", "const", "ARMBaseInstrInfo", "*", "getInstrInfo", "(", ")", "const", "{", "return", "InstrInfo", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "bool", "arc_is_aux_reg_p", "(", "rtx", "pat", ")", "{", "tree", "attrs", "=", "NULL_TREE", ";", "tree", "addr", ";", "if", "(", "!", "MEM_P", "(", "pat", ")", ")", "return", "false", ";", "addr", "=", "MEM_EXPR", "(", "pat", ")", ";", "if", "(", "!", "addr", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "addr", ")", "==", "VAR_DECL", ")", "attrs", "=", "DECL_ATTRIBUTES", "(", "addr", ")", ";", "else", "if", "(", "TREE_CODE", "(", "addr", ")", "==", "MEM_REF", ")", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "TREE_OPERAND", "(", "addr", ",", "0", ")", ")", ")", ";", "else", "return", "false", ";", "if", "(", "lookup_attribute", "(", "\"aux\"", ",", "attrs", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "PAT", "is", "accessing", "an", "aux-reg", "." ]

[ "arc", "0", "\"aux\"" ]

[]

[ "<s>", "void", "SparcFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "SparcMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SparcMachineFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "SparcInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "SparcInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "int", "NumBytes", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "SAVEri", "=", "SP", "::", "SAVEri", ";", "unsigned", "SAVErr", "=", "SP", "::", "SAVErr", ";", "if", "(", "FuncInfo", "->", "isLeafProc", "(", ")", ")", "{", "if", "(", "NumBytes", "==", "0", ")", "return", ";", "SAVEri", "=", "SP", "::", "ADDri", ";", "SAVErr", "=", "SP", "::", "ADDrr", ";", "}", "NumBytes", "=", "-", "SubTarget", ".", "getAdjustedFrameSize", "(", "NumBytes", ")", ";", "emitSPAdjustment", "(", "MF", ",", "MBB", ",", "MBBI", ",", "NumBytes", ",", "SAVErr", ",", "SAVEri", ")", ";", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "MCRegisterInfo", "*", "MRI", "=", "MMI", ".", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "regFP", "=", "MRI", "->", "getDwarfRegNum", "(", "SP", "::", "I6", ",", "true", ")", ";", "unsigned", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaRegister", "(", "nullptr", ",", "regFP", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createWindowSave", "(", "nullptr", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "unsigned", "regInRA", "=", "MRI", "->", "getDwarfRegNum", "(", "SP", "::", "I7", ",", "true", ")", ";", "unsigned", "regOutRA", "=", "MRI", "->", "getDwarfRegNum", "(", "SP", "::", "O7", ",", "true", ")", ";", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createRegister", "(", "nullptr", ",", "regOutRA", ",", "regInRA", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "</s>" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "SP::SAVEri", "SP::SAVErr", "0", "SP::ADDri", "SP::ADDrr", "SP", "SP::I6", "SP::I7", "SP::O7" ]

[]

[ "<s>", "SDValue", "HexagonTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_Hexagon", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "HexagonISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "&", "RetOps", "[", "0", "]", ",", "RetOps", ".", "size", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "ISD::OutputArg", "16", "Hexagon", "4", "1", "0", "1", "0", "HexagonISD::RET_FLAG", "MVT::Other", "0" ]

[]

[ "<s>", "int", "HexagonFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "auto", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "auto", "&", "HRI", "=", "*", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FI", ")", ";", "bool", "HasAlloca", "=", "MFI", ".", "hasVarSizedObjects", "(", ")", ";", "bool", "HasExtraAlign", "=", "HRI", ".", "needsStackRealignment", "(", "MF", ")", ";", "bool", "NoOpt", "=", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ";", "auto", "&", "HMFI", "=", "*", "MF", ".", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "Register", "SP", "=", "HRI", ".", "getStackRegister", "(", ")", ";", "Register", "FP", "=", "HRI", ".", "getFrameRegister", "(", ")", ";", "Register", "AP", "=", "HMFI", ".", "getStackAlignBasePhysReg", "(", ")", ";", "if", "(", "AP", "==", "0", ")", "AP", "=", "FP", ";", "bool", "UseFP", "=", "false", ",", "UseAP", "=", "false", ";", "if", "(", "NoOpt", "&&", "!", "HasExtraAlign", ")", "UseFP", "=", "true", ";", "if", "(", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", "||", "MFI", ".", "isObjectPreAllocated", "(", "FI", ")", ")", "{", "UseFP", "|=", "(", "HasAlloca", "||", "HasExtraAlign", ")", ";", "}", "else", "{", "if", "(", "HasAlloca", ")", "{", "if", "(", "HasExtraAlign", ")", "UseAP", "=", "true", ";", "else", "UseFP", "=", "true", ";", "}", "}", "bool", "HasFP", "=", "hasFP", "(", "MF", ")", ";", "assert", "(", "(", "HasFP", "||", "!", "UseFP", ")", "&&", "\"This function must have frame pointer\"", ")", ";", "if", "(", "Offset", ">", "0", "&&", "!", "HasFP", ")", "Offset", "-=", "8", ";", "if", "(", "UseFP", ")", "FrameReg", "=", "FP", ";", "else", "if", "(", "UseAP", ")", "FrameReg", "=", "AP", ";", "else", "FrameReg", "=", "SP", ";", "int", "RealOffset", "=", "Offset", ";", "if", "(", "!", "UseFP", "&&", "!", "UseAP", ")", "RealOffset", "=", "FrameSize", "+", "Offset", ";", "return", "RealOffset", ";", "}", "</s>" ]

[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "0", "\"This function must have frame pointer\"", "0", "8" ]

[]

[ "<s>", "static", "void", "expand_strncmp_align_check", "(", "rtx", "strncmp_label", ",", "rtx", "src", ",", "HOST_WIDE_INT", "bytes", ")", "{", "rtx", "lab_ref", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "strncmp_label", ")", ";", "rtx", "src_check", "=", "copy_addr_to_reg", "(", "XEXP", "(", "src", ",", "0", ")", ")", ";", "if", "(", "GET_MODE", "(", "src_check", ")", "==", "SImode", ")", "emit_insn", "(", "gen_andsi3", "(", "src_check", ",", "src_check", ",", "GEN_INT", "(", "0xfff", ")", ")", ")", ";", "else", "emit_insn", "(", "gen_anddi3", "(", "src_check", ",", "src_check", ",", "GEN_INT", "(", "0xfff", ")", ")", ")", ";", "rtx", "cond", "=", "gen_reg_rtx", "(", "CCmode", ")", ";", "emit_move_insn", "(", "cond", ",", "gen_rtx_COMPARE", "(", "CCmode", ",", "src_check", ",", "GEN_INT", "(", "4096", "-", "bytes", ")", ")", ")", ";", "rtx", "cmp_rtx", "=", "gen_rtx_LT", "(", "VOIDmode", ",", "cond", ",", "const0_rtx", ")", ";", "rtx", "ifelse", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "cmp_rtx", ",", "pc_rtx", ",", "lab_ref", ")", ";", "rtx", "j", "=", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "ifelse", ")", ")", ";", "JUMP_LABEL", "(", "j", ")", "=", "strncmp_label", ";", "LABEL_NUSES", "(", "strncmp_label", ")", "+=", "1", ";", "}", "</s>" ]

[ "Generate", "page", "crossing", "check", "and", "branch", "code", "to", "set", "up", "for", "strncmp", "when", "we", "do", "n't", "have", "DI", "alignment", ".", "STRNCMP_LABEL", "is", "the", "label", "to", "branch", "if", "there", "is", "a", "page", "crossing", ".", "SRC_ADDR", "is", "the", "string", "address", "to", "be", "examined", ".", "BYTES", "is", "the", "max", "number", "of", "bytes", "to", "compare", "." ]

[ "rs6000", "0", "0xfff", "0xfff", "4096", "1" ]

[]

[ "<s>", "void", "AlphaRegisterInfo", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "assert", "(", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "Alpha", "::", "RETDAG", "||", "MBBI", "->", "getOpcode", "(", ")", "==", "Alpha", "::", "RETDAGp", ")", "&&", "\"Can only insert epilog into returning blocks\"", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "bool", "FP", "=", "hasFP", "(", "MF", ")", ";", "long", "NumBytes", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "FP", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "BISr", ")", ",", "Alpha", "::", "R30", ")", ".", "addReg", "(", "Alpha", "::", "R15", ")", ".", "addReg", "(", "Alpha", "::", "R15", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDQ", ")", ",", "Alpha", "::", "R15", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "Alpha", "::", "R15", ")", ";", "}", "if", "(", "NumBytes", "!=", "0", ")", "{", "if", "(", "NumBytes", "<=", "IMM_HIGH", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDA", ")", ",", "Alpha", "::", "R30", ")", ".", "addImm", "(", "NumBytes", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "}", "else", "if", "(", "getUpper16", "(", "NumBytes", ")", "<=", "IMM_HIGH", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDAH", ")", ",", "Alpha", "::", "R30", ")", ".", "addImm", "(", "getUpper16", "(", "NumBytes", ")", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDA", ")", ",", "Alpha", "::", "R30", ")", ".", "addImm", "(", "getLower16", "(", "NumBytes", ")", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "}", "else", "{", "report_fatal_error", "(", "\"Too big a stack frame at \"", "+", "Twine", "(", "NumBytes", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "Alpha", "Alpha", "Alpha::RETDAG", "Alpha::RETDAGp", "\"Can only insert epilog into returning blocks\"", "Alpha::BISr", "Alpha::R30", "Alpha::R15", "Alpha::R15", "Alpha::LDQ", "Alpha::R15", "0", "Alpha::R15", "0", "Alpha::LDA", "Alpha::R30", "Alpha::R30", "Alpha::LDAH", "Alpha::R30", "Alpha::R30", "Alpha::LDA", "Alpha::R30", "Alpha::R30", "\"Too big a stack frame at \"" ]

[]

[ "<s>", "SMLoc", "getEndLoc", "(", ")", "const", "override", "{", "return", "EndLoc", ";", "}", "</s>" ]

[ "getEndLoc", "-", "Get", "the", "location", "of", "the", "last", "token", "of", "this", "operand", "." ]

[ "OR1K" ]

[]

[ "<s>", "bool", "ARMDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "switch", "(", "ConstraintID", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected asm memory constraint\"", ")", ";", "case", "InlineAsm", "::", "Constraint_i", ":", "case", "InlineAsm", "::", "Constraint_m", ":", "case", "InlineAsm", "::", "Constraint_o", ":", "case", "InlineAsm", "::", "Constraint_Q", ":", "case", "InlineAsm", "::", "Constraint_Um", ":", "case", "InlineAsm", "::", "Constraint_Un", ":", "case", "InlineAsm", "::", "Constraint_Uq", ":", "case", "InlineAsm", "::", "Constraint_Us", ":", "case", "InlineAsm", "::", "Constraint_Ut", ":", "case", "InlineAsm", "::", "Constraint_Uv", ":", "case", "InlineAsm", "::", "Constraint_Uy", ":", "OutOps", ".", "push_back", "(", "Op", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "SelectInlineAsmMemoryOperand", "-", "Select", "the", "specified", "address", "as", "a", "target", "addressing", "mode", ",", "according", "to", "the", "specified", "constraint", "." ]

[ "ARM", "ARM", "\"Unexpected asm memory constraint\"" ]

[]

[ "<s>", "bool", "Z80AsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "if", "(", "!", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "ExtraCode", ",", "OS", ")", ")", "return", "false", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "case", "MachineOperand", "::", "MO_Immediate", ":", "OS", "<<", "MO", ".", "getImm", "(", ")", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_Register", ":", "OS", "<<", "Z80InstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", ";", "return", "false", ";", "default", ":", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

[ "Z80", "Z80", "Z80" ]

[]

[ "<s>", "int", "mmix_initial_elimination_offset", "(", "int", "fromreg", ",", "int", "toreg", ")", "{", "int", "regno", ";", "int", "fp_sp_offset", "=", "(", "get_frame_size", "(", ")", "+", "current_function_outgoing_args_size", "+", "7", ")", "&", "~", "7", ";", "if", "(", "fromreg", "==", "MMIX_ARG_POINTER_REGNUM", "&&", "toreg", "==", "MMIX_FRAME_POINTER_REGNUM", ")", "return", "0", ";", "for", "(", "regno", "=", "MMIX_FIRST_GLOBAL_REGNUM", ";", "regno", "<=", "255", ";", "regno", "++", ")", "if", "(", "(", "regs_ever_live", "[", "regno", "]", "&&", "!", "call_used_regs", "[", "regno", "]", ")", "||", "IS_MMIX_EH_RETURN_DATA_REG", "(", "regno", ")", ")", "fp_sp_offset", "+=", "8", ";", "return", "fp_sp_offset", "+", "(", "MMIX_CFUN_HAS_LANDING_PAD", "?", "16", ":", "(", "MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS", "?", "8", ":", "0", ")", ")", "+", "(", "fromreg", "==", "MMIX_ARG_POINTER_REGNUM", "?", "0", ":", "8", ")", ";", "}", "</s>" ]

[ "The", "difference", "between", "the", "(", "imaginary", ")", "frame", "pointer", "and", "the", "stack", "pointer", ".", "Used", "to", "eliminate", "the", "frame", "pointer", "." ]

[ "mmix", "7", "7", "0", "255", "8", "16", "8", "0", "0", "8" ]

[]

[ "<s>", "bool", "sh_legitimize_reload_address", "(", "rtx", "*", "p", ",", "machine_mode", "mode", ",", "int", "opnum", ",", "int", "itype", ")", "{", "enum", "reload_type", "type", "=", "(", "enum", "reload_type", ")", "itype", ";", "const", "int", "mode_sz", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "sh_lra_p", "(", ")", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "*", "p", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "*", "p", ",", "1", ")", ")", "&&", "MAYBE_BASE_REGISTER_RTX_P", "(", "XEXP", "(", "*", "p", ",", "0", ")", ",", "true", ")", ")", "{", "const", "HOST_WIDE_INT", "offset", "=", "INTVAL", "(", "XEXP", "(", "*", "p", ",", "1", ")", ")", ";", "struct", "disp_adjust", "adj", "=", "sh_find_mov_disp_adjust", "(", "mode", ",", "offset", ")", ";", "if", "(", "TARGET_SH2A", "&&", "mode", "==", "DFmode", "&&", "(", "offset", "&", "0x7", ")", ")", "{", "push_reload", "(", "*", "p", ",", "NULL_RTX", ",", "p", ",", "NULL", ",", "BASE_REG_CLASS", ",", "Pmode", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "type", ")", ";", "return", "true", ";", "}", "if", "(", "TARGET_SH2E", "&&", "mode", "==", "SFmode", ")", "{", "*", "p", "=", "copy_rtx", "(", "*", "p", ")", ";", "push_reload", "(", "*", "p", ",", "NULL_RTX", ",", "p", ",", "NULL", ",", "BASE_REG_CLASS", ",", "Pmode", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "type", ")", ";", "return", "true", ";", "}", "if", "(", "(", "mode_sz", "==", "4", "||", "mode_sz", "==", "8", ")", "&&", "!", "(", "TARGET_SH4", "&&", "mode", "==", "DFmode", ")", "&&", "adj", ".", "offset_adjust", "!=", "NULL_RTX", "&&", "adj", ".", "mov_disp", "!=", "NULL_RTX", ")", "{", "rtx", "sum", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "XEXP", "(", "*", "p", ",", "0", ")", ",", "adj", ".", "offset_adjust", ")", ";", "*", "p", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "sum", ",", "adj", ".", "mov_disp", ")", ";", "push_reload", "(", "sum", ",", "NULL_RTX", ",", "&", "XEXP", "(", "*", "p", ",", "0", ")", ",", "NULL", ",", "BASE_REG_CLASS", ",", "Pmode", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "type", ")", ";", "return", "true", ";", "}", "}", "if", "(", "GET_CODE", "(", "*", "p", ")", "==", "PLUS", "&&", "(", "mode_sz", "==", "4", "||", "mode_sz", "==", "8", ")", "&&", "GET_CODE", "(", "XEXP", "(", "*", "p", ",", "0", ")", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "*", "p", ",", "0", ")", ",", "1", ")", ")", "&&", "MAYBE_BASE_REGISTER_RTX_P", "(", "XEXP", "(", "XEXP", "(", "*", "p", ",", "0", ")", ",", "0", ")", ",", "true", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "*", "p", ",", "1", ")", ")", "&&", "!", "(", "TARGET_SH2E", "&&", "mode", "==", "SFmode", ")", ")", "{", "push_reload", "(", "XEXP", "(", "*", "p", ",", "0", ")", ",", "NULL_RTX", ",", "&", "XEXP", "(", "*", "p", ",", "0", ")", ",", "NULL", ",", "BASE_REG_CLASS", ",", "Pmode", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "type", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Attempt", "to", "replace", "*", "p", ",", "which", "is", "an", "address", "that", "needs", "reloading", ",", "with", "a", "valid", "memory", "address", "for", "an", "operand", "of", "mode", "MODE", ".", "Like", "for", "sh_legitimize_address", ",", "for", "the", "SH", "we", "try", "to", "get", "a", "normal", "form", "of", "the", "address", ".", "That", "will", "allow", "inheritance", "of", "the", "address", "reloads", "." ]

[ "sh", "1", "0", "1", "0x7", "0", "0", "0", "0", "4", "8", "0", "0", "0", "0", "4", "8", "0", "0", "1", "0", "0", "1", "0", "0", "0", "0" ]

[]

[ "<s>", "int", "HexagonDAGToDAGISel", "::", "getWeight", "(", "SDNode", "*", "N", ")", "{", "if", "(", "!", "isOpcodeHandled", "(", "N", ")", ")", "return", "1", ";", "assert", "(", "RootWeights", ".", "count", "(", "N", ")", "&&", "\"Cannot get weight of unseen root!\"", ")", ";", "assert", "(", "RootWeights", "[", "N", "]", "!=", "-", "1", "&&", "\"Cannot get weight of unvisited root!\"", ")", ";", "assert", "(", "RootWeights", "[", "N", "]", "!=", "-", "2", "&&", "\"Cannot get weight of RAWU'd root!\"", ")", ";", "return", "RootWeights", "[", "N", "]", ";", "}", "</s>" ]

[ "Provide", "a", "weight", "to", "bias", "towards", "choosing", "this", "strategy", "for", "a", "mutation", "." ]

[ "Hexagon", "Hexagon", "1", "\"Cannot get weight of unseen root!\"", "1", "\"Cannot get weight of unvisited root!\"", "2", "\"Cannot get weight of RAWU'd root!\"" ]

[]

[ "<s>", "static", "rtx", "get_tail_policy_for_pred", "(", "enum", "predication_type_index", "pred", ")", "{", "if", "(", "pred", "==", "PRED_TYPE_tu", "||", "pred", "==", "PRED_TYPE_tum", "||", "pred", "==", "PRED_TYPE_tumu", ")", "return", "gen_int_mode", "(", "TAIL_UNDISTURBED", ",", "Pmode", ")", ";", "return", "gen_int_mode", "(", "get_prefer_tail_policy", "(", ")", ",", "Pmode", ")", ";", "}", "</s>" ]

[ "Get", "TAIL", "policy", "for", "predication", ".", "If", "predication", "indicates", "TU", ",", "return", "the", "TU", ".", "Otherwise", ",", "return", "the", "prefer", "default", "configuration", "." ]

[ "riscv" ]

[]

[ "<s>", "unsigned", "getWeight", "(", ")", "const", "{", "return", "(", "Weight", ")", ";", "}", "</s>" ]

[ "Provide", "a", "weight", "to", "bias", "towards", "choosing", "this", "strategy", "for", "a", "mutation", "." ]

[ "Hexagon" ]

[]

[ "<s>", "const", "char", "*", "standard_80387_constant_opcode", "(", "rtx", "x", ")", "{", "switch", "(", "standard_80387_constant_p", "(", "x", ")", ")", "{", "case", "1", ":", "return", "\"fldz\"", ";", "case", "2", ":", "return", "\"fld1\"", ";", "case", "3", ":", "return", "\"fldlg2\"", ";", "case", "4", ":", "return", "\"fldln2\"", ";", "case", "5", ":", "return", "\"fldl2e\"", ";", "case", "6", ":", "return", "\"fldl2t\"", ";", "case", "7", ":", "return", "\"fldpi\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "opcode", "of", "the", "special", "instruction", "to", "be", "used", "to", "load", "the", "constant", "X", "." ]

[ "i386", "1", "\"fldz\"", "2", "\"fld1\"", "3", "\"fldlg2\"", "4", "\"fldln2\"", "5", "\"fldl2e\"", "6", "\"fldl2t\"", "7", "\"fldpi\"" ]

[]

[ "<s>", "unsigned", "ARMTTI", "::", "getIntImmCost", "(", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "const", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "Bits", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "Bits", "==", "0", "||", "Bits", ">", "32", ")", "return", "4", ";", "int32_t", "SImmVal", "=", "Imm", ".", "getSExtValue", "(", ")", ";", "uint32_t", "ZImmVal", "=", "Imm", ".", "getZExtValue", "(", ")", ";", "if", "(", "!", "ST", "->", "isThumb", "(", ")", ")", "{", "if", "(", "(", "SImmVal", ">=", "0", "&&", "SImmVal", "<", "65536", ")", "||", "(", "ARM_AM", "::", "getSOImmVal", "(", "ZImmVal", ")", "!=", "-", "1", ")", "||", "(", "ARM_AM", "::", "getSOImmVal", "(", "~", "ZImmVal", ")", "!=", "-", "1", ")", ")", "return", "1", ";", "return", "ST", "->", "hasV6T2Ops", "(", ")", "?", "2", ":", "3", ";", "}", "if", "(", "ST", "->", "isThumb2", "(", ")", ")", "{", "if", "(", "(", "SImmVal", ">=", "0", "&&", "SImmVal", "<", "65536", ")", "||", "(", "ARM_AM", "::", "getT2SOImmVal", "(", "ZImmVal", ")", "!=", "-", "1", ")", "||", "(", "ARM_AM", "::", "getT2SOImmVal", "(", "~", "ZImmVal", ")", "!=", "-", "1", ")", ")", "return", "1", ";", "return", "ST", "->", "hasV6T2Ops", "(", ")", "?", "2", ":", "3", ";", "}", "if", "(", "SImmVal", ">=", "0", "&&", "SImmVal", "<", "256", ")", "return", "1", ";", "if", "(", "(", "~", "ZImmVal", "<", "256", ")", "||", "ARM_AM", "::", "isThumbImmShiftedVal", "(", "ZImmVal", ")", ")", "return", "2", ";", "return", "3", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "materializing", "a", "64-bit", "value", "." ]

[ "ARM", "ARMTTI::getIntImmCost", "0", "32", "4", "0", "65536", "ARM_AM::getSOImmVal", "1", "ARM_AM::getSOImmVal", "1", "1", "2", "3", "0", "65536", "ARM_AM::getT2SOImmVal", "1", "ARM_AM::getT2SOImmVal", "1", "1", "2", "3", "0", "256", "1", "256", "ARM_AM::isThumbImmShiftedVal", "2", "3" ]

[]

[ "<s>", "void", "ARMBaseRegisterInfo", "::", "resolveFrameIndex", "(", "MachineInstr", "&", "MI", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "ARMBaseInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "int", "Off", "=", "Offset", ";", "unsigned", "i", "=", "0", ";", "assert", "(", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", "&&", "\"This resolveFrameIndex does not support Thumb1!\"", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "bool", "Done", "=", "false", ";", "if", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", ")", "Done", "=", "rewriteARMFrameIndex", "(", "MI", ",", "i", ",", "BaseReg", ",", "Off", ",", "TII", ")", ";", "else", "{", "assert", "(", "AFI", "->", "isThumb2Function", "(", ")", ")", ";", "Done", "=", "rewriteT2FrameIndex", "(", "MI", ",", "i", ",", "BaseReg", ",", "Off", ",", "TII", ")", ";", "}", "assert", "(", "Done", "&&", "\"Unable to resolve frame index!\"", ")", ";", "(", "void", ")", "Done", ";", "}", "</s>" ]

[ "Resolve", "a", "frame", "index", "operand", "of", "an", "instruction", "to", "reference", "the", "indicated", "base", "register", "plus", "offset", "instead", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "0", "\"This resolveFrameIndex does not support Thumb1!\"", "\"Instr doesn't have FrameIndex operand!\"", "ARM", "\"Unable to resolve frame index!\"" ]

[]

[ "<s>", "bool", "MCSectionGBZ80", "::", "isVirtualSection", "(", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "this", "section", "is", "``", "virtual", "''", ",", "that", "is", "has", "no", "actual", "object", "file", "contents", "." ]

[ "GBZ80", "GB" ]

[]

[ "<s>", "static", "void", "ia64_dependencies_evaluation_hook", "(", "rtx_insn", "*", "head", ",", "rtx_insn", "*", "tail", ")", "{", "rtx_insn", "*", "insn", ",", "*", "next", ",", "*", "next_tail", ";", "if", "(", "!", "reload_completed", ")", "return", ";", "next_tail", "=", "NEXT_INSN", "(", "tail", ")", ";", "for", "(", "insn", "=", "head", ";", "insn", "!=", "next_tail", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "INSN_P", "(", "insn", ")", ")", "insn", "->", "call", "=", "0", ";", "for", "(", "insn", "=", "head", ";", "insn", "!=", "next_tail", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "INSN_P", "(", "insn", ")", "&&", "ia64_safe_itanium_class", "(", "insn", ")", "==", "ITANIUM_CLASS_IALU", ")", "{", "sd_iterator_def", "sd_it", ";", "dep_t", "dep", ";", "bool", "has_mem_op_consumer_p", "=", "false", ";", "FOR_EACH_DEP", "(", "insn", ",", "SD_LIST_FORW", ",", "sd_it", ",", "dep", ")", "{", "enum", "attr_itanium_class", "c", ";", "if", "(", "DEP_TYPE", "(", "dep", ")", "!=", "REG_DEP_TRUE", ")", "continue", ";", "next", "=", "DEP_CON", "(", "dep", ")", ";", "c", "=", "ia64_safe_itanium_class", "(", "next", ")", ";", "if", "(", "(", "c", "==", "ITANIUM_CLASS_ST", "||", "c", "==", "ITANIUM_CLASS_STF", ")", "&&", "ia64_st_address_bypass_p", "(", "insn", ",", "next", ")", ")", "{", "has_mem_op_consumer_p", "=", "true", ";", "break", ";", "}", "else", "if", "(", "(", "c", "==", "ITANIUM_CLASS_LD", "||", "c", "==", "ITANIUM_CLASS_FLD", "||", "c", "==", "ITANIUM_CLASS_FLDP", ")", "&&", "ia64_ld_address_bypass_p", "(", "insn", ",", "next", ")", ")", "{", "has_mem_op_consumer_p", "=", "true", ";", "break", ";", "}", "}", "insn", "->", "call", "=", "has_mem_op_consumer_p", ";", "}", "}", "</s>" ]

[ "The", "following", "function", "marks", "insns", "who", "produce", "addresses", "for", "load", "and", "store", "insns", ".", "Such", "insns", "will", "be", "placed", "into", "M", "slots", "because", "it", "decrease", "latency", "time", "for", "Itanium1", "(", "see", "function", "`", "ia64_produce_address_p", "'", "and", "the", "DFA", "descriptions", ")", "." ]

[ "ia64", "0" ]

[]

[ "<s>", "StackOffset", "ARMFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "return", "StackOffset", "::", "getFixed", "(", "ResolveFrameIndexReference", "(", "MF", ",", "FI", ",", "FrameReg", ",", "0", ")", ")", ";", "}", "</s>" ]

[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

[ "ARM", "ARM", "0" ]

[]

[ "<s>", "void", "ARCRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineOperand", "&", "FrameOp", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ";", "int", "FrameIndex", "=", "FrameOp", ".", "getIndex", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "ARCInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "ARCSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "ARCFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FrameIndex", ")", ";", "int", "ObjSize", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectSize", "(", "FrameIndex", ")", ";", "int", "StackSize", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ";", "int", "LocalFrameSize", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getLocalFrameSize", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nFunction : \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"<--------->\\n\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "MI", "<<", "\"\\n\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"FrameIndex : \"", "<<", "FrameIndex", "<<", "\"\\n\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"ObjSize : \"", "<<", "ObjSize", "<<", "\"\\n\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"FrameOffset : \"", "<<", "Offset", "<<", "\"\\n\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"StackSize : \"", "<<", "StackSize", "<<", "\"\\n\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"LocalFrameSize : \"", "<<", "LocalFrameSize", "<<", "\"\\n\"", ")", ";", "(", "void", ")", "LocalFrameSize", ";", "if", "(", "MI", ".", "isDebugValue", "(", ")", ")", "{", "unsigned", "FrameReg", "=", "getFrameRegister", "(", "MF", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Offset : \"", "<<", "Offset", "<<", "\"\\n\"", "<<", "\"<--------->\\n\"", ")", ";", "unsigned", "Reg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "assert", "(", "ARC", "::", "GPR32RegClass", ".", "contains", "(", "Reg", ")", "&&", "\"Unexpected register operand\"", ")", ";", "if", "(", "!", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "Offset", "=", "StackSize", "+", "Offset", ";", "if", "(", "FrameIndex", ">=", "0", ")", "assert", "(", "(", "Offset", ">=", "0", "&&", "Offset", "<", "StackSize", ")", "&&", "\"SP Offset not in bounds.\"", ")", ";", "}", "else", "{", "if", "(", "FrameIndex", ">=", "0", ")", "{", "assert", "(", "(", "Offset", "<", "0", "&&", "-", "Offset", "<=", "StackSize", ")", "&&", "\"FP Offset not in bounds.\"", ")", ";", "}", "}", "ReplaceFrameIndex", "(", "II", ",", "TII", ",", "Reg", ",", "getFrameRegister", "(", "MF", ")", ",", "Offset", ",", "StackSize", ",", "ObjSize", ",", "RS", ",", "SPAdj", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "ARC", "ARC", "0", "\"Unexpected\"", "ARC", "ARC", "ARC", "\"\\nFunction : \"", "\"\\n\"", "\"<--------->\\n\"", "\"\\n\"", "\"FrameIndex : \"", "\"\\n\"", "\"ObjSize : \"", "\"\\n\"", "\"FrameOffset : \"", "\"\\n\"", "\"StackSize : \"", "\"\\n\"", "\"LocalFrameSize : \"", "\"\\n\"", "1", "1", "\"Offset : \"", "\"\\n\"", "\"<--------->\\n\"", "0", "ARC::GPR32RegClass", "\"Unexpected register operand\"", "0", "0", "\"SP Offset not in bounds.\"", "0", "0", "\"FP Offset not in bounds.\"" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isShuffleMaskLegal", "(", "const", "SmallVectorImpl", "<", "int", ">", "&", "M", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "false", ";", "return", "isTypeLegal", "(", "VT", ".", "getSimpleVT", "(", ")", ")", ";", "}", "</s>" ]

[ "Targets", "can", "use", "this", "to", "indicate", "that", "they", "only", "support", "some", "VECTOR_SHUFFLE", "operations", ",", "those", "with", "specific", "masks", "." ]

[ "X86", "X86", "64" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineLoopInfo", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineLoopInfo", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "R600" ]

[]

[ "<s>", "void", "XCoreInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "uint64_t", "Address", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "O", ")", "{", "printInstruction", "(", "MI", ",", "Address", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "XCore", "XCore" ]

[]

[ "<s>", "bool", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]

[ "PowerPC" ]

[]

[ "<s>", "type_suffix_index", "function_resolver", "::", "infer_unsigned_vector_type", "(", "unsigned", "int", "argno", ")", "{", "type_suffix_index", "type", "=", "infer_vector_type", "(", "argno", ")", ";", "if", "(", "type", "==", "NUM_TYPE_SUFFIXES", ")", "return", "type", ";", "if", "(", "!", "type_suffixes", "[", "type", "]", ".", "unsigned_p", ")", "{", "error_at", "(", "location", ",", "\"passing %qT to argument %d of %qE, which\"", "\" expects a vector of unsigned integers\"", ",", "get_argument_type", "(", "argno", ")", ",", "argno", "+", "1", ",", "fndecl", ")", ";", "return", "NUM_TYPE_SUFFIXES", ";", "}", "return", "type", ";", "}", "</s>" ]

[ "Like", "infer_vector_type", ",", "but", "also", "require", "the", "type", "to", "be", "an", "unsigned", "integer", "." ]

[ "aarch64", "\"passing %qT to argument %d of %qE, which\"", "\" expects a vector of unsigned integers\"", "1" ]

[]

[ "<s>", "void", "print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "POST_INC", ":", "print_operand_address", "(", "file", ",", "XEXP", "(", "addr", ",", "0", ")", ")", ";", "fputc", "(", "'+'", ",", "file", ")", ";", "break", ";", "case", "REG", ":", "print_operand", "(", "file", ",", "addr", ",", "0", ")", ";", "break", ";", "case", "PLUS", ":", "{", "rtx", "base", ",", "index", ";", "if", "(", "REG_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "&&", "REG_OK_FOR_BASE_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", "base", "=", "XEXP", "(", "addr", ",", "0", ")", ",", "index", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "if", "(", "REG_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "&&", "REG_OK_FOR_BASE_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ")", "base", "=", "XEXP", "(", "addr", ",", "1", ")", ",", "index", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "print_operand", "(", "file", ",", "index", ",", "0", ")", ";", "fputc", "(", "','", ",", "file", ")", ";", "print_operand", "(", "file", ",", "base", ",", "0", ")", ";", ";", "break", ";", "}", "case", "SYMBOL_REF", ":", "output_addr_const", "(", "file", ",", "addr", ")", ";", "break", ";", "default", ":", "output_addr_const", "(", "file", ",", "addr", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Print", "the", "operand", "address", "represented", "by", "the", "rtx", "addr" ]

[ "mn10300", "0", "0", "0", "0", "0", "1", "1", "1", "1", "0", "0", "0" ]

[]

[ "<s>", "bool", "convertSetCCLogicToBitwiseLogic", "(", "EVT", "VT", ")", "const", "override", "{", "return", "VT", ".", "isScalarInteger", "(", ")", ";", "}", "</s>" ]

[ "Use", "bitwise", "logic", "to", "make", "pairs", "of", "compares", "more", "efficient", "." ]

[ "X86" ]

[]

[ "<s>", "StringRef", "SIRegisterInfo", "::", "getRegAsmName", "(", "unsigned", "Reg", ")", "const", "{", "return", "AMDGPUInstPrinter", "::", "getRegisterName", "(", "Reg", ")", ";", "}", "</s>" ]

[ "Return", "the", "assembly", "name", "for", "Reg", "." ]

[ "AMDGPU", "SI", "AMDGPU" ]

[]

[ "<s>", "void", "ix86_expand_clear", "(", "rtx", "dest", ")", "{", "rtx", "tmp", ";", "gcc_assert", "(", "reload_completed", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "dest", ")", ")", "<", "4", ")", "dest", "=", "gen_rtx_REG", "(", "SImode", ",", "REGNO", "(", "dest", ")", ")", ";", "tmp", "=", "gen_rtx_SET", "(", "dest", ",", "const0_rtx", ")", ";", "if", "(", "!", "TARGET_USE_MOV0", "||", "optimize_insn_for_size_p", "(", ")", ")", "{", "rtx", "clob", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "CCmode", ",", "FLAGS_REG", ")", ")", ";", "tmp", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "tmp", ",", "clob", ")", ")", ";", "}", "emit_insn", "(", "tmp", ")", ";", "}", "</s>" ]

[ "Generate", "either", "``", "mov", "$", "0", ",", "reg", "''", "or", "``", "xor", "reg", ",", "reg", "''", ",", "as", "appropriate", "for", "the", "target", "." ]

[ "i386", "4", "2" ]

[]

[ "<s>", "void", "BTFDebug", "::", "emitCommonHeader", "(", ")", "{", "OS", ".", "AddComment", "(", "\"0x\"", "+", "Twine", "::", "utohexstr", "(", "BTF", "::", "MAGIC", ")", ")", ";", "OS", ".", "emitIntValue", "(", "BTF", "::", "MAGIC", ",", "2", ")", ";", "OS", ".", "emitIntValue", "(", "BTF", "::", "VERSION", ",", "1", ")", ";", "OS", ".", "emitIntValue", "(", "0", ",", "1", ")", ";", "}", "</s>" ]

[ "Emit", "the", "common", "part", "of", "the", "header", "for", "this", "unit", "." ]

[ "BPF", "\"0x\"", "BTF::MAGIC", "BTF::MAGIC", "2", "BTF::VERSION", "1", "0", "1" ]

[]

[ "<s>", "bool", "requiresFrameIndexScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "requires", "post", "PEI", "scavenging", "of", "registers", "for", "materializing", "frame", "index", "constants", "." ]

[ "MMIX" ]

[]

[ "<s>", "SDValue", "SITargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ",", "bool", "IsThisReturn", ",", "SDValue", "ThisVal", ")", "const", "{", "CCAssignFn", "*", "RetCC", "=", "CCAssignFnForReturn", "(", "CallConv", ",", "IsVarArg", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "VA", "=", "RVLocs", "[", "i", "]", ";", "SDValue", "Val", ";", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ",", "InFlag", ")", ";", "Chain", "=", "Val", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Val", ".", "getValue", "(", "2", ")", ";", "}", "else", "if", "(", "VA", ".", "isMemLoc", "(", ")", ")", "{", "report_fatal_error", "(", "\"TODO: return values in memory\"", ")", ";", "}", "else", "llvm_unreachable", "(", "\"unknown argument location type\"", ")", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "BCvt", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "break", ";", "case", "CCValAssign", "::", "ZExt", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Val", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "break", ";", "case", "CCValAssign", "::", "SExt", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertSext", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Val", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "break", ";", "case", "CCValAssign", "::", "AExt", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info!\"", ")", ";", "}", "InVals", ".", "push_back", "(", "Val", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "AMDGPU", "SI", "ISD::InputArg", "16", "0", "1", "2", "\"TODO: return values in memory\"", "\"unknown argument location type\"", "ISD::BITCAST", "ISD::AssertZext", "ISD::TRUNCATE", "ISD::AssertSext", "ISD::TRUNCATE", "ISD::TRUNCATE", "\"Unknown loc info!\"" ]

[]

[ "<s>", "bool", "ComplexPatternFuncMutatesDAG", "(", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "complex", "patterns", "for", "this", "target", "can", "mutate", "the", "DAG", "." ]

[ "Hexagon" ]

[]

[ "<s>", "void", "MSP430RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "MSP430FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "unsigned", "BasePtr", "=", "(", "TFI", "->", "hasFP", "(", "MF", ")", "?", "MSP430", "::", "FP", ":", "MSP430", "::", "SP", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FrameIndex", ")", ";", "Offset", "+=", "2", ";", "if", "(", "!", "TFI", "->", "hasFP", "(", "MF", ")", ")", "Offset", "+=", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ";", "else", "Offset", "+=", "2", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "MSP430", "::", "ADDframe", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "MSP430", "::", "MOV16rr", ")", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "if", "(", "Offset", "==", "0", ")", "return", ";", "unsigned", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "Offset", "<", "0", ")", "BuildMI", "(", "MBB", ",", "std", "::", "next", "(", "II", ")", ",", "dl", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "DstReg", ")", ".", "addReg", "(", "DstReg", ")", ".", "addImm", "(", "-", "Offset", ")", ";", "else", "BuildMI", "(", "MBB", ",", "std", "::", "next", "(", "II", ")", ",", "dl", ",", "TII", ".", "get", "(", "MSP430", "::", "ADD16ri", ")", ",", "DstReg", ")", ".", "addReg", "(", "DstReg", ")", ".", "addImm", "(", "Offset", ")", ";", "return", ";", "}", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "MSP430", "MSP430", "0", "\"Unexpected\"", "MSP430", "MSP430::FP", "MSP430::SP", "2", "2", "1", "MSP430::ADDframe", "MSP430::MOV16rr", "0", "0", "0", "MSP430::SUB16ri", "MSP430::ADD16ri", "1" ]

[]

[ "<s>", "bool", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]

[ "PTX" ]

[]

[ "<s>", "rtx", "avr_legitimize_reload_address", "(", "rtx", "*", "px", ",", "machine_mode", "mode", ",", "int", "opnum", ",", "int", "type", ",", "int", "addr_type", ",", "int", "ind_levels", "ATTRIBUTE_UNUSED", ",", "rtx", "(", "*", "mk_memloc", ")", "(", "rtx", ",", "int", ")", ")", "{", "rtx", "x", "=", "*", "px", ";", "if", "(", "avr_log", ".", "legitimize_reload_address", ")", "avr_edump", "(", "\"\\n%?:%m %r\\n\"", ",", "mode", ",", "x", ")", ";", "if", "(", "1", "&&", "(", "GET_CODE", "(", "x", ")", "==", "POST_INC", "||", "GET_CODE", "(", "x", ")", "==", "PRE_DEC", ")", ")", "{", "push_reload", "(", "XEXP", "(", "x", ",", "0", ")", ",", "XEXP", "(", "x", ",", "0", ")", ",", "&", "XEXP", "(", "x", ",", "0", ")", ",", "&", "XEXP", "(", "x", ",", "0", ")", ",", "POINTER_REGS", ",", "GET_MODE", "(", "x", ")", ",", "GET_MODE", "(", "x", ")", ",", "0", ",", "0", ",", "opnum", ",", "RELOAD_OTHER", ")", ";", "if", "(", "avr_log", ".", "legitimize_reload_address", ")", "avr_edump", "(", "\" RCLASS.1 = %R\\n IN = %r\\n OUT = %r\\n\"", ",", "POINTER_REGS", ",", "XEXP", "(", "x", ",", "0", ")", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "return", "x", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "reg_equiv_constant", "(", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", "==", "0", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ">=", "1", ")", "{", "bool", "fit", "=", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "<=", "MAX_LD_OFFSET", "(", "mode", ")", ";", "if", "(", "fit", ")", "{", "if", "(", "reg_equiv_address", "(", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", "!=", "0", ")", "{", "int", "regno", "=", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "rtx", "mem", "=", "mk_memloc", "(", "x", ",", "regno", ")", ";", "push_reload", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "NULL_RTX", ",", "&", "XEXP", "(", "mem", ",", "0", ")", ",", "NULL", ",", "POINTER_REGS", ",", "Pmode", ",", "VOIDmode", ",", "0", ",", "0", ",", "1", ",", "(", "enum", "reload_type", ")", "addr_type", ")", ";", "if", "(", "avr_log", ".", "legitimize_reload_address", ")", "avr_edump", "(", "\" RCLASS.2 = %R\\n IN = %r\\n OUT = %r\\n\"", ",", "POINTER_REGS", ",", "XEXP", "(", "mem", ",", "0", ")", ",", "NULL_RTX", ")", ";", "push_reload", "(", "mem", ",", "NULL_RTX", ",", "&", "XEXP", "(", "x", ",", "0", ")", ",", "NULL", ",", "BASE_POINTER_REGS", ",", "GET_MODE", "(", "x", ")", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "(", "enum", "reload_type", ")", "type", ")", ";", "if", "(", "avr_log", ".", "legitimize_reload_address", ")", "avr_edump", "(", "\" RCLASS.2 = %R\\n IN = %r\\n OUT = %r\\n\"", ",", "BASE_POINTER_REGS", ",", "mem", ",", "NULL_RTX", ")", ";", "return", "x", ";", "}", "}", "else", "if", "(", "!", "(", "frame_pointer_needed", "&&", "XEXP", "(", "x", ",", "0", ")", "==", "frame_pointer_rtx", ")", ")", "{", "push_reload", "(", "x", ",", "NULL_RTX", ",", "px", ",", "NULL", ",", "POINTER_REGS", ",", "GET_MODE", "(", "x", ")", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "(", "enum", "reload_type", ")", "type", ")", ";", "if", "(", "avr_log", ".", "legitimize_reload_address", ")", "avr_edump", "(", "\" RCLASS.3 = %R\\n IN = %r\\n OUT = %r\\n\"", ",", "POINTER_REGS", ",", "x", ",", "NULL_RTX", ")", ";", "return", "x", ";", "}", "}", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "This", "will", "allow", "register", "R26/27", "to", "be", "used", "where", "it", "is", "no", "worse", "than", "normal", "base", "pointers", "R28/29", "or", "R30/31", ".", "For", "example", ",", "if", "base", "offset", "is", "greater", "than", "63", "bytes", "or", "for", "R++", "or", "--", "R", "addressing", "." ]

[ "avr", "\"\\n%?:%m %r\\n\"", "1", "0", "0", "0", "0", "0", "0", "\" RCLASS.1 = %R\\n IN = %r\\n OUT = %r\\n\"", "0", "0", "0", "0", "0", "1", "1", "1", "1", "0", "0", "0", "0", "0", "0", "0", "1", "\" RCLASS.2 = %R\\n IN = %r\\n OUT = %r\\n\"", "0", "0", "0", "0", "\" RCLASS.2 = %R\\n IN = %r\\n OUT = %r\\n\"", "0", "0", "0", "\" RCLASS.3 = %R\\n IN = %r\\n OUT = %r\\n\"" ]

[]

[ "<s>", "void", "PatmosAsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", "{", "CurrCodeEnd", "=", "OutContext", ".", "createTempSymbol", "(", ")", ";", "EmitFStart", "(", "CurrentFnSymForSize", ",", "CurrCodeEnd", ",", "FStartAlignment", ")", ";", "AsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", ";", "}", "</s>" ]

[ "EmitFunctionEntryLabel", "-", "Emit", "the", "label", "that", "is", "the", "entrypoint", "for", "the", "function", "." ]

[ "Patmos", "Patmos" ]

[]

[ "<s>", "unsigned", "getKnownHighZeroBitsForFrameIndex", "(", ")", "const", "{", "return", "countLeadingZeros", "(", "MaxWaveScratchSize", ")", "+", "getWavefrontSizeLog2", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "high", "bits", "known", "to", "be", "zero", "for", "a", "frame", "index", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "uint8_t", "HSAILTargetLowering", "::", "getRepRegClassCostFor", "(", "MVT", "VT", ")", "const", "{", "return", "1", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "the", "'representative", "'", "register", "class", "for", "the", "specified", "value", "type", "." ]

[ "HSAIL", "HSAIL", "1" ]

[]

[ "<s>", "static", "rtx", "ix86_expand_sse_comi", "(", "const", "struct", "builtin_description", "*", "d", ",", "tree", "exp", ",", "rtx", "target", ")", "{", "rtx", "pat", ";", "tree", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "tree", "arg1", "=", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ";", "rtx", "op0", "=", "expand_normal", "(", "arg0", ")", ";", "rtx", "op1", "=", "expand_normal", "(", "arg1", ")", ";", "machine_mode", "mode0", "=", "insn_data", "[", "d", "->", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ";", "machine_mode", "mode1", "=", "insn_data", "[", "d", "->", "icode", "]", ".", "operand", "[", "1", "]", ".", "mode", ";", "enum", "rtx_code", "comparison", "=", "d", "->", "comparison", ";", "if", "(", "VECTOR_MODE_P", "(", "mode0", ")", ")", "op0", "=", "safe_vector_operand", "(", "op0", ",", "mode0", ")", ";", "if", "(", "VECTOR_MODE_P", "(", "mode1", ")", ")", "op1", "=", "safe_vector_operand", "(", "op1", ",", "mode1", ")", ";", "target", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_move_insn", "(", "target", ",", "const0_rtx", ")", ";", "target", "=", "gen_rtx_SUBREG", "(", "QImode", ",", "target", ",", "0", ")", ";", "if", "(", "(", "optimize", "&&", "!", "register_operand", "(", "op0", ",", "mode0", ")", ")", "||", "!", "insn_data", "[", "d", "->", "icode", "]", ".", "operand", "[", "0", "]", ".", "predicate", "(", "op0", ",", "mode0", ")", ")", "op0", "=", "copy_to_mode_reg", "(", "mode0", ",", "op0", ")", ";", "if", "(", "(", "optimize", "&&", "!", "register_operand", "(", "op1", ",", "mode1", ")", ")", "||", "!", "insn_data", "[", "d", "->", "icode", "]", ".", "operand", "[", "1", "]", ".", "predicate", "(", "op1", ",", "mode1", ")", ")", "op1", "=", "copy_to_mode_reg", "(", "mode1", ",", "op1", ")", ";", "pat", "=", "GEN_FCN", "(", "d", "->", "icode", ")", "(", "op0", ",", "op1", ")", ";", "if", "(", "!", "pat", ")", "return", "0", ";", "emit_insn", "(", "pat", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "gen_rtx_STRICT_LOW_PART", "(", "VOIDmode", ",", "target", ")", ",", "gen_rtx_fmt_ee", "(", "comparison", ",", "QImode", ",", "SET_DEST", "(", "pat", ")", ",", "const0_rtx", ")", ")", ")", ";", "return", "SUBREG_REG", "(", "target", ")", ";", "}", "</s>" ]

[ "Subroutine", "of", "ix86_expand_builtin", "to", "take", "care", "of", "comi", "insns", "." ]

[ "i386", "0", "1", "0", "1", "0", "0", "1", "0" ]

[]

[ "<s>", "void", "ARMBaseRegisterInfo", "::", "emitLoadConstPool", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "const", "DebugLoc", "&", "dl", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "int", "Val", ",", "ARMCC", "::", "CondCodes", "Pred", ",", "unsigned", "PredReg", ",", "unsigned", "MIFlags", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineConstantPool", "*", "ConstantPool", "=", "MF", ".", "getConstantPool", "(", ")", ";", "const", "Constant", "*", "C", "=", "ConstantInt", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "MF", ".", "getFunction", "(", ")", "->", "getContext", "(", ")", ")", ",", "Val", ")", ";", "unsigned", "Idx", "=", "ConstantPool", "->", "getConstantPoolIndex", "(", "C", ",", "4", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "LDRcp", ")", ")", ".", "addReg", "(", "DestReg", ",", "getDefRegState", "(", "true", ")", ",", "SubIdx", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "Pred", ")", ".", "addReg", "(", "PredReg", ")", ".", "setMIFlags", "(", "MIFlags", ")", ";", "}", "</s>" ]

[ "emitLoadConstPool", "-", "Emits", "a", "load", "from", "constpool", "to", "materialize", "the", "specified", "immediate", "." ]

[ "ARM", "ARM", "ARMCC::CondCodes", "4", "ARM::LDRcp", "0" ]

[]

[ "<s>", "FunctionPass", "*", "SPIRVPassConfig", "::", "createTargetRegisterAllocator", "(", "bool", ")", "{", "return", "nullptr", ";", "}", "</s>" ]

[ "createTargetRegisterAllocator", "-", "Create", "the", "register", "allocator", "pass", "for", "this", "target", "at", "the", "current", "optimization", "level", "." ]

[ "SPIRV", "SPIRV" ]

[]

[ "<s>", "static", "enum", "insn_code", "tilepro_multiply_get_opcode", "(", "const", "struct", "tilepro_multiply_insn_seq_entry", "*", "entry", ")", "{", "return", "tilepro_multiply_insn_seq_decode_opcode", "[", "entry", "->", "compressed_opcode", "]", ";", "}", "</s>" ]

[ "Returns", "the", "insn_code", "in", "ENTRY", "." ]

[ "tilepro" ]

[]