{"ground_truth": ["<s>", "static", "void", "add_constant", "(", "int", "dest", ",", "int", "src", ",", "int", "value", ",", "int", "mark_frame", ")", "{", "rtx_insn", "*", "insn", ";", "int", "hi", ",", "lo", ";", "if", "(", "src", "==", "dest", "&&", "value", "==", "0", ")", "return", ";", "if", "(", "value", "==", "0", ")", "{", "insn", "=", "emit_move_insn", "(", "gen_rtx_REG", "(", "SImode", ",", "dest", ")", ",", "gen_rtx_REG", "(", "SImode", ",", "src", ")", ")", ";", "if", "(", "mark_frame", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "return", ";", "}", "if", "(", "value", ">=", "-", "32768", "&&", "value", "<=", "32767", ")", "{", "insn", "=", "emit_insn", "(", "gen_addsi3", "(", "gen_rtx_REG", "(", "SImode", ",", "dest", ")", ",", "gen_rtx_REG", "(", "SImode", ",", "src", ")", ",", "GEN_INT", "(", "value", ")", ")", ")", ";", "if", "(", "mark_frame", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "return", ";", "}", "hi", "=", "trunc_int_for_mode", "(", "value", "&", "0xffff0000", ",", "SImode", ")", ";", "lo", "=", "value", "&", "0xffff", ";", "insn", "=", "emit_move_insn", "(", "gen_rtx_REG", "(", "SImode", ",", "REGSAVE_CONTROL_TEMP", ")", ",", "GEN_INT", "(", "hi", ")", ")", ";", "if", "(", "lo", ")", "{", "insn", "=", "emit_insn", "(", "gen_iorsi3", "(", "gen_rtx_REG", "(", "SImode", ",", "REGSAVE_CONTROL_TEMP", ")", ",", "gen_rtx_REG", "(", "SImode", ",", "REGSAVE_CONTROL_TEMP", ")", ",", "GEN_INT", "(", "lo", ")", ")", ")", ";", "}", "insn", "=", "emit_insn", "(", "gen_addsi3", "(", "gen_rtx_REG", "(", "SImode", ",", "dest", ")", ",", "gen_rtx_REG", "(", "SImode", ",", "src", ")", ",", "gen_rtx_REG", "(", "SImode", ",", "REGSAVE_CONTROL_TEMP", ")", ")", ")", ";", "if", "(", "mark_frame", ")", "{", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "gen_rtx_REG", "(", "SImode", ",", "dest", ")", ",", "gen_rtx_PLUS", "(", "SImode", ",", "gen_rtx_REG", "(", "SImode", ",", "dest", ")", ",", "GEN_INT", "(", "value", ")", ")", ")", ")", ";", "}", "}", "</s>"], "natrual_language": ["Add", "a", "constant", "to", "the", "pool", "and", "return", "its", "label", "."], "TS_V_token": ["mep", "0", "0", "1", "32768", "32767", "1", "0xffff0000", "0xffff", "1"], "File": "mep1", "Func": "add_constant", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32260, "Length": 275}
{"ground_truth": ["<s>", "static", "bool", "mep_expand_setcc_1", "(", "enum", "rtx_code", "code", ",", "rtx", "dest", ",", "rtx", "op1", ",", "rtx", "op2", ")", "{", "rtx", "tmp", ";", "switch", "(", "code", ")", "{", "case", "GT", ":", "case", "GTU", ":", "tmp", "=", "op1", ",", "op1", "=", "op2", ",", "op2", "=", "tmp", ";", "code", "=", "swap_condition", "(", "code", ")", ";", "case", "LT", ":", "case", "LTU", ":", "op1", "=", "force_reg", "(", "SImode", ",", "op1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "gen_rtx_fmt_ee", "(", "code", ",", "SImode", ",", "op1", ",", "op2", ")", ")", ")", ";", "return", "true", ";", "case", "EQ", ":", "if", "(", "op2", "!=", "const0_rtx", ")", "op1", "=", "expand_binop", "(", "SImode", ",", "sub_optab", ",", "op1", ",", "op2", ",", "NULL", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "mep_expand_setcc_1", "(", "LTU", ",", "dest", ",", "op1", ",", "const1_rtx", ")", ";", "return", "true", ";", "case", "NE", ":", "if", "(", "optimize_size", "&&", "op2", "!=", "const0_rtx", ")", "return", "false", ";", "if", "(", "op2", "!=", "const0_rtx", ")", "op1", "=", "expand_binop", "(", "SImode", ",", "sub_optab", ",", "op1", ",", "op2", ",", "NULL", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "op2", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "mep_expand_setcc_1", "(", "LTU", ",", "op2", ",", "op1", ",", "const1_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "gen_rtx_XOR", "(", "SImode", ",", "op2", ",", "const1_rtx", ")", ")", ")", ";", "return", "true", ";", "case", "LE", ":", "if", "(", "GET_CODE", "(", "op2", ")", "!=", "CONST_INT", "||", "INTVAL", "(", "op2", ")", "==", "0x7ffffff", ")", "return", "false", ";", "op2", "=", "GEN_INT", "(", "INTVAL", "(", "op2", ")", "+", "1", ")", ";", "return", "mep_expand_setcc_1", "(", "LT", ",", "dest", ",", "op1", ",", "op2", ")", ";", "case", "LEU", ":", "if", "(", "GET_CODE", "(", "op2", ")", "!=", "CONST_INT", "||", "INTVAL", "(", "op2", ")", "==", "-", "1", ")", "return", "false", ";", "op2", "=", "GEN_INT", "(", "trunc_int_for_mode", "(", "INTVAL", "(", "op2", ")", "+", "1", ",", "SImode", ")", ")", ";", "return", "mep_expand_setcc_1", "(", "LTU", ",", "dest", ",", "op1", ",", "op2", ")", ";", "case", "GE", ":", "if", "(", "GET_CODE", "(", "op2", ")", "!=", "CONST_INT", "||", "INTVAL", "(", "op2", ")", "==", "trunc_int_for_mode", "(", "0x80000000", ",", "SImode", ")", ")", "return", "false", ";", "op2", "=", "GEN_INT", "(", "INTVAL", "(", "op2", ")", "-", "1", ")", ";", "return", "mep_expand_setcc_1", "(", "GT", ",", "dest", ",", "op1", ",", "op2", ")", ";", "case", "GEU", ":", "if", "(", "GET_CODE", "(", "op2", ")", "!=", "CONST_INT", "||", "op2", "==", "const0_rtx", ")", "return", "false", ";", "op2", "=", "GEN_INT", "(", "trunc_int_for_mode", "(", "INTVAL", "(", "op2", ")", "-", "1", ",", "SImode", ")", ")", ";", "return", "mep_expand_setcc_1", "(", "GTU", ",", "dest", ",", "op1", ",", "op2", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Emit", "a", "setcc", "instruction", "in", "its", "entirity", "."], "TS_V_token": ["mep", "1", "1", "0x7ffffff", "1", "1", "1", "0x80000000", "1", "1"], "File": "mep1", "Func": "mep_expand_setcc_1", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32261, "Length": 412}
{"ground_truth": ["<s>", "static", "void", "add_constant", "(", "int", "dest", ",", "int", "src", ",", "int", "value", ",", "int", "mark_frame", ")", "{", "rtx_insn", "*", "insn", ";", "int", "hi", ",", "lo", ";", "if", "(", "src", "==", "dest", "&&", "value", "==", "0", ")", "return", ";", "if", "(", "value", "==", "0", ")", "{", "insn", "=", "emit_move_insn", "(", "gen_rtx_REG", "(", "SImode", ",", "dest", ")", ",", "gen_rtx_REG", "(", "SImode", ",", "src", ")", ")", ";", "if", "(", "mark_frame", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "return", ";", "}", "if", "(", "value", ">=", "-", "32768", "&&", "value", "<=", "32767", ")", "{", "insn", "=", "emit_insn", "(", "gen_addsi3", "(", "gen_rtx_REG", "(", "SImode", ",", "dest", ")", ",", "gen_rtx_REG", "(", "SImode", ",", "src", ")", ",", "GEN_INT", "(", "value", ")", ")", ")", ";", "if", "(", "mark_frame", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "return", ";", "}", "hi", "=", "trunc_int_for_mode", "(", "value", "&", "0xffff0000", ",", "SImode", ")", ";", "lo", "=", "value", "&", "0xffff", ";", "insn", "=", "emit_move_insn", "(", "gen_rtx_REG", "(", "SImode", ",", "REGSAVE_CONTROL_TEMP", ")", ",", "GEN_INT", "(", "hi", ")", ")", ";", "if", "(", "lo", ")", "{", "insn", "=", "emit_insn", "(", "gen_iorsi3", "(", "gen_rtx_REG", "(", "SImode", ",", "REGSAVE_CONTROL_TEMP", ")", ",", "gen_rtx_REG", "(", "SImode", ",", "REGSAVE_CONTROL_TEMP", ")", ",", "GEN_INT", "(", "lo", ")", ")", ")", ";", "}", "insn", "=", "emit_insn", "(", "gen_addsi3", "(", "gen_rtx_REG", "(", "SImode", ",", "dest", ")", ",", "gen_rtx_REG", "(", "SImode", ",", "src", ")", ",", "gen_rtx_REG", "(", "SImode", ",", "REGSAVE_CONTROL_TEMP", ")", ")", ")", ";", "if", "(", "mark_frame", ")", "{", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "SImode", ",", "gen_rtx_REG", "(", "SImode", ",", "dest", ")", ",", "gen_rtx_PLUS", "(", "SImode", ",", "gen_rtx_REG", "(", "SImode", ",", "dest", ")", ",", "GEN_INT", "(", "value", ")", ")", ")", ")", ";", "}", "}", "</s>"], "natrual_language": ["Add", "a", "constant", "to", "the", "pool", "and", "return", "its", "label", "."], "TS_V_token": ["mep", "0", "0", "1", "32768", "32767", "1", "0xffff0000", "0xffff", "1"], "File": "mep", "Func": "add_constant", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32262, "Length": 277}
{"ground_truth": ["<s>", "static", "int", "add_sp_insn_p", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "pat", ";", "if", "(", "!", "single_set", "(", "insn", ")", ")", "return", "0", ";", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "SET_DEST", "(", "pat", ")", ")", "!=", "REG", ")", "return", "0", ";", "if", "(", "REGNO", "(", "SET_DEST", "(", "pat", ")", ")", "!=", "SP_REGNO", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "pat", ")", ")", "!=", "PLUS", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "pat", ")", ",", "0", ")", ")", "!=", "REG", ")", "return", "0", ";", "if", "(", "REGNO", "(", "XEXP", "(", "SET_SRC", "(", "pat", ")", ",", "0", ")", ")", "!=", "SP_REGNO", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "pat", ")", ",", "1", ")", ")", "!=", "CONST_INT", ")", "return", "0", ";", "return", "INTVAL", "(", "XEXP", "(", "SET_SRC", "(", "pat", ")", ",", "1", ")", ")", ";", "}", "</s>"], "natrual_language": ["If", "this", "insn", "adjusts", "the", "stack", ",", "return", "the", "adjustment", ",", "else", "return", "zero", "."], "TS_V_token": ["mep", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "1"], "File": "mep", "Func": "add_sp_insn_p", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32263, "Length": 150}
{"ground_truth": ["<s>", "static", "rtx_insn", "*", "F", "(", "rtx_insn", "*", "x", ")", "{", "RTX_FRAME_RELATED_P", "(", "x", ")", "=", "1", ";", "return", "x", ";", "}", "</s>"], "natrual_language": ["We", "use", "this", "to", "wrap", "all", "emitted", "insns", "in", "the", "prologue", ",", "so", "they", "get", "the", "``", "frame-related", "''", "(", "/f", ")", "flag", "set", "."], "TS_V_token": ["mep", "1"], "File": "mep", "Func": "F", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32264, "Length": 21}
{"ground_truth": ["<s>", "static", "bool", "global_reg_mentioned_p", "(", "rtx", "x", ")", "{", "if", "(", "INSN_P", "(", "x", ")", ")", "{", "if", "(", "CALL_P", "(", "x", ")", ")", "{", "if", "(", "!", "RTL_CONST_OR_PURE_CALL_P", "(", "x", ")", ")", "return", "true", ";", "x", "=", "CALL_INSN_FUNCTION_USAGE", "(", "x", ")", ";", "if", "(", "x", "==", "0", ")", "return", "false", ";", "}", "else", "x", "=", "PATTERN", "(", "x", ")", ";", "}", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "x", ",", "NONCONST", ")", "if", "(", "global_reg_mentioned_p_1", "(", "*", "iter", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Returns", "nonzero", "if", "X", "mentions", "a", "global", "register", "."], "TS_V_token": ["mep", "0"], "File": "mep", "Func": "global_reg_mentioned_p", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32265, "Length": 91}
{"ground_truth": ["<s>", "static", "bool", "global_reg_mentioned_p_1", "(", "const_rtx", "x", ")", "{", "int", "regno", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "SUBREG", ":", "if", "(", "REG_P", "(", "SUBREG_REG", "(", "x", ")", ")", ")", "{", "if", "(", "REGNO", "(", "SUBREG_REG", "(", "x", ")", ")", "<", "FIRST_PSEUDO_REGISTER", "&&", "global_regs", "[", "subreg_regno", "(", "x", ")", "]", ")", "return", "true", ";", "return", "false", ";", "}", "break", ";", "case", "REG", ":", "regno", "=", "REGNO", "(", "x", ")", ";", "if", "(", "regno", "<", "FIRST_PSEUDO_REGISTER", "&&", "global_regs", "[", "regno", "]", ")", "return", "true", ";", "return", "false", ";", "case", "CALL", ":", "return", "true", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["A", "subroutine", "of", "global_reg_mentioned_p", ",", "returns", "1", "if", "*", "LOC", "mentions", "a", "global", "register", "."], "TS_V_token": ["mep"], "File": "mep", "Func": "global_reg_mentioned_p_1", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32266, "Length": 104}
{"ground_truth": ["<s>", "static", "hashval_t", "hash", "(", "const", "char", "*", "s", ")", "{", "return", "htab_hash_string", "(", "s", ")", ";", "}", "</s>"], "natrual_language": ["Hash", "function", "for", "builtin", "functions", "with", "up", "to", "3", "arguments", "and", "a", "return", "type", "."], "TS_V_token": ["mep"], "File": "mep", "Func": "hash", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32267, "Length": 17}
{"ground_truth": ["<s>", "static", "rtx_insn", "*", "maybe_dead_move", "(", "rtx", "dest", ",", "rtx", "src", ",", "bool", "ATTRIBUTE_UNUSED", "maybe_dead_p", ")", "{", "rtx_insn", "*", "insn", "=", "emit_move_insn", "(", "dest", ",", "src", ")", ";", "if", "(", "maybe_dead_p", ")", "REG_NOTES", "(", "insn", ")", "=", "gen_rtx_EXPR_LIST", "(", "REG_MAYBE_DEAD", ",", "const0_rtx", ",", "NULL", ")", ";", "return", "insn", ";", "}", "</s>"], "natrual_language": ["Move", "SRC", "to", "DEST", ".", "Mark", "the", "move", "as", "being", "potentially", "dead", "if", "MAYBE_DEAD_P", "."], "TS_V_token": ["mep"], "File": "mep", "Func": "maybe_dead_move", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32268, "Length": 49}
{"ground_truth": ["<s>", "static", "int", "mep_adjust_cost", "(", "rtx_insn", "*", "insn", ",", "rtx", "link", ",", "rtx_insn", "*", "dep_insn", ",", "int", "cost", ")", "{", "int", "cost_specified", ";", "if", "(", "REG_NOTE_KIND", "(", "link", ")", "!=", "0", ")", "{", "if", "(", "REG_NOTE_KIND", "(", "link", ")", "==", "REG_DEP_OUTPUT", "&&", "global_reg_mentioned_p", "(", "PATTERN", "(", "insn", ")", ")", "&&", "global_reg_mentioned_p", "(", "PATTERN", "(", "dep_insn", ")", ")", ")", "return", "1", ";", "return", "0", ";", "}", "if", "(", "recog_memoized", "(", "dep_insn", ")", "<", "0", ")", "return", "cost", ";", "if", "(", "!", "TARGET_H1", ")", "{", "cost_specified", "=", "get_attr_latency", "(", "dep_insn", ")", ";", "if", "(", "cost_specified", "!=", "0", ")", "return", "cost_specified", ";", "}", "return", "cost", ";", "}", "</s>"], "natrual_language": ["Scheduling", "hooks", "for", "VLIW", "mode", ".", "Conceptually", "this", "is", "very", "simple", ":", "we", "have", "a", "two-pack", "architecture", "that", "takes", "one", "core", "insn", "and", "one", "coprocessor", "insn", "to", "make", "up", "either", "a", "32-", "or", "64-bit", "instruction", "word", "(", "depending", "on", "the", "option", "bit", "set", "in", "the", "chip", ")", ".", "I.e", ".", "in", "VL32", "mode", ",", "we", "can", "pack", "one", "16-bit", "core", "insn", "and", "one", "16-bit", "cop", "insn", ";", "in", "VL64", "mode", "we", "can", "pack", "one", "16-bit", "core", "insn", "and", "one", "48-bit", "cop", "insn", "or", "two", "32-bit", "core/cop", "insns", ".", "In", "practice", ",", "instruction", "selection", "will", "be", "a", "bear", ".", "Consider", "in", "VL64", "mode", "the", "following", "insns", "add", "$", "1", ",", "1", "cmov", "$", "cr0", ",", "$", "0", "these", "can", "not", "pack", ",", "since", "the", "add", "is", "a", "16-bit", "core", "insn", "and", "cmov", "is", "a", "32-bit", "cop", "insn", ".", "However", ",", "add3", "$", "1", ",", "$", "1", ",", "1", "cmov", "$", "cr0", ",", "$", "0", "packs", "just", "fine", ".", "For", "good", "VLIW", "code", "generation", "in", "VL64", "mode", ",", "we", "will", "have", "to", "have", "32-bit", "alternatives", "for", "many", "of", "the", "common", "core", "insns", ".", "Not", "implemented", "."], "TS_V_token": ["mep", "0", "1", "0", "0", "0"], "File": "mep", "Func": "mep_adjust_cost", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32269, "Length": 103}
{"ground_truth": ["<s>", "static", "void", "mep_asm_named_section", "(", "const", "char", "*", "name", ",", "unsigned", "int", "flags", ",", "tree", "decl", "ATTRIBUTE_UNUSED", ")", "{", "char", "flagchars", "[", "8", "]", ",", "*", "f", "=", "flagchars", ";", "const", "char", "*", "type", ";", "if", "(", "!", "(", "flags", "&", "SECTION_DEBUG", ")", ")", "*", "f", "++", "=", "'a'", ";", "if", "(", "flags", "&", "SECTION_WRITE", ")", "*", "f", "++", "=", "'w'", ";", "if", "(", "flags", "&", "SECTION_CODE", ")", "*", "f", "++", "=", "'x'", ";", "if", "(", "flags", "&", "SECTION_SMALL", ")", "*", "f", "++", "=", "'s'", ";", "if", "(", "flags", "&", "SECTION_MEP_VLIW", ")", "*", "f", "++", "=", "'v'", ";", "*", "f", "=", "'\\0'", ";", "if", "(", "flags", "&", "SECTION_BSS", ")", "type", "=", "\"nobits\"", ";", "else", "type", "=", "\"progbits\"", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.section\\t%s,\\\"%s\\\",@%s\\n\"", ",", "name", ",", "flagchars", ",", "type", ")", ";", "if", "(", "flags", "&", "SECTION_CODE", ")", "fputs", "(", "(", "flags", "&", "SECTION_MEP_VLIW", "?", "\"\\t.vliw\\n\"", ":", "\"\\t.core\\n\"", ")", ",", "asm_out_file", ")", ";", "}", "</s>"], "natrual_language": ["Switch", "to", "an", "arbitrary", "section", "NAME", "with", "attributes", "as", "specified", "by", "FLAGS", ".", "ALIGN", "specifies", "any", "known", "alignment", "requirements", "for", "the", "section", ";", "0", "if", "the", "default", "should", "be", "used", ".", "Differs", "from", "the", "standard", "ELF", "version", "only", "in", "support", "of", "VLIW", "mode", "."], "TS_V_token": ["mep", "8", "\"nobits\"", "\"progbits\"", "\"\\t.section\\t%s,\\\"%s\\\",@%s\\n\"", "\"\\t.vliw\\n\"", "\"\\t.core\\n\""], "File": "mep", "Func": "mep_asm_named_section", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32270, "Length": 152}
{"ground_truth": ["<s>", "void", "mep_asm_output_opcode", "(", "FILE", "*", "file", ",", "const", "char", "*", "ptr", ")", "{", "int", "this_opcode", "=", "op_none", ";", "const", "char", "*", "hazard", "=", "0", ";", "switch", "(", "*", "ptr", ")", "{", "case", "'f'", ":", "if", "(", "strncmp", "(", "ptr", ",", "\"fsft\"", ",", "4", ")", "==", "0", "&&", "!", "ISGRAPH", "(", "ptr", "[", "4", "]", ")", ")", "this_opcode", "=", "op_fsft", ";", "break", ";", "case", "'r'", ":", "if", "(", "strncmp", "(", "ptr", ",", "\"ret\"", ",", "3", ")", "==", "0", "&&", "!", "ISGRAPH", "(", "ptr", "[", "3", "]", ")", ")", "this_opcode", "=", "op_ret", ";", "break", ";", "case", "'s'", ":", "if", "(", "strncmp", "(", "ptr", ",", "\"stc\"", ",", "3", ")", "==", "0", "&&", "!", "ISGRAPH", "(", "ptr", "[", "3", "]", ")", ")", "this_opcode", "=", "op_stc", ";", "break", ";", "}", "if", "(", "prev_opcode", "==", "op_stc", "&&", "this_opcode", "==", "op_fsft", ")", "hazard", "=", "\"nop\"", ";", "if", "(", "prev_opcode", "==", "op_stc", "&&", "this_opcode", "==", "op_ret", ")", "hazard", "=", "\"nop\"", ";", "if", "(", "hazard", ")", "fprintf", "(", "file", ",", "\"%s\\t# %s-%s hazard\\n\\t\"", ",", "hazard", ",", "opnames", "[", "prev_opcode", "]", ",", "opnames", "[", "this_opcode", "]", ")", ";", "prev_opcode", "=", "this_opcode", ";", "}", "</s>"], "natrual_language": ["This", "is", "n't", "as", "optimal", "as", "it", "could", "be", ",", "because", "we", "do", "n't", "know", "what", "control", "register", "the", "STC", "opcode", "is", "storing", "in", ".", "We", "only", "need", "to", "add", "the", "nop", "if", "it", "'s", "the", "relevant", "register", ",", "but", "we", "add", "it", "for", "irrelevant", "registers", "also", "."], "TS_V_token": ["mep", "0", "\"fsft\"", "4", "0", "4", "\"ret\"", "3", "0", "3", "\"stc\"", "3", "0", "3", "\"nop\"", "\"nop\"", "\"%s\\t# %s-%s hazard\\n\\t\""], "File": "mep", "Func": "mep_asm_output_opcode", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32271, "Length": 181}
{"ground_truth": ["<s>", "static", "bool", "mep_assign_save_slots", "(", "int", "reg_save_size", ")", "{", "bool", "really_need_stack_frame", "=", "false", ";", "int", "di_ofs", "=", "0", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "if", "(", "mep_call_saves_register", "(", "i", ")", ")", "{", "int", "regsize", "=", "mep_reg_size", "(", "i", ")", ";", "if", "(", "(", "i", "!=", "TP_REGNO", "&&", "i", "!=", "GP_REGNO", "&&", "i", "!=", "LP_REGNO", ")", "||", "mep_reg_set_in_function", "(", "i", ")", ")", "really_need_stack_frame", "=", "true", ";", "if", "(", "cfun", "->", "machine", "->", "reg_save_slot", "[", "i", "]", ")", "continue", ";", "if", "(", "regsize", "<", "8", ")", "{", "cfun", "->", "machine", "->", "reg_save_size", "+=", "regsize", ";", "cfun", "->", "machine", "->", "reg_save_slot", "[", "i", "]", "=", "cfun", "->", "machine", "->", "reg_save_size", ";", "}", "else", "{", "cfun", "->", "machine", "->", "reg_save_slot", "[", "i", "]", "=", "reg_save_size", "-", "di_ofs", ";", "di_ofs", "+=", "8", ";", "}", "}", "cfun", "->", "machine", "->", "frame_locked", "=", "1", ";", "return", "really_need_stack_frame", ";", "}", "</s>"], "natrual_language": ["Assign", "save", "slots", "for", "any", "register", "not", "already", "saved", ".", "DImode", "registers", "go", "at", "the", "end", "of", "the", "reg", "save", "area", ";", "the", "rest", "go", "at", "the", "beginning", ".", "This", "is", "for", "alignment", "purposes", ".", "Returns", "true", "if", "a", "frame", "is", "really", "needed", "."], "TS_V_token": ["mep", "0", "0", "8", "8", "1"], "File": "mep", "Func": "mep_assign_save_slots", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32272, "Length": 152}
{"ground_truth": ["<s>", "bool", "mep_cannot_change_mode_class", "(", "machine_mode", "from", ",", "machine_mode", "to", ",", "enum", "reg_class", "regclass", ")", "{", "if", "(", "from", "==", "to", ")", "return", "false", ";", "if", "(", "TARGET_64BIT_CR_REGS", "&&", "(", "regclass", "==", "CR_REGS", "||", "regclass", "==", "LOADABLE_CR_REGS", ")", "&&", "(", "GET_MODE_SIZE", "(", "to", ")", "<", "8", "||", "GET_MODE_SIZE", "(", "from", ")", "<", "8", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "the", "registers", "in", "CLASS", "can", "not", "represent", "the", "change", "from", "modes", "FROM", "to", "TO", "."], "TS_V_token": ["mep", "8", "8"], "File": "mep", "Func": "mep_cannot_change_mode_class", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32273, "Length": 60}
{"ground_truth": ["<s>", "bool", "mep_can_eliminate", "(", "const", "int", "from", ",", "const", "int", "to", ")", "{", "return", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", "?", "!", "frame_pointer_needed", ":", "true", ")", ";", "}", "</s>"], "natrual_language": ["Worker", "function", "for", "TARGET_CAN_ELIMINATE", "."], "TS_V_token": ["mep"], "File": "mep", "Func": "mep_can_eliminate", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32274, "Length": 29}
{"ground_truth": ["<s>", "static", "rtx", "mep_convert_arg", "(", "machine_mode", "mode", ",", "rtx", "arg", ")", "{", "if", "(", "GET_MODE", "(", "arg", ")", "!=", "mode", "&&", "register_operand", "(", "arg", ",", "VOIDmode", ")", "&&", "GET_MODE_SIZE", "(", "GET_MODE", "(", "arg", ")", ")", "==", "GET_MODE_SIZE", "(", "mode", ")", ")", "return", "simplify_gen_subreg", "(", "mode", ",", "arg", ",", "GET_MODE", "(", "arg", ")", ",", "0", ")", ";", "return", "arg", ";", "}", "</s>"], "natrual_language": ["If", "ARG", "is", "a", "register", "operand", "that", "is", "the", "same", "size", "as", "MODE", ",", "convert", "it", "to", "MODE", "using", "a", "subreg", ".", "Otherwise", "return", "ARG", "as-is", "."], "TS_V_token": ["mep", "0"], "File": "mep", "Func": "mep_convert_arg", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32275, "Length": 59}
{"ground_truth": ["<s>", "static", "rtx", "mep_convert_regnum", "(", "const", "struct", "cgen_regnum_operand", "*", "regnum", ",", "rtx", "arg", ")", "{", "if", "(", "regnum", "->", "count", "==", "0", ")", "return", "arg", ";", "if", "(", "GET_CODE", "(", "arg", ")", "!=", "CONST_INT", "||", "INTVAL", "(", "arg", ")", "<", "0", "||", "INTVAL", "(", "arg", ")", ">=", "regnum", "->", "count", ")", "return", "0", ";", "return", "gen_rtx_REG", "(", "SImode", ",", "INTVAL", "(", "arg", ")", "+", "regnum", "->", "base", ")", ";", "}", "</s>"], "natrual_language": ["Apply", "regnum", "conversions", "to", "ARG", "using", "the", "description", "given", "by", "REGNUM", ".", "Return", "the", "new", "argument", "on", "success", "and", "null", "on", "failure", "."], "TS_V_token": ["mep", "0", "0", "0"], "File": "mep", "Func": "mep_convert_regnum", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32276, "Length": 69}
{"ground_truth": ["<s>", "bool", "mep_emit_intrinsic", "(", "int", "intrinsic", ",", "const", "rtx", "*", "operands", ")", "{", "const", "struct", "cgen_insn", "*", "cgen_insn", ";", "const", "struct", "insn_data_d", "*", "idata", ";", "rtx", "newop", "[", "10", "]", ";", "int", "i", ";", "if", "(", "!", "mep_get_intrinsic_insn", "(", "intrinsic", ",", "&", "cgen_insn", ")", ")", "return", "false", ";", "idata", "=", "&", "insn_data", "[", "cgen_insn", "->", "icode", "]", ";", "for", "(", "i", "=", "0", ";", "i", "<", "idata", "->", "n_operands", ";", "i", "++", ")", "{", "newop", "[", "i", "]", "=", "mep_convert_arg", "(", "idata", "->", "operand", "[", "i", "]", ".", "mode", ",", "operands", "[", "i", "]", ")", ";", "if", "(", "!", "idata", "->", "operand", "[", "i", "]", ".", "predicate", "(", "newop", "[", "i", "]", ",", "idata", "->", "operand", "[", "i", "]", ".", "mode", ")", ")", "return", "false", ";", "}", "emit_insn", "(", "idata", "->", "genfun", "(", "newop", "[", "0", "]", ",", "newop", "[", "1", "]", ",", "newop", "[", "2", "]", ",", "newop", "[", "3", "]", ",", "newop", "[", "4", "]", ",", "newop", "[", "5", "]", ",", "newop", "[", "6", "]", ",", "newop", "[", "7", "]", ",", "newop", "[", "8", "]", ")", ")", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Try", "to", "instantiate", "INTRINSIC", "with", "the", "operands", "given", "in", "OPERANDS", ".", "Return", "true", "on", "success", ".", "This", "function", "can", "fail", "if", "the", "intrinsic", "is", "unavailable", "or", "if", "the", "operands", "do", "n't", "satisfy", "their", "predicates", "."], "TS_V_token": ["mep", "10", "0", "0", "1", "2", "3", "4", "5", "6", "7", "8"], "File": "mep", "Func": "mep_emit_intrinsic", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32277, "Length": 183}
{"ground_truth": ["<s>", "bool", "mep_epilogue_uses", "(", "int", "regno", ")", "{", "if", "(", "regno", "==", "LP_REGNO", "&&", "(", "profile_arc_flag", ">", "0", "||", "profile_flag", ">", "0", ")", ")", "return", "true", ";", "return", "(", "reload_completed", "&&", "mep_interrupt_saved_reg", "(", "regno", ")", ")", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "epilogue", "uses", "register", "REGNO", "."], "TS_V_token": ["mep", "0", "0"], "File": "mep", "Func": "mep_epilogue_uses", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32278, "Length": 37}
{"ground_truth": ["<s>", "bool", "mep_expand_binary_intrinsic", "(", "int", "ATTRIBUTE_UNUSED", "immediate", ",", "int", "ATTRIBUTE_UNUSED", "immediate3", ",", "int", "ATTRIBUTE_UNUSED", "reg", ",", "int", "ATTRIBUTE_UNUSED", "reg3", ",", "rtx", "*", "operands", "ATTRIBUTE_UNUSED", ")", "{", "return", "false", ";", "}", "</s>"], "natrual_language": ["Likewise", ",", "but", "apply", "a", "binary", "operation", "to", "OPERANDS", "[", "1", "]", "and", "OPERANDS", "[", "2", "]", ".", "OPERANDS", "[", "1", "]", "is", "a", "register_operand", ",", "OPERANDS", "[", "2", "]", "can", "be", "a", "general_operand", ".", "IMMEDIATE", "and", "IMMEDIATE3", "are", "intrinsics", "that", "take", "an", "immediate", "third", "operand", ".", "REG", "and", "REG3", "take", "register", "operands", "only", "."], "TS_V_token": ["mep"], "File": "mep", "Func": "mep_expand_binary_intrinsic", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32279, "Length": 29}
{"ground_truth": ["<s>", "static", "bool", "mep_expand_setcc_1", "(", "enum", "rtx_code", "code", ",", "rtx", "dest", ",", "rtx", "op1", ",", "rtx", "op2", ")", "{", "rtx", "tmp", ";", "switch", "(", "code", ")", "{", "case", "GT", ":", "case", "GTU", ":", "tmp", "=", "op1", ",", "op1", "=", "op2", ",", "op2", "=", "tmp", ";", "code", "=", "swap_condition", "(", "code", ")", ";", "case", "LT", ":", "case", "LTU", ":", "op1", "=", "force_reg", "(", "SImode", ",", "op1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "gen_rtx_fmt_ee", "(", "code", ",", "SImode", ",", "op1", ",", "op2", ")", ")", ")", ";", "return", "true", ";", "case", "EQ", ":", "if", "(", "op2", "!=", "const0_rtx", ")", "op1", "=", "expand_binop", "(", "SImode", ",", "sub_optab", ",", "op1", ",", "op2", ",", "NULL", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "mep_expand_setcc_1", "(", "LTU", ",", "dest", ",", "op1", ",", "const1_rtx", ")", ";", "return", "true", ";", "case", "NE", ":", "if", "(", "optimize_size", "&&", "op2", "!=", "const0_rtx", ")", "return", "false", ";", "if", "(", "op2", "!=", "const0_rtx", ")", "op1", "=", "expand_binop", "(", "SImode", ",", "sub_optab", ",", "op1", ",", "op2", ",", "NULL", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "op2", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "mep_expand_setcc_1", "(", "LTU", ",", "op2", ",", "op1", ",", "const1_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "gen_rtx_XOR", "(", "SImode", ",", "op2", ",", "const1_rtx", ")", ")", ")", ";", "return", "true", ";", "case", "LE", ":", "if", "(", "GET_CODE", "(", "op2", ")", "!=", "CONST_INT", "||", "INTVAL", "(", "op2", ")", "==", "0x7ffffff", ")", "return", "false", ";", "op2", "=", "GEN_INT", "(", "INTVAL", "(", "op2", ")", "+", "1", ")", ";", "return", "mep_expand_setcc_1", "(", "LT", ",", "dest", ",", "op1", ",", "op2", ")", ";", "case", "LEU", ":", "if", "(", "GET_CODE", "(", "op2", ")", "!=", "CONST_INT", "||", "INTVAL", "(", "op2", ")", "==", "-", "1", ")", "return", "false", ";", "op2", "=", "GEN_INT", "(", "trunc_int_for_mode", "(", "INTVAL", "(", "op2", ")", "+", "1", ",", "SImode", ")", ")", ";", "return", "mep_expand_setcc_1", "(", "LTU", ",", "dest", ",", "op1", ",", "op2", ")", ";", "case", "GE", ":", "if", "(", "GET_CODE", "(", "op2", ")", "!=", "CONST_INT", "||", "INTVAL", "(", "op2", ")", "==", "trunc_int_for_mode", "(", "0x80000000", ",", "SImode", ")", ")", "return", "false", ";", "op2", "=", "GEN_INT", "(", "INTVAL", "(", "op2", ")", "-", "1", ")", ";", "return", "mep_expand_setcc_1", "(", "GT", ",", "dest", ",", "op1", ",", "op2", ")", ";", "case", "GEU", ":", "if", "(", "GET_CODE", "(", "op2", ")", "!=", "CONST_INT", "||", "op2", "==", "const0_rtx", ")", "return", "false", ";", "op2", "=", "GEN_INT", "(", "trunc_int_for_mode", "(", "INTVAL", "(", "op2", ")", "-", "1", ",", "SImode", ")", ")", ";", "return", "mep_expand_setcc_1", "(", "GTU", ",", "dest", ",", "op1", ",", "op2", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Emit", "a", "setcc", "instruction", "in", "its", "entirity", "."], "TS_V_token": ["mep", "1", "1", "0x7ffffff", "1", "1", "1", "0x80000000", "1", "1"], "File": "mep", "Func": "mep_expand_setcc_1", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32280, "Length": 416}
{"ground_truth": ["<s>", "bool", "mep_expand_unary_intrinsic", "(", "int", "ATTRIBUTE_UNUSED", "intrinsic", ",", "rtx", "*", "operands", "ATTRIBUTE_UNUSED", ")", "{", "return", "false", ";", "}", "</s>"], "natrual_language": ["Apply", "the", "given", "unary", "intrinsic", "to", "OPERANDS", "[", "1", "]", "and", "store", "it", "on", "OPERANDS", "[", "0", "]", ".", "Report", "an", "error", "if", "the", "instruction", "could", "not", "be", "synthesized", ".", "OPERANDS", "[", "1", "]", "is", "a", "register_operand", ".", "For", "sign", "and", "zero", "extensions", ",", "it", "may", "be", "smaller", "than", "SImode", "."], "TS_V_token": ["mep"], "File": "mep", "Func": "mep_expand_unary_intrinsic", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32281, "Length": 17}
{"ground_truth": ["<s>", "rtx", "mep_find_base_term", "(", "rtx", "x", ")", "{", "rtx", "base", ",", "term", ";", "int", "unspec", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "PLUS", ")", "return", "x", ";", "base", "=", "XEXP", "(", "x", ",", "0", ")", ";", "term", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "has_hard_reg_initial_val", "(", "Pmode", ",", "TP_REGNO", ")", "&&", "base", "==", "mep_tp_rtx", "(", ")", ")", "unspec", "=", "UNS_TPREL", ";", "else", "if", "(", "has_hard_reg_initial_val", "(", "Pmode", ",", "GP_REGNO", ")", "&&", "base", "==", "mep_gp_rtx", "(", ")", ")", "unspec", "=", "UNS_GPREL", ";", "else", "return", "x", ";", "if", "(", "GET_CODE", "(", "term", ")", "!=", "CONST", ")", "return", "x", ";", "term", "=", "XEXP", "(", "term", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "term", ")", "!=", "UNSPEC", "||", "XINT", "(", "term", ",", "1", ")", "!=", "unspec", ")", "return", "x", ";", "return", "XVECEXP", "(", "term", ",", "0", ",", "0", ")", ";", "}", "</s>"], "natrual_language": ["If", "X", "is", "a", "machine", "specific", "address", "(", "i.e", ".", "a", "symbol", "or", "label", "being", "referenced", "as", "a", "displacement", "from", "the", "GOT", "implemented", "using", "an", "UNSPEC", ")", ",", "then", "return", "the", "base", "term", ".", "Otherwise", "return", "X", "."], "TS_V_token": ["mep", "0", "1", "0", "1", "0", "0"], "File": "mep", "Func": "mep_find_base_term", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32282, "Length": 141}
{"ground_truth": ["<s>", "static", "rtx", "mep_frame_expr", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "note", ",", "expr", ";", "note", "=", "find_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "0", ")", ";", "expr", "=", "(", "note", "!=", "0", "?", "XEXP", "(", "note", ",", "0", ")", ":", "copy_rtx", "(", "PATTERN", "(", "insn", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "expr", ")", "=", "1", ";", "return", "expr", ";", "}", "</s>"], "natrual_language": ["Return", "the", "effect", "of", "frame-related", "instruction", "INSN", "."], "TS_V_token": ["mep", "0", "0", "0", "1"], "File": "mep", "Func": "mep_frame_expr", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32283, "Length": 59}
{"ground_truth": ["<s>", "static", "rtx", "mep_function_arg", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "mode", "==", "VOIDmode", ")", "return", "GEN_INT", "(", "cum", "->", "vliw", ")", ";", "if", "(", "cum", "->", "nregs", "<", "4", ")", "{", "if", "(", "type", "&&", "TARGET_IVC2", "&&", "VECTOR_TYPE_P", "(", "type", ")", ")", "return", "gen_rtx_REG", "(", "mode", ",", "cum", "->", "nregs", "+", "49", ")", ";", "else", "return", "gen_rtx_REG", "(", "mode", ",", "cum", "->", "nregs", "+", "1", ")", ";", "}", "return", "NULL_RTX", ";", "}", "</s>"], "natrual_language": ["The", "ABI", "is", "thus", ":", "Arguments", "are", "in", "$", "1", ",", "$", "2", ",", "$", "3", ",", "$", "4", ",", "stack", ".", "Arguments", "larger", "than", "4", "bytes", "are", "passed", "indirectly", ".", "Return", "value", "in", "0", ",", "unless", "bigger", "than", "4", "bytes", ",", "then", "the", "caller", "passes", "a", "pointer", "as", "the", "first", "arg", ".", "For", "varargs", ",", "we", "copy", "$", "1", "..", "$", "4", "to", "the", "stack", "."], "TS_V_token": ["mep", "4", "49", "1"], "File": "mep", "Func": "mep_function_arg", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32284, "Length": 92}
{"ground_truth": ["<s>", "rtx", "mep_function_value", "(", "const_tree", "type", ",", "const_tree", "func", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_IVC2", "&&", "VECTOR_TYPE_P", "(", "type", ")", ")", "return", "gen_rtx_REG", "(", "TYPE_MODE", "(", "type", ")", ",", "48", ")", ";", "return", "gen_rtx_REG", "(", "TYPE_MODE", "(", "type", ")", ",", "RETURN_VALUE_REGNUM", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "FUNCTION_VALUE", ".", "All", "values", "are", "returned", "in", "$", "0", "."], "TS_V_token": ["mep", "48"], "File": "mep", "Func": "mep_function_value", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32285, "Length": 43}
{"ground_truth": ["<s>", "static", "bool", "mep_get_intrinsic_insn", "(", "int", "intrinsic", "ATTRIBUTE_UNUSED", ",", "const", "struct", "cgen_insn", "*", "*", "insn_ptr", "ATTRIBUTE_UNUSED", ")", "{", "int", "i", ";", "i", "=", "mep_intrinsic_insn", "[", "intrinsic", "]", ";", "while", "(", "i", ">=", "0", "&&", "!", "CGEN_ENABLE_INSN_P", "(", "i", ")", ")", "i", "=", "mep_intrinsic_chain", "[", "i", "]", ";", "if", "(", "i", ">=", "0", ")", "{", "*", "insn_ptr", "=", "&", "cgen_insns", "[", "i", "]", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["See", "if", "any", "implementation", "of", "INTRINSIC", "is", "available", "to", "the", "current", "function", ".", "If", "so", ",", "store", "the", "most", "general", "implementation", "in", "*", "INSN_PTR", "and", "return", "true", ".", "Return", "false", "otherwise", "."], "TS_V_token": ["mep", "0", "0"], "File": "mep", "Func": "mep_get_intrinsic_insn", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32286, "Length": 70}
{"ground_truth": ["<s>", "static", "bool", "mep_get_move_insn", "(", "int", "intrinsic", ",", "const", "struct", "cgen_insn", "*", "*", "cgen_insn", ")", "{", "size_t", "i", ";", "if", "(", "intrinsic", "==", "mep_cmov", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "mep_cmov_insns", ")", ";", "i", "++", ")", "if", "(", "mep_get_intrinsic_insn", "(", "mep_cmov_insns", "[", "i", "]", ",", "cgen_insn", ")", ")", "return", "true", ";", "return", "false", ";", "}", "return", "mep_get_intrinsic_insn", "(", "intrinsic", ",", "cgen_insn", ")", ";", "}", "</s>"], "natrual_language": ["Like", "mep_get_intrinsic_insn", ",", "but", "with", "extra", "handling", "for", "moves", ".", "If", "INTRINSIC", "is", "mep_cmov", ",", "but", "there", "is", "no", "pure", "CR", "<", "-", "CR", "move", "insn", ",", "try", "using", "a", "work-alike", "instead", ".", "In", "this", "case", ",", "the", "returned", "insn", "may", "have", "three", "operands", "rather", "than", "two", "."], "TS_V_token": ["mep", "0"], "File": "mep", "Func": "mep_get_move_insn", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32287, "Length": 69}
{"ground_truth": ["<s>", "static", "void", "mep_incompatible_arg", "(", "const", "struct", "insn_operand_data", "*", "operand", ",", "rtx", "arg", ",", "int", "argnum", ",", "tree", "fnname", ")", "{", "size_t", "i", ";", "if", "(", "GET_CODE", "(", "arg", ")", "==", "CONST_INT", ")", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "cgen_immediate_predicates", ")", ";", "i", "++", ")", "if", "(", "operand", "->", "predicate", "==", "cgen_immediate_predicates", "[", "i", "]", ".", "predicate", ")", "{", "const", "struct", "cgen_immediate_predicate", "*", "predicate", ";", "HOST_WIDE_INT", "argval", ";", "predicate", "=", "&", "cgen_immediate_predicates", "[", "i", "]", ";", "argval", "=", "INTVAL", "(", "arg", ")", ";", "if", "(", "argval", "<", "predicate", "->", "lower", "||", "argval", ">=", "predicate", "->", "upper", ")", "error", "(", "\"argument %d of %qE must be in the range %d...%d\"", ",", "argnum", ",", "fnname", ",", "predicate", "->", "lower", ",", "predicate", "->", "upper", "-", "1", ")", ";", "else", "error", "(", "\"argument %d of %qE must be a multiple of %d\"", ",", "argnum", ",", "fnname", ",", "predicate", "->", "align", ")", ";", "return", ";", "}", "error", "(", "\"incompatible type for argument %d of %qE\"", ",", "argnum", ",", "fnname", ")", ";", "}", "</s>"], "natrual_language": ["Report", "that", "ARG", "can", "not", "be", "passed", "to", "argument", "ARGNUM", "of", "intrinsic", "function", "FNNAME", ".", "OPERAND", "describes", "the", "operand", "to", "which", "ARGNUM", "is", "mapped", "."], "TS_V_token": ["mep", "0", "\"argument %d of %qE must be in the range %d...%d\"", "1", "\"argument %d of %qE must be a multiple of %d\"", "\"incompatible type for argument %d of %qE\""], "File": "mep", "Func": "mep_incompatible_arg", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32288, "Length": 146}
{"ground_truth": ["<s>", "static", "void", "mep_init_intrinsics", "(", "void", ")", "{", "size_t", "i", ";", "mep_selected_isa", "=", "mep_configs", "[", "0", "]", ".", "isa", ";", "if", "(", "mep_config_string", "!=", "0", ")", "for", "(", "i", "=", "0", ";", "mep_configs", "[", "i", "]", ".", "config_name", ";", "i", "++", ")", "if", "(", "strcmp", "(", "mep_config_string", ",", "mep_configs", "[", "i", "]", ".", "config_name", ")", "==", "0", ")", "{", "mep_selected_isa", "=", "mep_configs", "[", "i", "]", ".", "isa", ";", "break", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "mep_intrinsic_insn", ")", ";", "i", "++", ")", "mep_intrinsic_insn", "[", "i", "]", "=", "-", "1", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "cgen_insns", ")", ";", "i", "++", ")", "if", "(", "(", "cgen_insns", "[", "i", "]", ".", "isas", "&", "mep_selected_isa", ")", "!=", "0", ")", "{", "mep_intrinsic_chain", "[", "i", "]", "=", "mep_intrinsic_insn", "[", "cgen_insns", "[", "i", "]", ".", "intrinsic", "]", ";", "mep_intrinsic_insn", "[", "cgen_insns", "[", "i", "]", ".", "intrinsic", "]", "=", "i", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "mep_cmov_insns", ")", ";", "i", "++", ")", "if", "(", "MEP_INTRINSIC_AVAILABLE_P", "(", "mep_cmov_insns", "[", "i", "]", ")", ")", "mep_have_copro_copro_moves_p", "=", "true", ";", "mep_have_core_copro_moves_p", "=", "(", "MEP_INTRINSIC_AVAILABLE_P", "(", "mep_cmov1", ")", "&&", "MEP_INTRINSIC_AVAILABLE_P", "(", "mep_cmov2", ")", ")", ";", "mep_have_core_copro_moves_p", "=", "1", ";", "}", "</s>"], "natrual_language": ["Initialize", "the", "global", "intrinsics", "variables", "above", "."], "TS_V_token": ["mep", "0", "0", "0", "0", "0", "1", "0", "0", "0", "1"], "File": "mep", "Func": "mep_init_intrinsics", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32289, "Length": 203}
{"ground_truth": ["<s>", "static", "struct", "machine_function", "*", "mep_init_machine_status", "(", "void", ")", "{", "return", "ggc_cleared_alloc", "<", "machine_function", ">", "(", ")", ";", "}", "</s>"], "natrual_language": ["Functions", "to", "save", "and", "restore", "machine-specific", "function", "data", "."], "TS_V_token": ["mep"], "File": "mep", "Func": "mep_init_machine_status", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32290, "Length": 18}
{"ground_truth": ["<s>", "static", "rtx_insn", "*", "mep_insert_repeat_label_last", "(", "rtx_insn", "*", "last_insn", ",", "rtx_code_label", "*", "label", ",", "bool", "including", ",", "bool", "shared", ")", "{", "rtx_insn", "*", "next", ",", "*", "prev", ";", "int", "count", "=", "0", ",", "code", ",", "icode", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"considering end of repeat loop at insn %d\\n\"", ",", "INSN_UID", "(", "last_insn", ")", ")", ";", "prev", "=", "last_insn", ";", "if", "(", "!", "including", ")", "prev", "=", "PREV_INSN", "(", "prev", ")", ";", "next", "=", "last_insn", ";", "if", "(", "!", "shared", ")", "while", "(", "prev", "!=", "0", ")", "{", "code", "=", "GET_CODE", "(", "prev", ")", ";", "if", "(", "code", "==", "CALL_INSN", "||", "code", "==", "CODE_LABEL", "||", "code", "==", "BARRIER", ")", "break", ";", "if", "(", "INSN_P", "(", "prev", ")", ")", "{", "if", "(", "GET_CODE", "(", "PATTERN", "(", "prev", ")", ")", "==", "SEQUENCE", ")", "prev", "=", "as_a", "<", "rtx_insn", "*", ">", "(", "XVECEXP", "(", "PATTERN", "(", "prev", ")", ",", "0", ",", "1", ")", ")", ";", "icode", "=", "recog_memoized", "(", "prev", ")", ";", "if", "(", "icode", "<", "0", "||", "icode", "==", "CODE_FOR_repeat", "||", "icode", "==", "CODE_FOR_erepeat", "||", "get_attr_may_trap", "(", "prev", ")", "==", "MAY_TRAP_YES", ")", "break", ";", "if", "(", "GET_MODE", "(", "prev", ")", "!=", "BImode", ")", "{", "count", "++", ";", "next", "=", "prev", ";", "if", "(", "dump_file", ")", "print_rtl_single", "(", "dump_file", ",", "next", ")", ";", "if", "(", "count", "==", "2", ")", "break", ";", "}", "}", "prev", "=", "PREV_INSN", "(", "prev", ")", ";", "}", "prev", "=", "prev_real_insn", "(", "next", ")", ";", "if", "(", "prev", ")", "switch", "(", "recog_memoized", "(", "prev", ")", ")", "{", "case", "CODE_FOR_repeat", ":", "case", "CODE_FOR_erepeat", ":", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Adding nop inside loop\\n\"", ")", ";", "emit_insn_before", "(", "gen_nop", "(", ")", ",", "next", ")", ";", "break", ";", "default", ":", "break", ";", "}", "emit_label_before", "(", "label", ",", "next", ")", ";", "if", "(", "dump_file", "&&", "count", "<", "2", ")", "fprintf", "(", "dump_file", ",", "\"Adding %d nop%s\\n\\n\"", ",", "2", "-", "count", ",", "count", "==", "1", "?", "\"\"", ":", "\"s\"", ")", ";", "for", "(", ";", "count", "<", "2", ";", "count", "++", ")", "if", "(", "including", ")", "last_insn", "=", "emit_insn_after", "(", "gen_nop", "(", ")", ",", "last_insn", ")", ";", "else", "emit_insn_before", "(", "gen_nop", "(", ")", ",", "last_insn", ")", ";", "return", "last_insn", ";", "}", "</s>"], "natrual_language": ["Figure", "out", "where", "to", "put", "LABEL", ",", "which", "is", "the", "label", "for", "a", "repeat", "loop", ".", "If", "INCLUDING", ",", "LAST_INSN", "is", "the", "last", "instruction", "in", "the", "loop", ",", "otherwise", "the", "loop", "ends", "just", "before", "LAST_INSN", ".", "If", "SHARED", ",", "insns", "other", "than", "the", "``", "repeat", "''", "might", "use", "LABEL", "to", "jump", "to", "the", "loop", "'s", "continuation", "point", ".", "Return", "the", "last", "instruction", "in", "the", "adjusted", "loop", "."], "TS_V_token": ["mep", "0", "\"considering end of repeat loop at insn %d\\n\"", "0", "0", "1", "0", "2", "\"Adding nop inside loop\\n\"", "2", "\"Adding %d nop%s\\n\\n\"", "2", "1", "\"\"", "\"s\"", "2"], "File": "mep", "Func": "mep_insert_repeat_label_last", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32291, "Length": 349}
{"ground_truth": ["<s>", "static", "int", "mep_insn_dependent_p", "(", "rtx", "x", ",", "rtx", "y", ")", "{", "rtx", "tmp", ";", "gcc_assert", "(", "INSN_P", "(", "x", ")", ")", ";", "gcc_assert", "(", "INSN_P", "(", "y", ")", ")", ";", "tmp", "=", "PATTERN", "(", "y", ")", ";", "note_stores", "(", "PATTERN", "(", "x", ")", ",", "mep_insn_dependent_p_1", ",", "&", "tmp", ")", ";", "if", "(", "tmp", "==", "NULL_RTX", ")", "return", "1", ";", "tmp", "=", "PATTERN", "(", "x", ")", ";", "note_stores", "(", "PATTERN", "(", "y", ")", ",", "mep_insn_dependent_p_1", ",", "&", "tmp", ")", ";", "if", "(", "tmp", "==", "NULL_RTX", ")", "return", "1", ";", "return", "0", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "anything", "in", "insn", "X", "is", "(", "anti", ",", "output", ",", "true", ")", "dependent", "on", "anything", "in", "insn", "Y", "."], "TS_V_token": ["mep", "1", "1", "0"], "File": "mep", "Func": "mep_insn_dependent_p", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32292, "Length": 92}
{"ground_truth": ["<s>", "static", "void", "mep_insn_dependent_p_1", "(", "rtx", "x", ",", "const_rtx", "pat", "ATTRIBUTE_UNUSED", ",", "void", "*", "data", ")", "{", "rtx", "*", "pinsn", "=", "(", "rtx", "*", ")", "data", ";", "if", "(", "*", "pinsn", "&&", "reg_mentioned_p", "(", "x", ",", "*", "pinsn", ")", ")", "*", "pinsn", "=", "NULL_RTX", ";", "}", "</s>"], "natrual_language": ["A", "helper", "routine", "for", "ms1_insn_dependent_p", "called", "through", "note_stores", "."], "TS_V_token": ["mep"], "File": "mep", "Func": "mep_insn_dependent_p_1", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32293, "Length": 45}
{"ground_truth": ["<s>", "bool", "mep_ipipe_ldc_p", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "pat", ",", "src", ";", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "pat", "=", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SET", ")", "{", "src", "=", "SET_SRC", "(", "pat", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "UNSPEC", "||", "GET_CODE", "(", "src", ")", "==", "UNSPEC_VOLATILE", ")", "src", "=", "XVECEXP", "(", "src", ",", "0", ",", "0", ")", ";", "if", "(", "REG_P", "(", "src", ")", ")", "switch", "(", "REGNO", "(", "src", ")", ")", "{", "case", "PSW_REGNO", ":", "case", "LP_REGNO", ":", "case", "SAR_REGNO", ":", "case", "HI_REGNO", ":", "case", "LO_REGNO", ":", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "INSN", "is", "an", "ldc", "instruction", "that", "issues", "to", "the", "MeP-h1", "integer", "pipeline", ".", "This", "is", "true", "for", "instructions", "that", "read", "from", "PSW", ",", "LP", ",", "SAR", ",", "HI", "and", "LO", "."], "TS_V_token": ["mep", "0", "0", "0", "0"], "File": "mep", "Func": "mep_ipipe_ldc_p", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32294, "Length": 123}
{"ground_truth": ["<s>", "static", "void", "mep_jmp_return_reorg", "(", "rtx_insn", "*", "insns", ")", "{", "rtx_insn", "*", "insn", ",", "*", "label", ",", "*", "ret", ";", "int", "ret_code", ";", "for", "(", "insn", "=", "insns", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "simplejump_p", "(", "insn", ")", ")", "{", "label", "=", "ret", "=", "safe_as_a", "<", "rtx_insn", "*", ">", "(", "JUMP_LABEL", "(", "insn", ")", ")", ";", "while", "(", "ret", "&&", "(", "NOTE_P", "(", "ret", ")", "||", "LABEL_P", "(", "ret", ")", "||", "GET_CODE", "(", "PATTERN", "(", "ret", ")", ")", "==", "USE", ")", ")", "ret", "=", "NEXT_INSN", "(", "ret", ")", ";", "if", "(", "ret", ")", "{", "ret_code", "=", "recog_memoized", "(", "ret", ")", ";", "if", "(", "ret_code", "==", "CODE_FOR_return_internal", "||", "ret_code", "==", "CODE_FOR_eh_return_internal", ")", "{", "LABEL_NUSES", "(", "label", ")", "--", ";", "if", "(", "LABEL_NUSES", "(", "label", ")", "==", "0", ")", "delete_insn", "(", "label", ")", ";", "PATTERN", "(", "insn", ")", "=", "copy_rtx", "(", "PATTERN", "(", "ret", ")", ")", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "}", "}", "}", "}", "</s>"], "natrual_language": ["Replace", "a", "jump", "to", "a", "return", ",", "with", "a", "copy", "of", "the", "return", ".", "GCC", "does", "n't", "always", "do", "this", "on", "its", "own", "."], "TS_V_token": ["mep", "0", "1"], "File": "mep", "Func": "mep_jmp_return_reorg", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32295, "Length": 162}
{"ground_truth": ["<s>", "bool", "mep_legitimate_address", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "int", "strict", ")", "{", "int", "the_tag", ";", "fprintf", "(", "stderr", ",", "\"legit: mode %s strict %d \"", ",", "mode_name", "[", "mode", "]", ",", "strict", ")", ";", "debug_rtx", "(", "x", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "LO_SUM", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "REG", "&&", "GEN_REG", "(", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ",", "strict", ")", "&&", "CONSTANT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "4", ")", "{", "fprintf", "(", "stderr", ",", "\" - nope, %%lo(sym)[reg] not splittable\\n\"", ")", ";", "return", "false", ";", "}", "fprintf", "(", "stderr", ",", "\" - yup, %%lo(sym)[reg]\\n\"", ")", ";", "return", "true", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "REG", "&&", "GEN_REG", "(", "REGNO", "(", "x", ")", ",", "strict", ")", ")", "{", "fprintf", "(", "stderr", ",", "\" - yup, [reg]\\n\"", ")", ";", "return", "true", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "REG", "&&", "GEN_REG", "(", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ",", "strict", ")", "&&", "const_in_range", "(", "XEXP", "(", "x", ",", "1", ")", ",", "-", "32768", ",", "32767", ")", ")", "{", "fprintf", "(", "stderr", ",", "\" - yup, [reg+const]\\n\"", ")", ";", "return", "true", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "REG", "&&", "GEN_REG", "(", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ",", "strict", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST", "&&", "(", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "0", ")", ")", "==", "UNSPEC", "||", "(", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "0", ")", ",", "0", ")", ")", "==", "UNSPEC", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "0", ")", ",", "1", ")", ")", "==", "CONST_INT", ")", ")", ")", "{", "fprintf", "(", "stderr", ",", "\" - yup, [reg+unspec]\\n\"", ")", ";", "return", "true", ";", "}", "the_tag", "=", "mep_section_tag", "(", "x", ")", ";", "if", "(", "the_tag", "==", "'f'", ")", "{", "fprintf", "(", "stderr", ",", "\" - nope, [far]\\n\"", ")", ";", "return", "false", ";", "}", "if", "(", "mode", "==", "VOIDmode", "&&", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", "{", "fprintf", "(", "stderr", ",", "\" - yup, call [symbol]\\n\"", ")", ";", "return", "true", ";", "}", "if", "(", "(", "mode", "==", "SImode", "||", "mode", "==", "SFmode", ")", "&&", "CONSTANT_P", "(", "x", ")", "&&", "mep_legitimate_constant_p", "(", "mode", ",", "x", ")", "&&", "the_tag", "!=", "'t'", "&&", "the_tag", "!=", "'b'", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "!=", "CONST_INT", "||", "(", "INTVAL", "(", "x", ")", "<=", "0xfffff", "&&", "INTVAL", "(", "x", ")", ">=", "0", "&&", "(", "INTVAL", "(", "x", ")", "%", "4", ")", "==", "0", ")", ")", "{", "fprintf", "(", "stderr", ",", "\" - yup, [const]\\n\"", ")", ";", "return", "true", ";", "}", "}", "fprintf", "(", "stderr", ",", "\" - nope.\\n\"", ")", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Be", "careful", "not", "to", "use", "macros", "that", "need", "to", "be", "compiled", "one", "way", "for", "strict", ",", "and", "another", "way", "for", "not-strict", ",", "like", "REG_OK_FOR_BASE_P", "."], "TS_V_token": ["mep", "\"legit: mode %s strict %d \"", "0", "0", "1", "4", "\" - nope, %%lo(sym)[reg] not splittable\\n\"", "\" - yup, %%lo(sym)[reg]\\n\"", "\" - yup, [reg]\\n\"", "0", "0", "1", "32768", "32767", "\" - yup, [reg+const]\\n\"", "0", "0", "1", "1", "0", "1", "0", "1", "0", "0", "1", "0", "1", "\" - yup, [reg+unspec]\\n\"", "\" - nope, [far]\\n\"", "\" - yup, call [symbol]\\n\"", "0xfffff", "0", "4", "0", "\" - yup, [const]\\n\"", "\" - nope.\\n\""], "File": "mep", "Func": "mep_legitimate_address", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32296, "Length": 493}
{"ground_truth": ["<s>", "static", "bool", "mep_legitimate_constant_p", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "(", "reload_in_progress", "||", "reload_completed", ")", ")", "{", "char", "e", "=", "mep_section_tag", "(", "x", ")", ";", "return", "(", "e", "!=", "'t'", "&&", "e", "!=", "'b'", ")", ";", "}", "return", "1", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_LEGITIMATE_CONSTANT_P", "."], "TS_V_token": ["mep", "1"], "File": "mep", "Func": "mep_legitimate_constant_p", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32297, "Length": 52}
{"ground_truth": ["<s>", "static", "rtx", "mep_legitimize_arg", "(", "const", "struct", "insn_operand_data", "*", "operand", ",", "rtx", "arg", ",", "int", "unsigned_p", ")", "{", "if", "(", "GET_CODE", "(", "arg", ")", "==", "CONST_INT", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "operand", "->", "mode", ")", "!=", "MODE_INT", ")", "return", "0", ";", "}", "else", "if", "(", "GET_CODE", "(", "arg", ")", "==", "CONST_DOUBLE", ")", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "arg", ")", ")", "!=", "GET_MODE_SIZE", "(", "operand", "->", "mode", ")", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "operand", "->", "mode", ")", "!=", "GET_MODE_CLASS", "(", "GET_MODE", "(", "arg", ")", ")", ")", "return", "0", ";", "if", "(", "operand", "->", "constraint", "[", "0", "]", "!=", "'='", ")", "arg", "=", "convert_to_mode", "(", "operand", "->", "mode", ",", "arg", ",", "unsigned_p", ")", ";", "}", "if", "(", "operand", "->", "constraint", "[", "0", "]", "==", "'='", "&&", "(", "!", "REG_P", "(", "arg", ")", "||", "!", "(", "CONTROL_REGNO_P", "(", "REGNO", "(", "arg", ")", ")", "||", "CCR_REGNO_P", "(", "REGNO", "(", "arg", ")", ")", "||", "CR_REGNO_P", "(", "REGNO", "(", "arg", ")", ")", ")", ")", ")", "return", "gen_reg_rtx", "(", "operand", "->", "mode", ")", ";", "arg", "=", "mep_convert_arg", "(", "operand", "->", "mode", ",", "arg", ")", ";", "if", "(", "operand", "->", "predicate", "(", "arg", ",", "operand", "->", "mode", ")", ")", "return", "arg", ";", "if", "(", "GET_CODE", "(", "arg", ")", "==", "CONST_INT", "||", "GET_CODE", "(", "arg", ")", "==", "CONST_DOUBLE", ")", "arg", "=", "force_reg", "(", "operand", "->", "mode", ",", "arg", ")", ";", "else", "arg", "=", "mep_convert_arg", "(", "operand", "->", "mode", ",", "force_reg", "(", "GET_MODE", "(", "arg", ")", ",", "arg", ")", ")", ";", "if", "(", "operand", "->", "predicate", "(", "arg", ",", "operand", "->", "mode", ")", ")", "return", "arg", ";", "return", "0", ";", "}", "</s>"], "natrual_language": ["Try", "to", "make", "intrinsic", "argument", "ARG", "match", "the", "given", "operand", ".", "UNSIGNED_P", "is", "true", "if", "the", "argument", "has", "an", "unsigned", "type", "."], "TS_V_token": ["mep", "0", "0", "0", "0", "0"], "File": "mep", "Func": "mep_legitimize_arg", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32298, "Length": 265}
{"ground_truth": ["<s>", "rtx", "mep_libcall_value", "(", "machine_mode", "mode", ")", "{", "return", "gen_rtx_REG", "(", "mode", ",", "RETURN_VALUE_REGNUM", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "LIBCALL_VALUE", ",", "using", "the", "same", "rules", "as", "mep_function_value", "."], "TS_V_token": ["mep"], "File": "mep", "Func": "mep_libcall_value", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32299, "Length": 16}
{"ground_truth": ["<s>", "static", "rtx_insn", "*", "mep_make_bundle", "(", "rtx", "core_insn_or_pat", ",", "rtx_insn", "*", "cop", ")", "{", "rtx", "seq", ";", "rtx_insn", "*", "core_insn", ";", "rtx_insn", "*", "insn", ";", "if", "(", "INSN_P", "(", "core_insn_or_pat", ")", ")", "{", "core_insn", "=", "as_a", "<", "rtx_insn", "*", ">", "(", "core_insn_or_pat", ")", ";", "remove_insn", "(", "core_insn", ")", ";", "}", "else", "core_insn", "=", "make_insn_raw", "(", "core_insn_or_pat", ")", ";", "seq", "=", "gen_rtx_SEQUENCE", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "core_insn", ",", "cop", ")", ")", ";", "insn", "=", "emit_insn_after", "(", "seq", ",", "cop", ")", ";", "remove_insn", "(", "cop", ")", ";", "SET_PREV_INSN", "(", "core_insn", ")", "=", "PREV_INSN", "(", "insn", ")", ";", "SET_NEXT_INSN", "(", "core_insn", ")", "=", "cop", ";", "SET_PREV_INSN", "(", "cop", ")", "=", "core_insn", ";", "SET_NEXT_INSN", "(", "cop", ")", "=", "NEXT_INSN", "(", "insn", ")", ";", "PUT_MODE", "(", "core_insn", ",", "VOIDmode", ")", ";", "PUT_MODE", "(", "cop", ",", "BImode", ")", ";", "INSN_LOCATION", "(", "insn", ")", "=", "INSN_LOCATION", "(", "INSN_LOCATION", "(", "core_insn", ")", "?", "core_insn", ":", "cop", ")", ";", "INSN_LOCATION", "(", "core_insn", ")", "=", "0", ";", "INSN_LOCATION", "(", "cop", ")", "=", "0", ";", "return", "insn", ";", "}", "</s>"], "natrual_language": ["Create", "a", "VLIW", "bundle", "from", "core", "instruction", "CORE", "and", "coprocessor", "instruction", "COP", ".", "COP", "always", "satisfies", "INSN_P", ",", "but", "CORE", "can", "be", "either", "a", "new", "pattern", "or", "an", "existing", "instruction", ".", "Emit", "the", "bundle", "in", "place", "of", "COP", "and", "return", "it", "."], "TS_V_token": ["mep", "2", "0", "0"], "File": "mep", "Func": "mep_make_bundle", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32300, "Length": 170}
{"ground_truth": ["<s>", "static", "void", "mep_make_parallel", "(", "rtx_insn", "*", "insn1", ",", "rtx_insn", "*", "insn2", ")", "{", "rtx", "expr", ";", "if", "(", "RTX_FRAME_RELATED_P", "(", "insn2", ")", ")", "{", "expr", "=", "mep_frame_expr", "(", "insn2", ")", ";", "if", "(", "RTX_FRAME_RELATED_P", "(", "insn1", ")", ")", "expr", "=", "gen_rtx_SEQUENCE", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "mep_frame_expr", "(", "insn1", ")", ",", "expr", ")", ")", ";", "set_unique_reg_note", "(", "insn1", ",", "REG_FRAME_RELATED_EXPR", ",", "expr", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn1", ")", "=", "1", ";", "}", "PATTERN", "(", "insn1", ")", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "PATTERN", "(", "insn1", ")", ",", "PATTERN", "(", "insn2", ")", ")", ")", ";", "INSN_CODE", "(", "insn1", ")", "=", "-", "1", ";", "}", "</s>"], "natrual_language": ["Merge", "instructions", "INSN1", "and", "INSN2", "using", "a", "PARALLEL", ".", "Store", "the", "new", "pattern", "in", "INSN1", ";", "INSN2", "will", "be", "deleted", "by", "the", "caller", "."], "TS_V_token": ["mep", "2", "1", "2", "1"], "File": "mep", "Func": "mep_make_parallel", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32301, "Length": 108}
{"ground_truth": ["<s>", "static", "bool", "mep_mentioned_p", "(", "rtx", "in", ",", "rtx", "reg", ",", "int", "modes_too", ")", "{", "const", "char", "*", "fmt", ";", "int", "i", ";", "enum", "rtx_code", "code", ";", "if", "(", "in", "==", "0", ")", "return", "false", ";", "if", "(", "reg", "&&", "GET_CODE", "(", "reg", ")", "!=", "REG", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "in", ")", "==", "LABEL_REF", ")", "return", "(", "reg", "==", "0", ")", ";", "code", "=", "GET_CODE", "(", "in", ")", ";", "switch", "(", "code", ")", "{", "case", "MEM", ":", "if", "(", "reg", ")", "return", "mep_mentioned_p", "(", "XEXP", "(", "in", ",", "0", ")", ",", "reg", ",", "modes_too", ")", ";", "return", "true", ";", "case", "REG", ":", "if", "(", "!", "reg", ")", "return", "false", ";", "if", "(", "modes_too", "&&", "(", "GET_MODE", "(", "in", ")", "!=", "GET_MODE", "(", "reg", ")", ")", ")", "return", "false", ";", "return", "(", "REGNO", "(", "in", ")", "==", "REGNO", "(", "reg", ")", ")", ";", "case", "SCRATCH", ":", "case", "CC0", ":", "case", "PC", ":", "case", "CONST_INT", ":", "case", "CONST_DOUBLE", ":", "return", "false", ";", "default", ":", "break", ";", "}", "if", "(", "code", "==", "SET", "&&", "!", "reg", ")", "return", "mep_mentioned_p", "(", "SET_DEST", "(", "in", ")", ",", "reg", ",", "modes_too", ")", ";", "fmt", "=", "GET_RTX_FORMAT", "(", "code", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "code", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "register", "int", "j", ";", "for", "(", "j", "=", "XVECLEN", "(", "in", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "if", "(", "mep_mentioned_p", "(", "XVECEXP", "(", "in", ",", "i", ",", "j", ")", ",", "reg", ",", "modes_too", ")", ")", "return", "true", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'e'", "&&", "mep_mentioned_p", "(", "XEXP", "(", "in", ",", "i", ")", ",", "reg", ",", "modes_too", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Experimental", "Reorg", "."], "TS_V_token": ["mep", "0", "0", "0", "1", "0", "1", "0"], "File": "mep", "Func": "mep_mentioned_p", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32302, "Length": 304}
{"ground_truth": ["<s>", "bool", "mep_mov_ok", "(", "rtx", "*", "operands", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "int", "i", ";", "fprintf", "(", "stderr", ",", "\"mep_mov_ok %s %c=%c\\n\"", ",", "mode_name", "[", "mode", "]", ",", "mep_section_tag", "(", "operands", "[", "0", "]", ")", ",", "mep_section_tag", "(", "operands", "[", "1", "]", ")", ")", ";", "debug_rtx", "(", "operands", "[", "0", "]", ")", ";", "debug_rtx", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "HIGH", ")", "return", "false", ";", "if", "(", "mep_section_tag", "(", "operands", "[", "0", "]", ")", "==", "'f'", "||", "mep_section_tag", "(", "operands", "[", "1", "]", ")", "==", "'f'", ")", "{", "fprintf", "(", "stderr", ",", "\" - no, f\\n\"", ")", ";", "return", "false", ";", "}", "i", "=", "mep_section_tag", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "(", "i", "==", "'b'", "||", "i", "==", "'t'", ")", "&&", "!", "reload_completed", "&&", "!", "reload_in_progress", ")", "{", "fprintf", "(", "stderr", ",", "\" - no, bt\\n\"", ")", ";", "return", "false", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "2", ";", "i", "++", ")", "{", "rtx", "x", "=", "operands", "[", "i", "]", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SUBREG", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "REG", "&&", "!", "MEP_CONTROL_REG", "(", "x", ")", ")", "{", "fprintf", "(", "stderr", ",", "\" - ok\\n\"", ")", ";", "return", "true", ";", "}", "}", "fprintf", "(", "stderr", ",", "\" - no, no gen reg\\n\"", ")", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Cases", "where", "the", "pattern", "ca", "n't", "be", "made", "to", "use", "at", "all", "."], "TS_V_token": ["mep", "\"mep_mov_ok %s %c=%c\\n\"", "0", "1", "0", "1", "1", "0", "1", "\" - no, f\\n\"", "1", "\" - no, bt\\n\"", "0", "2", "0", "\" - ok\\n\"", "\" - no, no gen reg\\n\""], "File": "mep", "Func": "mep_mov_ok", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32303, "Length": 227}
{"ground_truth": ["<s>", "rtx", "mep_mulr_source", "(", "rtx_insn", "*", "insn", ",", "rtx", "dest", ",", "rtx", "src1", ",", "rtx", "src2", ")", "{", "if", "(", "rtx_equal_p", "(", "dest", ",", "src1", ")", ")", "return", "src2", ";", "else", "if", "(", "rtx_equal_p", "(", "dest", ",", "src2", ")", ")", "return", "src1", ";", "else", "{", "if", "(", "insn", "==", "0", ")", "emit_insn", "(", "gen_movsi", "(", "copy_rtx", "(", "dest", ")", ",", "src1", ")", ")", ";", "else", "emit_insn_before", "(", "gen_movsi", "(", "copy_rtx", "(", "dest", ")", ",", "src1", ")", ",", "insn", ")", ";", "return", "src2", ";", "}", "}", "</s>"], "natrual_language": ["Given", "three", "integer", "registers", "DEST", ",", "SRC1", "and", "SRC2", ",", "return", "an", "rtx", "X", "such", "that", "``", "mulr", "DEST", ",", "X", "''", "will", "calculate", "DEST", "=", "SRC1", "*", "SRC2", ".", "If", "a", "move", "is", "needed", ",", "emit", "it", "before", "INSN", "if", "INSN", "is", "nonnull", ",", "otherwise", "emit", "it", "at", "the", "end", "of", "the", "insn", "stream", "."], "TS_V_token": ["mep", "0"], "File": "mep", "Func": "mep_mulr_source", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32304, "Length": 84}
{"ground_truth": ["<s>", "bool", "mep_mul_hilo_bypass_p", "(", "rtx_insn", "*", "prev", ",", "rtx_insn", "*", "insn", ")", "{", "rtx", "pat", ";", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "pat", "=", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "!=", "SET", ")", "return", "false", ";", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "SET_SRC", "(", "pat", ")", ",", "NONCONST", ")", "{", "const_rtx", "x", "=", "*", "iter", ";", "if", "(", "REG_P", "(", "x", ")", "&&", "REGNO", "(", "x", ")", "!=", "LO_REGNO", "&&", "REGNO", "(", "x", ")", "!=", "HI_REGNO", "&&", "reg_set_p", "(", "x", ",", "prev", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", ",", "apart", "from", "HI/LO", ",", "there", "are", "no", "true", "dependencies", "between", "multiplication", "instructions", "PREV", "and", "INSN", "."], "TS_V_token": ["mep", "0", "0"], "File": "mep", "Func": "mep_mul_hilo_bypass_p", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32305, "Length": 115}
{"ground_truth": ["<s>", "enum", "reg_class", "mep_preferred_reload_class", "(", "rtx", "x", ",", "enum", "reg_class", "rclass", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST_INT", ":", "if", "(", "INTVAL", "(", "x", ")", ">=", "0x10000", "&&", "INTVAL", "(", "x", ")", "<", "0x01000000", "&&", "(", "INTVAL", "(", "x", ")", "&", "0xffff", ")", "!=", "0", "&&", "reg_class_subset_p", "(", "TPREL_REGS", ",", "rclass", ")", ")", "rclass", "=", "TPREL_REGS", ";", "break", ";", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "if", "(", "mep_section_tag", "(", "x", ")", "!=", "'f'", "&&", "reg_class_subset_p", "(", "TPREL_REGS", ",", "rclass", ")", ")", "rclass", "=", "TPREL_REGS", ";", "break", ";", "default", ":", "break", ";", "}", "return", "rclass", ";", "}", "</s>"], "natrual_language": ["Implement", "PREFERRED_RELOAD_CLASS", ".", "See", "whether", "X", "is", "a", "constant", "that", "can", "be", "moved", "directly", "into", "registers", "0", "to", "7", ",", "but", "not", "into", "the", "rest", ".", "If", "so", ",", "and", "if", "the", "required", "class", "includes", "registers", "0", "to", "7", ",", "restrict", "it", "to", "those", "registers", "."], "TS_V_token": ["mep", "0x10000", "0x01000000", "0xffff", "0"], "File": "mep", "Func": "mep_preferred_reload_class", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32306, "Length": 103}
{"ground_truth": ["<s>", "void", "mep_print_operand_address", "(", "FILE", "*", "stream", ",", "rtx", "address", ")", "{", "if", "(", "GET_CODE", "(", "address", ")", "==", "MEM", ")", "address", "=", "XEXP", "(", "address", ",", "0", ")", ";", "else", "gcc_assert", "(", "GET_CODE", "(", "address", ")", "==", "REG", ")", ";", "mep_print_operand", "(", "stream", ",", "address", ",", "0", ")", ";", "}", "</s>"], "natrual_language": ["Operand", "Printing", "."], "TS_V_token": ["mep", "0", "0"], "File": "mep", "Func": "mep_print_operand_address", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32307, "Length": 50}
{"ground_truth": ["<s>", "int", "mep_register_move_cost", "(", "machine_mode", "mode", ",", "enum", "reg_class", "from", ",", "enum", "reg_class", "to", ")", "{", "if", "(", "mep_have_copro_copro_moves_p", "&&", "reg_class_subset_p", "(", "from", ",", "CR_REGS", ")", "&&", "reg_class_subset_p", "(", "to", ",", "CR_REGS", ")", ")", "{", "if", "(", "TARGET_32BIT_CR_REGS", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", ")", "return", "4", ";", "return", "2", ";", "}", "if", "(", "reg_class_subset_p", "(", "from", ",", "CR_REGS", ")", "&&", "reg_class_subset_p", "(", "to", ",", "CR_REGS", ")", ")", "{", "if", "(", "TARGET_32BIT_CR_REGS", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", ")", "return", "8", ";", "return", "4", ";", "}", "if", "(", "reg_class_subset_p", "(", "from", ",", "CR_REGS", ")", "||", "reg_class_subset_p", "(", "to", ",", "CR_REGS", ")", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", ")", "return", "4", ";", "return", "2", ";", "}", "if", "(", "mep_secondary_memory_needed", "(", "from", ",", "to", ",", "mode", ")", ")", "return", "1000", ";", "if", "(", "MEP_NONGENERAL_CLASS", "(", "from", ")", "&&", "MEP_NONGENERAL_CLASS", "(", "to", ")", ")", "return", "1000", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "4", ")", "return", "4", ";", "return", "2", ";", "}", "</s>"], "natrual_language": ["Implement", "REGISTER_MOVE_COST", ".", "Return", "2", "for", "direct", "single-register", "moves", ",", "4", "for", "direct", "double-register", "moves", ",", "and", "1000", "for", "anything", "that", "requires", "a", "temporary", "register", "or", "temporary", "stack", "slot", "."], "TS_V_token": ["mep", "4", "2", "8", "4", "4", "2", "1000", "1000", "4", "4", "2"], "File": "mep", "Func": "mep_register_move_cost", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32308, "Length": 165}
{"ground_truth": ["<s>", "static", "bool", "mep_reg_set_p", "(", "rtx", "reg", ",", "rtx", "insn", ")", "{", "if", "(", "INSN_P", "(", "insn", ")", ")", "{", "if", "(", "FIND_REG_INC_NOTE", "(", "insn", ",", "reg", ")", ")", "return", "true", ";", "insn", "=", "PATTERN", "(", "insn", ")", ";", "}", "if", "(", "GET_CODE", "(", "insn", ")", "==", "SET", "&&", "GET_CODE", "(", "XEXP", "(", "insn", ",", "0", ")", ")", "==", "REG", "&&", "GET_CODE", "(", "XEXP", "(", "insn", ",", "1", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "insn", ",", "0", ")", ")", "==", "REGNO", "(", "XEXP", "(", "insn", ",", "1", ")", ")", ")", "return", "false", ";", "return", "set_of", "(", "reg", ",", "insn", ")", "!=", "NULL_RTX", ";", "}", "</s>"], "natrual_language": ["Frame/Epilog/Prolog", "Related", "."], "TS_V_token": ["mep", "0", "1", "0", "1"], "File": "mep", "Func": "mep_reg_set_p", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32309, "Length": 106}
{"ground_truth": ["<s>", "static", "void", "mep_reload_pointer", "(", "int", "regno", ",", "const", "char", "*", "symbol", ")", "{", "rtx", "reg", ",", "sym", ";", "if", "(", "!", "df_regs_ever_live_p", "(", "regno", ")", "&&", "crtl", "->", "is_leaf", ")", "return", ";", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "sym", "=", "gen_rtx_SYMBOL_REF", "(", "SImode", ",", "symbol", ")", ";", "emit_insn", "(", "gen_movsi_topsym_s", "(", "reg", ",", "sym", ")", ")", ";", "emit_insn", "(", "gen_movsi_botsym_s", "(", "reg", ",", "reg", ",", "sym", ")", ")", ";", "}", "</s>"], "natrual_language": ["Used", "for", "interrupt", "functions", ",", "which", "ca", "n't", "assume", "that", "$", "tp", "and", "$", "gp", "contain", "the", "correct", "pointers", "."], "TS_V_token": ["mep"], "File": "mep", "Func": "mep_reload_pointer", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32310, "Length": 73}
{"ground_truth": ["<s>", "static", "void", "mep_reorg_noframe", "(", "rtx_insn", "*", "insns", ")", "{", "rtx_insn", "*", "start_frame_insn", ";", "rtx_insn", "*", "end_frame_insn", "=", "0", ";", "int", "sp_adjust", ",", "sp2", ";", "rtx", "sp", ";", "while", "(", "insns", "&&", "!", "INSN_P", "(", "insns", ")", ")", "insns", "=", "NEXT_INSN", "(", "insns", ")", ";", "if", "(", "!", "insns", ")", "return", ";", "sp_adjust", "=", "add_sp_insn_p", "(", "insns", ")", ";", "if", "(", "sp_adjust", "==", "0", ")", "return", ";", "start_frame_insn", "=", "insns", ";", "sp", "=", "SET_DEST", "(", "PATTERN", "(", "start_frame_insn", ")", ")", ";", "insns", "=", "next_real_insn", "(", "insns", ")", ";", "while", "(", "insns", ")", "{", "rtx_insn", "*", "next", "=", "next_real_insn", "(", "insns", ")", ";", "if", "(", "!", "next", ")", "break", ";", "sp2", "=", "add_sp_insn_p", "(", "insns", ")", ";", "if", "(", "sp2", ")", "{", "if", "(", "end_frame_insn", ")", "return", ";", "end_frame_insn", "=", "insns", ";", "if", "(", "sp2", "!=", "-", "sp_adjust", ")", "return", ";", "}", "else", "if", "(", "mep_mentioned_p", "(", "insns", ",", "sp", ",", "0", ")", ")", "return", ";", "else", "if", "(", "CALL_P", "(", "insns", ")", ")", "return", ";", "insns", "=", "next", ";", "}", "if", "(", "end_frame_insn", ")", "{", "delete_insn", "(", "start_frame_insn", ")", ";", "delete_insn", "(", "end_frame_insn", ")", ";", "}", "}", "</s>"], "natrual_language": ["Check", "for", "trivial", "functions", "that", "set", "up", "an", "unneeded", "stack", "frame", "."], "TS_V_token": ["mep", "0", "0", "0"], "File": "mep", "Func": "mep_reorg_noframe", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32311, "Length": 186}
{"ground_truth": ["<s>", "static", "bool", "mep_repeat_loop_p", "(", "struct", "mep_doloop", "*", "loop", ")", "{", "struct", "mep_doloop_end", "*", "end", ";", "rtx", "fallthrough", ";", "if", "(", "loop", "->", "begin", "==", "0", "||", "loop", "->", "end", "==", "0", "||", "loop", "->", "begin", "->", "next", "!=", "0", ")", "return", "false", ";", "if", "(", "prev_real_insn", "(", "loop", "->", "end", "->", "label", ")", "!=", "loop", "->", "begin", "->", "insn", ")", "return", "false", ";", "fallthrough", "=", "loop", "->", "end", "->", "fallthrough", ";", "for", "(", "end", "=", "loop", "->", "end", "->", "next", ";", "end", "!=", "0", ";", "end", "=", "end", "->", "next", ")", "if", "(", "end", "->", "label", "!=", "loop", "->", "end", "->", "label", "||", "!", "simplejump_p", "(", "end", "->", "fallthrough", ")", "||", "next_real_insn", "(", "JUMP_LABEL", "(", "end", "->", "fallthrough", ")", ")", "!=", "fallthrough", ")", "return", "false", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "LOOP", "can", "be", "converted", "into", "repeat/repeat_end", "form", "(", "that", "is", ",", "if", "it", "matches", "cases", "(", "1", ")", "or", "(", "2", ")", "above", ")", "."], "TS_V_token": ["mep", "0", "0", "0", "0"], "File": "mep", "Func": "mep_repeat_loop_p", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32312, "Length": 130}
{"ground_truth": ["<s>", "bool", "mep_reuse_lo_p", "(", "rtx", "lo", ",", "rtx", "gpr", ",", "rtx_insn", "*", "insn", ",", "bool", "gpr_dead_p", ")", "{", "bool", "result", "=", "mep_reuse_lo_p_1", "(", "lo", ",", "gpr", ",", "insn", ",", "gpr_dead_p", ")", ";", "extract_insn", "(", "insn", ")", ";", "return", "result", ";", "}", "</s>"], "natrual_language": ["A", "wrapper", "around", "mep_reuse_lo_p_1", "that", "preserves", "recog_data", "."], "TS_V_token": ["mep"], "File": "mep", "Func": "mep_reuse_lo_p", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32313, "Length": 40}
{"ground_truth": ["<s>", "static", "bool", "mep_reuse_lo_p_1", "(", "rtx", "lo", ",", "rtx", "gpr", ",", "rtx_insn", "*", "insn", ",", "bool", "gpr_dead_p", ")", "{", "do", "{", "insn", "=", "PREV_INSN", "(", "insn", ")", ";", "if", "(", "INSN_P", "(", "insn", ")", ")", "switch", "(", "recog_memoized", "(", "insn", ")", ")", "{", "case", "CODE_FOR_mulsi3_1", ":", "extract_insn", "(", "insn", ")", ";", "if", "(", "rtx_equal_p", "(", "recog_data", ".", "operand", "[", "0", "]", ",", "gpr", ")", ")", "{", "mep_rewrite_mulsi3", "(", "insn", ",", "gpr_dead_p", "?", "NULL", ":", "recog_data", ".", "operand", "[", "0", "]", ",", "recog_data", ".", "operand", "[", "1", "]", ",", "recog_data", ".", "operand", "[", "2", "]", ")", ";", "return", "true", ";", "}", "return", "false", ";", "case", "CODE_FOR_maddsi3", ":", "extract_insn", "(", "insn", ")", ";", "if", "(", "rtx_equal_p", "(", "recog_data", ".", "operand", "[", "0", "]", ",", "gpr", ")", ")", "{", "mep_rewrite_maddsi3", "(", "insn", ",", "gpr_dead_p", "?", "NULL", ":", "recog_data", ".", "operand", "[", "0", "]", ",", "recog_data", ".", "operand", "[", "1", "]", ",", "recog_data", ".", "operand", "[", "2", "]", ",", "recog_data", ".", "operand", "[", "3", "]", ")", ";", "return", "true", ";", "}", "return", "false", ";", "case", "CODE_FOR_mulsi3r", ":", "case", "CODE_FOR_maddsi3r", ":", "extract_insn", "(", "insn", ")", ";", "return", "rtx_equal_p", "(", "recog_data", ".", "operand", "[", "1", "]", ",", "gpr", ")", ";", "default", ":", "if", "(", "reg_set_p", "(", "lo", ",", "insn", ")", "||", "reg_set_p", "(", "gpr", ",", "insn", ")", "||", "volatile_insn_p", "(", "PATTERN", "(", "insn", ")", ")", ")", "return", "false", ";", "if", "(", "gpr_dead_p", "&&", "reg_referenced_p", "(", "gpr", ",", "PATTERN", "(", "insn", ")", ")", ")", "gpr_dead_p", "=", "false", ";", "break", ";", "}", "}", "while", "(", "!", "NOTE_INSN_BASIC_BLOCK_P", "(", "insn", ")", ")", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "$", "lo", "has", "the", "same", "value", "as", "integer", "register", "GPR", "when", "instruction", "INSN", "is", "reached", ".", "If", "necessary", ",", "rewrite", "the", "instruction", "that", "sets", "$", "lo", "so", "that", "it", "uses", "a", "proper", "SET", ",", "not", "a", "CLOBBER", ".", "LO", "is", "an", "rtx", "for", "(", "reg", ":", "SI", "LO_REGNO", ")", ".", "This", "function", "is", "intended", "to", "be", "used", "by", "the", "peephole2", "pass", ".", "Since", "that", "pass", "goes", "from", "the", "end", "of", "a", "basic", "block", "to", "the", "beginning", ",", "and", "propagates", "liveness", "information", "on", "the", "way", ",", "there", "is", "no", "need", "to", "update", "register", "notes", "here", ".", "If", "GPR_DEAD_P", "is", "true", "on", "entry", ",", "and", "this", "function", "returns", "true", ",", "then", "the", "caller", "will", "replace", "_every_", "use", "of", "GPR", "in", "and", "after", "INSN", "with", "LO", ".", "This", "means", "that", "if", "the", "instruction", "that", "sets", "$", "lo", "is", "a", "mulr-", "or", "maddr-type", "instruction", ",", "we", "can", "rewrite", "it", "to", "use", "mul", "or", "madd", "instead", ".", "In", "combination", "with", "the", "copy", "progagation", "pass", ",", "this", "allows", "us", "to", "replace", "sequences", "like", ":", "mov", "GPR", ",", "R1", "mulr", "GPR", ",", "R2", "with", ":", "mul", "R1", ",", "R2", "if", "GPR", "is", "no", "longer", "used", "."], "TS_V_token": ["mep", "0", "0", "1", "2", "0", "0", "1", "2", "3", "1"], "File": "mep", "Func": "mep_reuse_lo_p_1", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32314, "Length": 257}
{"ground_truth": ["<s>", "static", "void", "mep_rewrite_maddsi3", "(", "rtx_insn", "*", "insn", ",", "rtx", "dest", ",", "rtx", "src1", ",", "rtx", "src2", ",", "rtx", "src3", ")", "{", "rtx", "lo", ",", "pattern", ";", "lo", "=", "gen_rtx_REG", "(", "SImode", ",", "LO_REGNO", ")", ";", "emit_insn_before", "(", "gen_movsi", "(", "copy_rtx", "(", "lo", ")", ",", "src3", ")", ",", "insn", ")", ";", "if", "(", "dest", ")", "pattern", "=", "gen_maddsi3r", "(", "lo", ",", "dest", ",", "copy_rtx", "(", "dest", ")", ",", "mep_mulr_source", "(", "insn", ",", "dest", ",", "src1", ",", "src2", ")", ",", "copy_rtx", "(", "lo", ")", ")", ";", "else", "pattern", "=", "gen_maddsi3_lo", "(", "lo", ",", "src1", ",", "src2", ",", "copy_rtx", "(", "lo", ")", ")", ";", "mep_rewrite_mult", "(", "insn", ",", "pattern", ")", ";", "}", "</s>"], "natrual_language": ["Like", "mep_rewrite_mulsi3", ",", "but", "calculate", "SRC1", "*", "SRC2", "+", "SRC3", ".", "First", "copy", "SRC3", "into", "$", "lo", ",", "then", "use", "either", "madd", "or", "maddr", ".", "The", "move", "into", "$", "lo", "will", "be", "deleted", "by", "a", "peephole2", "if", "SRC3", "is", "already", "in", "$", "lo", "."], "TS_V_token": ["mep"], "File": "mep", "Func": "mep_rewrite_maddsi3", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32315, "Length": 109}
{"ground_truth": ["<s>", "static", "void", "mep_rewrite_mulsi3", "(", "rtx_insn", "*", "insn", ",", "rtx", "dest", ",", "rtx", "src1", ",", "rtx", "src2", ")", "{", "rtx", "lo", ",", "pattern", ";", "lo", "=", "gen_rtx_REG", "(", "SImode", ",", "LO_REGNO", ")", ";", "if", "(", "dest", ")", "pattern", "=", "gen_mulsi3r", "(", "lo", ",", "dest", ",", "copy_rtx", "(", "dest", ")", ",", "mep_mulr_source", "(", "insn", ",", "dest", ",", "src1", ",", "src2", ")", ")", ";", "else", "pattern", "=", "gen_mulsi3_lo", "(", "lo", ",", "src1", ",", "src2", ")", ";", "mep_rewrite_mult", "(", "insn", ",", "pattern", ")", ";", "}", "</s>"], "natrual_language": ["Subroutine", "of", "mep_reuse_lo_p", ".", "Rewrite", "instruction", "INSN", "so", "that", "it", "calculates", "SRC1", "*", "SRC2", "and", "stores", "the", "result", "in", "$", "lo", ".", "Also", "make", "it", "store", "the", "result", "in", "DEST", "if", "nonnull", "."], "TS_V_token": ["mep"], "File": "mep", "Func": "mep_rewrite_mulsi3", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32316, "Length": 81}
{"ground_truth": ["<s>", "static", "void", "mep_rewrite_mult", "(", "rtx_insn", "*", "insn", ",", "rtx", "pattern", ")", "{", "rtx", "hi_clobber", ";", "hi_clobber", "=", "XVECEXP", "(", "pattern", ",", "0", ",", "XVECLEN", "(", "pattern", ",", "0", ")", "-", "1", ")", ";", "XEXP", "(", "hi_clobber", ",", "0", ")", "=", "gen_rtx_REG", "(", "SImode", ",", "HI_REGNO", ")", ";", "PATTERN", "(", "insn", ")", "=", "pattern", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "}", "</s>"], "natrual_language": ["Replace", "INSN", "'s", "pattern", "with", "PATTERN", ",", "a", "multiplication", "PARALLEL", ".", "Change", "the", "last", "element", "of", "PATTERN", "from", "(", "clobber", "(", "scratch", ":", "SI", ")", ")", "to", "(", "clobber", "(", "reg", ":", "SI", "HI_REGNO", ")", ")", "."], "TS_V_token": ["mep", "0", "0", "1", "0", "1"], "File": "mep", "Func": "mep_rewrite_mult", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32317, "Length": 63}
{"ground_truth": ["<s>", "void", "mep_save_register_info", "(", "void", ")", "{", "save_register_info", "(", ")", ";", "}", "</s>"], "natrual_language": ["These", "three", "functions", "provide", "a", "bridge", "between", "the", "pramgas", "that", "affect", "register", "classes", ",", "and", "the", "functions", "that", "maintain", "them", ".", "We", "ca", "n't", "call", "those", "functions", "directly", "as", "pragma", "handling", "is", "part", "of", "the", "front", "end", "and", "does", "n't", "have", "direct", "access", "to", "them", "."], "TS_V_token": ["mep"], "File": "mep", "Func": "mep_save_register_info", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32318, "Length": 11}
{"ground_truth": ["<s>", "static", "enum", "reg_class", "mep_secondary_copro_reload_class", "(", "enum", "reg_class", "rclass", ",", "rtx", "x", ")", "{", "if", "(", "mep_general_reg", "(", "x", ")", ")", "return", "NO_REGS", ";", "if", "(", "mep_general_copro_reg", "(", "x", ")", ")", "{", "if", "(", "mep_have_copro_copro_moves_p", ")", "return", "NO_REGS", ";", "if", "(", "mep_have_core_copro_moves_p", ")", "return", "GENERAL_REGS", ";", "return", "NO_REGS", ";", "}", "if", "(", "reg_class_subset_p", "(", "rclass", ",", "LOADABLE_CR_REGS", ")", "&&", "constraint_satisfied_p", "(", "x", ",", "CONSTRAINT_U", ")", ")", "return", "NO_REGS", ";", "return", "GENERAL_REGS", ";", "}", "</s>"], "natrual_language": ["Return", "the", "secondary", "reload", "class", "needed", "for", "moving", "value", "X", "to", "or", "from", "a", "register", "in", "coprocessor", "register", "class", "CLASS", "."], "TS_V_token": ["mep"], "File": "mep", "Func": "mep_secondary_copro_reload_class", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32319, "Length": 72}
{"ground_truth": ["<s>", "enum", "reg_class", "mep_secondary_input_reload_class", "(", "enum", "reg_class", "rclass", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ")", "{", "int", "rv", "=", "NO_REGS", ";", "fprintf", "(", "stderr", ",", "\"secondary input reload copy to %s %s from \"", ",", "reg_class_names", "[", "rclass", "]", ",", "mode_name", "[", "mode", "]", ")", ";", "debug_rtx", "(", "x", ")", ";", "if", "(", "reg_class_subset_p", "(", "rclass", ",", "CR_REGS", ")", ")", "rv", "=", "mep_secondary_copro_reload_class", "(", "rclass", ",", "x", ")", ";", "else", "if", "(", "MEP_NONGENERAL_CLASS", "(", "rclass", ")", "&&", "(", "mep_nonregister", "(", "x", ")", "||", "mep_nongeneral_reg", "(", "x", ")", ")", ")", "rv", "=", "GENERAL_REGS", ";", "fprintf", "(", "stderr", ",", "\" - requires %s\\n\"", ",", "reg_class_names", "[", "rv", "]", ")", ";", "return", "(", "enum", "reg_class", ")", "rv", ";", "}", "</s>"], "natrual_language": ["Copying", "X", "to", "register", "in", "RCLASS", "."], "TS_V_token": ["mep", "\"secondary input reload copy to %s %s from \"", "\" - requires %s\\n\""], "File": "mep", "Func": "mep_secondary_input_reload_class", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32320, "Length": 105}
{"ground_truth": ["<s>", "bool", "mep_secondary_memory_needed", "(", "enum", "reg_class", "rclass1", ",", "enum", "reg_class", "rclass2", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "!", "mep_have_core_copro_moves_p", ")", "{", "if", "(", "reg_classes_intersect_p", "(", "rclass1", ",", "CR_REGS", ")", "&&", "reg_classes_intersect_p", "(", "rclass2", ",", "GENERAL_REGS", ")", ")", "return", "true", ";", "if", "(", "reg_classes_intersect_p", "(", "rclass2", ",", "CR_REGS", ")", "&&", "reg_classes_intersect_p", "(", "rclass1", ",", "GENERAL_REGS", ")", ")", "return", "true", ";", "if", "(", "!", "mep_have_copro_copro_moves_p", "&&", "reg_classes_intersect_p", "(", "rclass1", ",", "CR_REGS", ")", "&&", "reg_classes_intersect_p", "(", "rclass2", ",", "CR_REGS", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Implement", "SECONDARY_MEMORY_NEEDED", "."], "TS_V_token": ["mep"], "File": "mep", "Func": "mep_secondary_memory_needed", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32321, "Length": 87}
{"ground_truth": ["<s>", "enum", "reg_class", "mep_secondary_output_reload_class", "(", "enum", "reg_class", "rclass", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ")", "{", "int", "rv", "=", "NO_REGS", ";", "fprintf", "(", "stderr", ",", "\"secondary output reload copy from %s %s to \"", ",", "reg_class_names", "[", "rclass", "]", ",", "mode_name", "[", "mode", "]", ")", ";", "debug_rtx", "(", "x", ")", ";", "if", "(", "reg_class_subset_p", "(", "rclass", ",", "CR_REGS", ")", ")", "rv", "=", "mep_secondary_copro_reload_class", "(", "rclass", ",", "x", ")", ";", "else", "if", "(", "MEP_NONGENERAL_CLASS", "(", "rclass", ")", "&&", "(", "mep_nonregister", "(", "x", ")", "||", "mep_nongeneral_reg", "(", "x", ")", ")", ")", "rv", "=", "GENERAL_REGS", ";", "fprintf", "(", "stderr", ",", "\" - requires %s\\n\"", ",", "reg_class_names", "[", "rv", "]", ")", ";", "return", "(", "enum", "reg_class", ")", "rv", ";", "}", "</s>"], "natrual_language": ["Copying", "register", "in", "RCLASS", "to", "X", "."], "TS_V_token": ["mep", "\"secondary output reload copy from %s %s to \"", "\" - requires %s\\n\""], "File": "mep", "Func": "mep_secondary_output_reload_class", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32322, "Length": 105}
{"ground_truth": ["<s>", "static", "void", "mep_setup_incoming_varargs", "(", "cumulative_args_t", "cum", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "tree", "type", "ATTRIBUTE_UNUSED", ",", "int", "*", "pretend_size", ",", "int", "second_time", "ATTRIBUTE_UNUSED", ")", "{", "int", "nsave", "=", "4", "-", "(", "get_cumulative_args", "(", "cum", ")", "->", "nregs", "+", "1", ")", ";", "if", "(", "nsave", ">", "0", ")", "cfun", "->", "machine", "->", "arg_regs_to_save", "=", "nsave", ";", "*", "pretend_size", "=", "nsave", "*", "4", ";", "}", "</s>"], "natrual_language": ["Function", "args", "in", "registers", "."], "TS_V_token": ["mep", "4", "1", "0", "4"], "File": "mep", "Func": "mep_setup_incoming_varargs", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32323, "Length": 62}
{"ground_truth": ["<s>", "static", "bool", "mep_store_data_bypass_1", "(", "rtx_insn", "*", "prev", ",", "rtx", "pat", ")", "{", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "pat", ",", "0", ")", ";", "i", "++", ")", "if", "(", "mep_store_data_bypass_p", "(", "prev", ",", "as_a", "<", "rtx_insn", "*", ">", "(", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "if", "(", "GET_CODE", "(", "pat", ")", "!=", "SET", "||", "GET_CODE", "(", "SET_DEST", "(", "pat", ")", ")", "!=", "MEM", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "pat", ")", ")", "==", "UNSPEC", ")", "{", "rtx", "src", ";", "int", "i", ";", "src", "=", "SET_SRC", "(", "pat", ")", ";", "for", "(", "i", "=", "1", ";", "i", "<", "XVECLEN", "(", "src", ",", "0", ")", ";", "i", "++", ")", "if", "(", "mep_store_find_set", "(", "XVECEXP", "(", "src", ",", "0", ",", "i", ")", ",", "prev", ")", ")", "return", "false", ";", "return", "true", ";", "}", "return", "!", "mep_store_find_set", "(", "SET_DEST", "(", "pat", ")", ",", "prev", ")", ";", "}", "</s>"], "natrual_language": ["Like", "mep_store_bypass_p", ",", "but", "takes", "a", "pattern", "as", "the", "second", "argument", ",", "not", "the", "containing", "insn", "."], "TS_V_token": ["mep", "0", "0", "0", "1", "0", "0"], "File": "mep", "Func": "mep_store_data_bypass_1", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32324, "Length": 175}
{"ground_truth": ["<s>", "bool", "mep_store_data_bypass_p", "(", "rtx_insn", "*", "prev", ",", "rtx_insn", "*", "insn", ")", "{", "return", "INSN_P", "(", "insn", ")", "?", "mep_store_data_bypass_1", "(", "prev", ",", "PATTERN", "(", "insn", ")", ")", ":", "false", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "INSN", "is", "a", "store", "instruction", "and", "if", "the", "store", "address", "has", "no", "true", "dependence", "on", "PREV", "."], "TS_V_token": ["mep"], "File": "mep", "Func": "mep_store_data_bypass_p", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32325, "Length": 31}
{"ground_truth": ["<s>", "static", "bool", "mep_store_find_set", "(", "const_rtx", "x", ",", "const", "rtx_insn", "*", "prev", ")", "{", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "x", ",", "NONCONST", ")", "if", "(", "REG_P", "(", "x", ")", "&&", "reg_set_p", "(", "x", ",", "prev", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "X", "contains", "a", "register", "that", "is", "set", "by", "insn", "PREV", "."], "TS_V_token": ["mep"], "File": "mep", "Func": "mep_store_find_set", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32326, "Length": 49}
{"ground_truth": ["<s>", "static", "void", "mep_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "static_chain", ")", "{", "rtx", "addr", "=", "XEXP", "(", "m_tramp", ",", "0", ")", ";", "rtx", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "emit_library_call", "(", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__mep_trampoline_helper\"", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "3", ",", "addr", ",", "Pmode", ",", "fnaddr", ",", "Pmode", ",", "static_chain", ",", "Pmode", ")", ";", "}", "</s>"], "natrual_language": ["Trampolines", "."], "TS_V_token": ["mep", "0", "0", "\"__mep_trampoline_helper\"", "3"], "File": "mep", "Func": "mep_trampoline_init", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32327, "Length": 66}
{"ground_truth": ["<s>", "static", "bool", "mep_use_post_modify_for_set_p", "(", "rtx", "set", ",", "rtx", "gpr", ",", "rtx", "offset", ")", "{", "rtx", "*", "reg", ",", "*", "mem", ";", "unsigned", "int", "reg_bytes", ",", "mem_bytes", ";", "machine_mode", "reg_mode", ",", "mem_mode", ";", "if", "(", "GET_CODE", "(", "set", ")", "!=", "SET", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "SET_DEST", "(", "set", ")", ")", "==", "MEM", ")", "{", "mem", "=", "&", "SET_DEST", "(", "set", ")", ";", "reg", "=", "&", "SET_SRC", "(", "set", ")", ";", "}", "else", "{", "reg", "=", "&", "SET_DEST", "(", "set", ")", ";", "mem", "=", "&", "SET_SRC", "(", "set", ")", ";", "if", "(", "GET_CODE", "(", "*", "mem", ")", "==", "SIGN_EXTEND", ")", "mem", "=", "&", "XEXP", "(", "*", "mem", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "*", "reg", ")", "!=", "REG", "||", "!", "LOADABLE_CR_REGNO_P", "(", "REGNO", "(", "*", "reg", ")", ")", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "*", "mem", ")", "!=", "MEM", "||", "!", "rtx_equal_p", "(", "XEXP", "(", "*", "mem", ",", "0", ")", ",", "gpr", ")", ")", "return", "false", ";", "mem_bytes", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "*", "mem", ")", ")", ";", "reg_bytes", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "*", "reg", ")", ")", ";", "if", "(", "INTVAL", "(", "offset", ")", "&", "(", "mem_bytes", "-", "1", ")", ")", "return", "false", ";", "mem_mode", "=", "mode_for_size", "(", "mem_bytes", "*", "BITS_PER_UNIT", ",", "MODE_INT", ",", "0", ")", ";", "*", "mem", "=", "change_address", "(", "*", "mem", ",", "mem_mode", ",", "NULL", ")", ";", "*", "reg", "=", "shallow_copy_rtx", "(", "*", "reg", ")", ";", "if", "(", "reg", "==", "&", "SET_DEST", "(", "set", ")", "&&", "reg_bytes", "<", "UNITS_PER_WORD", ")", "{", "PUT_MODE", "(", "*", "reg", ",", "SImode", ")", ";", "*", "mem", "=", "gen_rtx_SIGN_EXTEND", "(", "SImode", ",", "*", "mem", ")", ";", "}", "else", "{", "reg_mode", "=", "mode_for_size", "(", "reg_bytes", "*", "BITS_PER_UNIT", ",", "MODE_INT", ",", "0", ")", ";", "PUT_MODE", "(", "*", "reg", ",", "reg_mode", ")", ";", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "SET", "can", "be", "turned", "into", "a", "post-modify", "load", "or", "store", "that", "adds", "OFFSET", "to", "GPR", ".", "In", "other", "words", ",", "return", "true", "if", "SET", "can", "be", "changed", "into", ":", "(", "parallel", "[", "SET", "(", "set", "GPR", "(", "plus", ":", "SI", "GPR", "OFFSET", ")", ")", "]", ")", ".", "It", "'s", "OK", "to", "change", "SET", "to", "an", "equivalent", "operation", "in", "order", "to", "make", "it", "match", "."], "TS_V_token": ["mep", "0", "0", "1", "0", "0"], "File": "mep", "Func": "mep_use_post_modify_for_set_p", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32328, "Length": 300}
{"ground_truth": ["<s>", "bool", "mep_use_post_modify_p", "(", "rtx_insn", "*", "insn", ",", "rtx", "reg", ",", "rtx", "offset", ")", "{", "bool", "result", "=", "mep_use_post_modify_p_1", "(", "insn", ",", "reg", ",", "offset", ")", ";", "extract_insn", "(", "insn", ")", ";", "return", "result", ";", "}", "</s>"], "natrual_language": ["A", "wrapper", "around", "mep_use_post_modify_p_1", "that", "preserves", "recog_data", "."], "TS_V_token": ["mep"], "File": "mep", "Func": "mep_use_post_modify_p", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32329, "Length": 35}
{"ground_truth": ["<s>", "static", "bool", "mep_use_post_modify_p_1", "(", "rtx_insn", "*", "set_insn", ",", "rtx", "reg", ",", "rtx", "offset", ")", "{", "rtx_insn", "*", "insn", ";", "insn", "=", "set_insn", ";", "do", "{", "insn", "=", "PREV_INSN", "(", "insn", ")", ";", "if", "(", "INSN_P", "(", "insn", ")", ")", "{", "if", "(", "mep_use_post_modify_for_set_p", "(", "PATTERN", "(", "insn", ")", ",", "reg", ",", "offset", ")", ")", "{", "mep_make_parallel", "(", "insn", ",", "set_insn", ")", ";", "return", "true", ";", "}", "if", "(", "reg_set_p", "(", "reg", ",", "insn", ")", "||", "reg_referenced_p", "(", "reg", ",", "PATTERN", "(", "insn", ")", ")", "||", "volatile_insn_p", "(", "PATTERN", "(", "insn", ")", ")", ")", "return", "false", ";", "}", "}", "while", "(", "!", "NOTE_INSN_BASIC_BLOCK_P", "(", "insn", ")", ")", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["SET_INSN", "is", "an", "instruction", "that", "adds", "OFFSET", "to", "REG", ".", "Go", "back", "through", "the", "basic", "block", "to", "see", "if", "any", "previous", "load", "or", "store", "instruction", "can", "be", "persuaded", "to", "do", "SET_INSN", "as", "a", "side-effect", ".", "Return", "true", "if", "so", "."], "TS_V_token": ["mep"], "File": "mep", "Func": "mep_use_post_modify_p_1", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32330, "Length": 111}
{"ground_truth": ["<s>", "static", "tree", "mep_validate_based_tiny", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "VAR_DECL", "&&", "TREE_CODE", "(", "*", "node", ")", "!=", "POINTER_TYPE", "&&", "TREE_CODE", "(", "*", "node", ")", "!=", "TYPE_DECL", ")", "{", "warning", "(", "0", ",", "\"%qE attribute only applies to variables\"", ",", "name", ")", ";", "*", "no_add", "=", "true", ";", "}", "else", "if", "(", "args", "==", "NULL_TREE", "&&", "TREE_CODE", "(", "*", "node", ")", "==", "VAR_DECL", ")", "{", "if", "(", "!", "(", "TREE_PUBLIC", "(", "*", "node", ")", "||", "TREE_STATIC", "(", "*", "node", ")", ")", ")", "{", "warning", "(", "0", ",", "\"address region attributes not allowed with auto storage class\"", ")", ";", "*", "no_add", "=", "true", ";", "}", "if", "(", "TREE_TYPE", "(", "*", "node", ")", "&&", "TREE_CODE", "(", "TREE_TYPE", "(", "*", "node", ")", ")", "==", "POINTER_TYPE", ")", "{", "warning", "(", "0", ",", "\"address region attributes on pointed-to types ignored\"", ")", ";", "*", "no_add", "=", "true", ";", "}", "}", "return", "NULL_TREE", ";", "}", "</s>"], "natrual_language": ["Handle", "attributes", "."], "TS_V_token": ["mep", "0", "\"%qE attribute only applies to variables\"", "0", "\"address region attributes not allowed with auto storage class\"", "0", "\"address region attributes on pointed-to types ignored\""], "File": "mep", "Func": "mep_validate_based_tiny", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32331, "Length": 150}
{"ground_truth": ["<s>", "bool", "mep_vliw_function_p", "(", "tree", "decl", ")", "{", "return", "lookup_attribute", "(", "\"vliw\"", ",", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "decl", ")", ")", ")", "!=", "0", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "function", "DECL", "was", "declared", "with", "the", "vliw", "attribute", "."], "TS_V_token": ["mep", "\"vliw\"", "0"], "File": "mep", "Func": "mep_vliw_function_p", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32332, "Length": 24}
{"ground_truth": ["<s>", "bool", "mep_vliw_jmp_match", "(", "rtx", "tgt", ")", "{", "bool", "src_vliw", "=", "mep_vliw_function_p", "(", "cfun", "->", "decl", ")", ";", "bool", "tgt_vliw", "=", "INTVAL", "(", "tgt", ")", ";", "if", "(", "mep_section_tag", "(", "DECL_RTL", "(", "cfun", "->", "decl", ")", ")", "==", "'f'", ")", "return", "false", ";", "return", "src_vliw", "==", "tgt_vliw", ";", "}", "</s>"], "natrual_language": ["Like", "the", "above", ",", "but", "also", "test", "for", "near/far", "mismatches", "."], "TS_V_token": ["mep"], "File": "mep", "Func": "mep_vliw_jmp_match", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32333, "Length": 48}
{"ground_truth": ["<s>", "bool", "mep_vliw_mode_match", "(", "rtx", "tgt", ")", "{", "bool", "src_vliw", "=", "mep_vliw_function_p", "(", "cfun", "->", "decl", ")", ";", "bool", "tgt_vliw", "=", "INTVAL", "(", "tgt", ")", ";", "return", "src_vliw", "==", "tgt_vliw", ";", "}", "</s>"], "natrual_language": ["Irritatingly", ",", "the", "``", "jsrv", "''", "insn", "*", "toggles", "*", "PSW.OM", "rather", "than", "set", "it", "to", "one", "specific", "value", ".", "So", "the", "insn", "chosen", "depends", "on", "whether", "the", "source", "and", "destination", "modes", "match", "."], "TS_V_token": ["mep"], "File": "mep", "Func": "mep_vliw_mode_match", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32334, "Length": 31}
{"ground_truth": ["<s>", "static", "bool", "symbol_p", "(", "rtx", "x", ")", "{", "int", "c", "=", "GET_CODE", "(", "x", ")", ";", "return", "(", "c", "==", "CONST_INT", "||", "c", "==", "CONST", "||", "c", "==", "SYMBOL_REF", ")", ";", "}", "</s>"], "natrual_language": ["MEP", "has", "very", "few", "instructions", "that", "can", "refer", "to", "the", "span", "of", "addresses", "used", "by", "symbols", ",", "so", "it", "'s", "common", "to", "check", "for", "them", "."], "TS_V_token": ["mep"], "File": "mep", "Func": "symbol_p", "Target": "mep", "Target_Clf": "CPU", "Compiler_Type": "GCC", "Idx": 32335, "Length": 32}