{"ground_truth": ["<s>", "int", "flags_in_68881", "(", ")", "{", "return", "cc_status", ".", "flags", "&", "CC_IN_68881", ";", "}", "</s>"], "natrual_language": ["Return", "nonzero", "if", "flags", "are", "currently", "in", "the", "68881", "flag", "register", "."], "TS_V_token": ["m68k"], "File": "m68k2", "Func": "flags_in_68881", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42619, "Length": 13}
{"ground_truth": ["<s>", "void", "init_68881_table", "(", ")", "{", "int", "i", ";", "REAL_VALUE_TYPE", "r", ";", "enum", "machine_mode", "mode", ";", "mode", "=", "SFmode", ";", "for", "(", "i", "=", "0", ";", "i", "<", "7", ";", "i", "++", ")", "{", "if", "(", "i", "==", "6", ")", "mode", "=", "DFmode", ";", "r", "=", "REAL_VALUE_ATOF", "(", "strings_68881", "[", "i", "]", ",", "mode", ")", ";", "values_68881", "[", "i", "]", "=", "r", ";", "}", "inited_68881_table", "=", "1", ";", "}", "</s>"], "natrual_language": ["Set", "up", "values_68881", "array", "by", "converting", "the", "decimal", "values", "strings_68881", "to", "binary", "."], "TS_V_token": ["m68k", "0", "7", "6", "1"], "File": "m68k2", "Func": "init_68881_table", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42620, "Length": 68}
{"ground_truth": ["<s>", "void", "override_options", "(", ")", "{", "int", "def_align", ";", "int", "i", ";", "def_align", "=", "1", ";", "m68k_align_loops", "=", "def_align", ";", "if", "(", "m68k_align_loops_string", ")", "{", "i", "=", "atoi", "(", "m68k_align_loops_string", ")", ";", "if", "(", "i", "<", "1", "||", "i", ">", "MAX_CODE_ALIGN", ")", "error", "(", "\"-malign-loops=%d is not between 1 and %d\"", ",", "i", ",", "MAX_CODE_ALIGN", ")", ";", "else", "m68k_align_loops", "=", "i", ";", "}", "m68k_align_jumps", "=", "def_align", ";", "if", "(", "m68k_align_jumps_string", ")", "{", "i", "=", "atoi", "(", "m68k_align_jumps_string", ")", ";", "if", "(", "i", "<", "1", "||", "i", ">", "MAX_CODE_ALIGN", ")", "error", "(", "\"-malign-jumps=%d is not between 1 and %d\"", ",", "i", ",", "MAX_CODE_ALIGN", ")", ";", "else", "m68k_align_jumps", "=", "i", ";", "}", "m68k_align_funcs", "=", "def_align", ";", "if", "(", "m68k_align_funcs_string", ")", "{", "i", "=", "atoi", "(", "m68k_align_funcs_string", ")", ";", "if", "(", "i", "<", "1", "||", "i", ">", "MAX_CODE_ALIGN", ")", "error", "(", "\"-malign-functions=%d is not between 1 and %d\"", ",", "i", ",", "MAX_CODE_ALIGN", ")", ";", "else", "m68k_align_funcs", "=", "i", ";", "}", "}", "</s>"], "natrual_language": ["Set", "global", "variables", "as", "needed", "for", "the", "options", "enabled", "."], "TS_V_token": ["m68k", "1", "1", "\"-malign-loops=%d is not between 1 and %d\"", "1", "\"-malign-jumps=%d is not between 1 and %d\"", "1", "\"-malign-functions=%d is not between 1 and %d\""], "File": "m68k2", "Func": "override_options", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42621, "Length": 139}
{"ground_truth": ["<s>", "int", "use_return_insn", "(", ")", "{", "int", "regno", ";", "if", "(", "!", "reload_completed", "||", "frame_pointer_needed", "||", "get_frame_size", "(", ")", "!=", "0", ")", "return", "0", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "regs_ever_live", "[", "regno", "]", "&&", "!", "call_used_regs", "[", "regno", "]", ")", "return", "0", ";", "if", "(", "flag_pic", "&&", "current_function_uses_pic_offset_table", ")", "return", "0", ";", "return", "1", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "this", "function", "'s", "epilogue", "can", "be", "output", "as", "RTL", "."], "TS_V_token": ["m68k", "0", "0", "0", "0", "0", "1"], "File": "m68k2", "Func": "use_return_insn", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42622, "Length": 66}
{"ground_truth": ["<s>", "static", "int", "const_int_cost", "(", "rtx", "constant", ")", "{", "switch", "(", "const_method", "(", "constant", ")", ")", "{", "case", "MOVQ", ":", "return", "0", ";", "case", "MVZ", ":", "case", "MVS", ":", "case", "NOTB", ":", "case", "NOTW", ":", "case", "NEGW", ":", "case", "SWAP", ":", "return", "1", ";", "case", "MOVL", ":", "return", "2", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Return", "the", "cost", "of", "moving", "constant", "I", "into", "a", "data", "register", "."], "TS_V_token": ["m68k", "0", "1", "2"], "File": "m68k3", "Func": "const_int_cost", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42623, "Length": 57}
{"ground_truth": ["<s>", "int", "flags_in_68881", "(", "void", ")", "{", "return", "cc_status", ".", "flags", "&", "CC_IN_68881", ";", "}", "</s>"], "natrual_language": ["Return", "nonzero", "if", "flags", "are", "currently", "in", "the", "68881", "flag", "register", "."], "TS_V_token": ["m68k"], "File": "m68k3", "Func": "flags_in_68881", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42624, "Length": 14}
{"ground_truth": ["<s>", "int", "floating_exact_log2", "(", "rtx", "x", ")", "{", "REAL_VALUE_TYPE", "r", ",", "r1", ";", "int", "exp", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "r", ",", "x", ")", ";", "if", "(", "REAL_VALUES_LESS", "(", "r", ",", "dconst1", ")", ")", "return", "0", ";", "exp", "=", "real_exponent", "(", "&", "r", ")", ";", "real_2expN", "(", "&", "r1", ",", "exp", ")", ";", "if", "(", "REAL_VALUES_EQUAL", "(", "r1", ",", "r", ")", ")", "return", "exp", ";", "return", "0", ";", "}", "</s>"], "natrual_language": ["If", "X", "is", "a", "floating-point", "constant", ",", "return", "the", "logarithm", "of", "X", "base", "2", ",", "or", "0", "if", "X", "is", "not", "a", "power", "of", "2", "."], "TS_V_token": ["m68k", "0", "0"], "File": "m68k3", "Func": "floating_exact_log2", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42625, "Length": 66}
{"ground_truth": ["<s>", "void", "init_68881_table", "(", "void", ")", "{", "int", "i", ";", "REAL_VALUE_TYPE", "r", ";", "enum", "machine_mode", "mode", ";", "mode", "=", "SFmode", ";", "for", "(", "i", "=", "0", ";", "i", "<", "7", ";", "i", "++", ")", "{", "if", "(", "i", "==", "6", ")", "mode", "=", "DFmode", ";", "r", "=", "REAL_VALUE_ATOF", "(", "strings_68881", "[", "i", "]", ",", "mode", ")", ";", "values_68881", "[", "i", "]", "=", "r", ";", "}", "inited_68881_table", "=", "1", ";", "}", "</s>"], "natrual_language": ["Set", "up", "values_68881", "array", "by", "converting", "the", "decimal", "values", "strings_68881", "to", "binary", "."], "TS_V_token": ["m68k", "0", "7", "6", "1"], "File": "m68k3", "Func": "init_68881_table", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42626, "Length": 69}
{"ground_truth": ["<s>", "rtx", "legitimize_pic_address", "(", "rtx", "orig", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "reg", ")", "{", "rtx", "pic_ref", "=", "orig", ";", "if", "(", "GET_CODE", "(", "orig", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "orig", ")", "==", "LABEL_REF", ")", "{", "gcc_assert", "(", "reg", ")", ";", "pic_ref", "=", "gen_rtx_MEM", "(", "Pmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "pic_offset_table_rtx", ",", "orig", ")", ")", ";", "current_function_uses_pic_offset_table", "=", "1", ";", "MEM_READONLY_P", "(", "pic_ref", ")", "=", "1", ";", "emit_move_insn", "(", "reg", ",", "pic_ref", ")", ";", "return", "reg", ";", "}", "else", "if", "(", "GET_CODE", "(", "orig", ")", "==", "CONST", ")", "{", "rtx", "base", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "orig", ",", "0", ")", ")", "==", "PLUS", "&&", "XEXP", "(", "XEXP", "(", "orig", ",", "0", ")", ",", "0", ")", "==", "pic_offset_table_rtx", ")", "return", "orig", ";", "gcc_assert", "(", "reg", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "orig", ",", "0", ")", ")", "==", "PLUS", ")", ";", "base", "=", "legitimize_pic_address", "(", "XEXP", "(", "XEXP", "(", "orig", ",", "0", ")", ",", "0", ")", ",", "Pmode", ",", "reg", ")", ";", "orig", "=", "legitimize_pic_address", "(", "XEXP", "(", "XEXP", "(", "orig", ",", "0", ")", ",", "1", ")", ",", "Pmode", ",", "base", "==", "reg", "?", "0", ":", "reg", ")", ";", "if", "(", "GET_CODE", "(", "orig", ")", "==", "CONST_INT", ")", "return", "plus_constant", "(", "base", ",", "INTVAL", "(", "orig", ")", ")", ";", "pic_ref", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "base", ",", "orig", ")", ";", "}", "return", "pic_ref", ";", "}", "</s>"], "natrual_language": ["Legitimize", "PIC", "addresses", ".", "If", "the", "address", "is", "already", "position-independent", ",", "we", "return", "ORIG", ".", "Newly", "generated", "position-independent", "addresses", "go", "into", "a", "reg", ".", "This", "is", "REG", "if", "nonzero", ",", "otherwise", "we", "allocate", "register", "(", "s", ")", "as", "necessary", "."], "TS_V_token": ["m68k", "1", "1", "0", "0", "0", "0", "0", "0", "0", "1", "0"], "File": "m68k3", "Func": "legitimize_pic_address", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42627, "Length": 229}
{"ground_truth": ["<s>", "static", "void", "m68k_coff_asm_named_section", "(", "const", "char", "*", "name", ",", "unsigned", "int", "flags", ",", "tree", "decl", "ATTRIBUTE_UNUSED", ")", "{", "char", "flagchar", ";", "if", "(", "flags", "&", "SECTION_WRITE", ")", "flagchar", "=", "'d'", ";", "else", "flagchar", "=", "'x'", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.section\\t%s,\\\"%c\\\"\\n\"", ",", "name", ",", "flagchar", ")", ";", "}", "</s>"], "natrual_language": ["Output", "assembly", "to", "switch", "to", "section", "NAME", "with", "attribute", "FLAGS", "."], "TS_V_token": ["m68k", "\"\\t.section\\t%s,\\\"%c\\\"\\n\""], "File": "m68k3", "Func": "m68k_coff_asm_named_section", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42628, "Length": 48}
{"ground_truth": ["<s>", "static", "tree", "m68k_handle_fndecl_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_DECL", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qs attribute only applies to functions\"", ",", "IDENTIFIER_POINTER", "(", "name", ")", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>"], "natrual_language": ["Handle", "an", "attribute", "requiring", "a", "FUNCTION_DECL", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "."], "TS_V_token": ["m68k", "\"%qs attribute only applies to functions\""], "File": "m68k3", "Func": "m68k_handle_fndecl_attribute", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42629, "Length": 57}
{"ground_truth": ["<s>", "static", "bool", "m68k_handle_option", "(", "size_t", "code", ",", "const", "char", "*", "arg", ",", "int", "value", ")", "{", "switch", "(", "code", ")", "{", "case", "OPT_m5200", ":", "target_flags", "&=", "~", "(", "MASK_ALL_CPU_BITS", "|", "MASK_68881", ")", ";", "target_flags", "|=", "MASK_5200", ";", "return", "true", ";", "case", "OPT_m5206e", ":", "target_flags", "&=", "~", "(", "MASK_ALL_CPU_BITS", "|", "MASK_68881", ")", ";", "target_flags", "|=", "MASK_5200", "|", "MASK_CF_HWDIV", ";", "return", "true", ";", "case", "OPT_m528x", ":", "target_flags", "&=", "~", "(", "MASK_ALL_CPU_BITS", "|", "MASK_68881", ")", ";", "target_flags", "|=", "MASK_528x", "|", "MASK_CF_HWDIV", ";", "return", "true", ";", "case", "OPT_m5307", ":", "target_flags", "&=", "~", "(", "MASK_ALL_CPU_BITS", "|", "MASK_68881", ")", ";", "target_flags", "|=", "MASK_CFV3", "|", "MASK_CF_HWDIV", ";", "return", "true", ";", "case", "OPT_m5407", ":", "target_flags", "&=", "~", "(", "MASK_ALL_CPU_BITS", "|", "MASK_68881", ")", ";", "target_flags", "|=", "MASK_CFV4", "|", "MASK_CF_HWDIV", ";", "return", "true", ";", "case", "OPT_m68000", ":", "case", "OPT_mc68000", ":", "target_flags", "&=", "~", "(", "MASK_ALL_CPU_BITS", "|", "MASK_68881", ")", ";", "return", "true", ";", "case", "OPT_m68020", ":", "case", "OPT_mc68020", ":", "target_flags", "&=", "~", "MASK_ALL_CPU_BITS", ";", "target_flags", "|=", "MASK_68020", "|", "MASK_BITFIELD", ";", "return", "true", ";", "case", "OPT_m68020_40", ":", "target_flags", "&=", "~", "MASK_ALL_CPU_BITS", ";", "target_flags", "|=", "MASK_BITFIELD", "|", "MASK_68881", "|", "MASK_68020", "|", "MASK_68040", ";", "return", "true", ";", "case", "OPT_m68020_60", ":", "target_flags", "&=", "~", "MASK_ALL_CPU_BITS", ";", "target_flags", "|=", "(", "MASK_BITFIELD", "|", "MASK_68881", "|", "MASK_68020", "|", "MASK_68040", "|", "MASK_68060", ")", ";", "return", "true", ";", "case", "OPT_m68030", ":", "target_flags", "&=", "~", "MASK_ALL_CPU_BITS", ";", "target_flags", "|=", "MASK_68020", "|", "MASK_68030", "|", "MASK_BITFIELD", ";", "return", "true", ";", "case", "OPT_m68040", ":", "target_flags", "&=", "~", "MASK_ALL_CPU_BITS", ";", "target_flags", "|=", "(", "MASK_68020", "|", "MASK_68881", "|", "MASK_BITFIELD", "|", "MASK_68040_ONLY", "|", "MASK_68040", ")", ";", "return", "true", ";", "case", "OPT_m68060", ":", "target_flags", "&=", "~", "MASK_ALL_CPU_BITS", ";", "target_flags", "|=", "(", "MASK_68020", "|", "MASK_68881", "|", "MASK_BITFIELD", "|", "MASK_68040_ONLY", "|", "MASK_68060", ")", ";", "return", "true", ";", "case", "OPT_m68302", ":", "target_flags", "&=", "~", "(", "MASK_ALL_CPU_BITS", "|", "MASK_68881", ")", ";", "return", "true", ";", "case", "OPT_m68332", ":", "case", "OPT_mcpu32", ":", "target_flags", "&=", "~", "(", "MASK_ALL_CPU_BITS", "|", "MASK_68881", ")", ";", "target_flags", "|=", "MASK_68020", ";", "return", "true", ";", "case", "OPT_mshared_library_id_", ":", "if", "(", "value", ">", "MAX_LIBRARY_ID", ")", "error", "(", "\"-mshared-library-id=%s is not between 0 and %d\"", ",", "arg", ",", "MAX_LIBRARY_ID", ")", ";", "else", "asprintf", "(", "(", "char", "*", "*", ")", "&", "m68k_library_id_string", ",", "\"%d\"", ",", "(", "value", "*", "-", "4", ")", "-", "4", ")", ";", "return", "true", ";", "default", ":", "return", "true", ";", "}", "}", "</s>"], "natrual_language": ["Implement", "TARGET_HANDLE_OPTION", "."], "TS_V_token": ["m68k", "\"-mshared-library-id=%s is not between 0 and %d\"", "\"%d\"", "4", "4"], "File": "m68k3", "Func": "m68k_handle_option", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42630, "Length": 365}
{"ground_truth": ["<s>", "int", "m68k_hard_regno_rename_ok", "(", "unsigned", "int", "old_reg", "ATTRIBUTE_UNUSED", ",", "unsigned", "int", "new_reg", ")", "{", "if", "(", "m68k_interrupt_function_p", "(", "current_function_decl", ")", "&&", "!", "regs_ever_live", "[", "new_reg", "]", ")", "return", "0", ";", "return", "1", ";", "}", "</s>"], "natrual_language": ["Return", "nonzero", "if", "register", "old_reg", "can", "be", "renamed", "to", "register", "new_reg", "."], "TS_V_token": ["m68k", "0", "1"], "File": "m68k3", "Func": "m68k_hard_regno_rename_ok", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42631, "Length": 33}
{"ground_truth": ["<s>", "static", "bool", "m68k_interrupt_function_p", "(", "tree", "func", ")", "{", "tree", "a", ";", "if", "(", "TREE_CODE", "(", "func", ")", "!=", "FUNCTION_DECL", ")", "return", "false", ";", "a", "=", "lookup_attribute", "(", "\"interrupt_handler\"", ",", "DECL_ATTRIBUTES", "(", "func", ")", ")", ";", "return", "(", "a", "!=", "NULL_TREE", ")", ";", "}", "</s>"], "natrual_language": ["Return", "nonzero", "if", "FUNC", "is", "an", "interrupt", "function", "as", "specified", "by", "the", "``", "interrupt_handler", "''", "attribute", "."], "TS_V_token": ["m68k", "\"interrupt_handler\""], "File": "m68k3", "Func": "m68k_interrupt_function_p", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42632, "Length": 43}
{"ground_truth": ["<s>", "void", "m68k_output_pic_call", "(", "rtx", "dest", ")", "{", "const", "char", "*", "out", ";", "if", "(", "!", "(", "GET_CODE", "(", "dest", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "dest", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", ")", "out", "=", "\"jsr %0\"", ";", "else", "if", "(", "TARGET_PCREL", ")", "out", "=", "\"bsr.l %o0\"", ";", "else", "if", "(", "TARGET_68020", ")", "out", "=", "\"bsr.l %0@PLTPC\"", ";", "out", "=", "\"bsr %0@PLTPC\"", ";", "else", "if", "(", "optimize_size", "||", "TARGET_ID_SHARED_LIBRARY", ")", "out", "=", "\"move.l %0@GOT(%%a5), %%a1\\n\\tjsr (%%a1)\"", ";", "else", "out", "=", "\"lea %0-.-8,%%a1\\n\\tjsr 0(%%pc,%%a1)\"", ";", "output_asm_insn", "(", "out", ",", "&", "dest", ")", ";", "}", "</s>"], "natrual_language": ["Output", "a", "BSR", "instruction", "suitable", "for", "PIC", "code", "."], "TS_V_token": ["m68k", "0", "\"jsr %0\"", "\"bsr.l %o0\"", "\"bsr.l %0@PLTPC\"", "\"bsr %0@PLTPC\"", "\"move.l %0@GOT(%%a5), %%a1\\n\\tjsr (%%a1)\"", "\"lea %0-.-8,%%a1\\n\\tjsr 0(%%pc,%%a1)\""], "File": "m68k3", "Func": "m68k_output_pic_call", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42633, "Length": 87}
{"ground_truth": ["<s>", "bool", "m68k_regno_mode_ok", "(", "int", "regno", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "regno", "<", "8", ")", "{", "if", "(", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", "/", "4", "<=", "8", ")", "return", "true", ";", "}", "else", "if", "(", "regno", "<", "16", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "1", ")", "return", "false", ";", "if", "(", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", "/", "4", "<=", "16", ")", "return", "true", ";", "}", "else", "if", "(", "regno", "<", "24", ")", "{", "if", "(", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", ")", "&&", "GET_MODE_UNIT_SIZE", "(", "mode", ")", "<=", "12", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Value", "is", "true", "if", "hard", "register", "REGNO", "can", "hold", "a", "value", "of", "machine-mode", "MODE", ".", "On", "the", "68000", ",", "we", "let", "the", "cpu", "registers", "can", "hold", "any", "mode", ",", "but", "restrict", "the", "68881", "registers", "to", "floating-point", "modes", "."], "TS_V_token": ["m68k", "8", "4", "8", "16", "1", "4", "16", "24", "12"], "File": "m68k3", "Func": "m68k_regno_mode_ok", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42634, "Length": 113}
{"ground_truth": ["<s>", "static", "bool", "m68k_save_reg", "(", "unsigned", "int", "regno", ",", "bool", "interrupt_handler", ")", "{", "if", "(", "flag_pic", "&&", "regno", "==", "PIC_OFFSET_TABLE_REGNUM", ")", "{", "if", "(", "current_function_uses_pic_offset_table", ")", "return", "true", ";", "if", "(", "!", "current_function_is_leaf", "&&", "TARGET_ID_SHARED_LIBRARY", ")", "return", "true", ";", "}", "if", "(", "current_function_calls_eh_return", ")", "{", "unsigned", "int", "i", ";", "for", "(", "i", "=", "0", ";", ";", "i", "++", ")", "{", "unsigned", "int", "test", "=", "EH_RETURN_DATA_REGNO", "(", "i", ")", ";", "if", "(", "test", "==", "INVALID_REGNUM", ")", "break", ";", "if", "(", "test", "==", "regno", ")", "return", "true", ";", "}", "}", "if", "(", "fixed_regs", "[", "regno", "]", ")", "return", "false", ";", "if", "(", "regno", "==", "FRAME_POINTER_REGNUM", "&&", "frame_pointer_needed", ")", "return", "false", ";", "if", "(", "interrupt_handler", ")", "{", "if", "(", "regs_ever_live", "[", "regno", "]", ")", "return", "true", ";", "if", "(", "!", "current_function_is_leaf", "&&", "call_used_regs", "[", "regno", "]", ")", "return", "true", ";", "}", "if", "(", "!", "regs_ever_live", "[", "regno", "]", ")", "return", "false", ";", "return", "!", "call_used_regs", "[", "regno", "]", ";", "}", "</s>"], "natrual_language": ["Refer", "to", "the", "array", "`", "regs_ever_live", "'", "to", "determine", "which", "registers", "to", "save", ";", "`", "regs_ever_live", "[", "I", "]", "'", "is", "nonzero", "if", "register", "number", "I", "is", "ever", "used", "in", "the", "function", ".", "This", "function", "is", "responsible", "for", "knowing", "which", "registers", "should", "not", "be", "saved", "even", "if", "used", ".", "Return", "true", "if", "we", "need", "to", "save", "REGNO", "."], "TS_V_token": ["m68k", "0"], "File": "m68k3", "Func": "m68k_save_reg", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42635, "Length": 156}
{"ground_truth": ["<s>", "const", "char", "*", "output_addsi3", "(", "rtx", "*", "operands", ")", "{", "if", "(", "!", "operands_match_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", "{", "if", "(", "!", "ADDRESS_REG_P", "(", "operands", "[", "1", "]", ")", ")", "{", "rtx", "tmp", "=", "operands", "[", "1", "]", ";", "operands", "[", "1", "]", "=", "operands", "[", "2", "]", ";", "operands", "[", "2", "]", "=", "tmp", ";", "}", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", "&&", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "-", "32768", "||", "INTVAL", "(", "operands", "[", "2", "]", ")", ">", "32767", ")", ")", "return", "\"move%.l %2,%0\\n\\tadd%.l %1,%0\"", ";", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "REG", ")", "return", "MOTOROLA", "?", "\"lea (%1,%2.l),%0\"", ":", "\"lea %1@(0,%2:l),%0\"", ";", "return", "MOTOROLA", "?", "\"lea (%c2,%1),%0\"", ":", "\"lea %1@(%c2),%0\"", ";", "}", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", "{", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ">", "0", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", "<=", "8", ")", "return", "\"addq%.l %2,%0\"", ";", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "0", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", ">=", "-", "8", ")", "{", "operands", "[", "2", "]", "=", "GEN_INT", "(", "-", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", ";", "return", "\"subq%.l %2,%0\"", ";", "}", "if", "(", "TARGET_CPU32", "&&", "REG_P", "(", "operands", "[", "0", "]", ")", ")", "{", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ">", "8", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", "<=", "16", ")", "{", "operands", "[", "2", "]", "=", "GEN_INT", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "-", "8", ")", ";", "return", "\"addq%.l #8,%0\\n\\taddq%.l %2,%0\"", ";", "}", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "-", "8", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", ">=", "-", "16", ")", "{", "operands", "[", "2", "]", "=", "GEN_INT", "(", "-", "INTVAL", "(", "operands", "[", "2", "]", ")", "-", "8", ")", ";", "return", "\"subq%.l #8,%0\\n\\tsubq%.l %2,%0\"", ";", "}", "}", "if", "(", "ADDRESS_REG_P", "(", "operands", "[", "0", "]", ")", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", ">=", "-", "0x8000", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "0x8000", ")", "{", "if", "(", "TARGET_68040", ")", "return", "\"add%.w %2,%0\"", ";", "else", "return", "MOTOROLA", "?", "\"lea (%c2,%0),%0\"", ":", "\"lea %0@(%c2),%0\"", ";", "}", "}", "return", "\"add%.l %2,%0\"", ";", "}", "</s>"], "natrual_language": ["Output", "assembler", "code", "to", "perform", "a", "32", "bit", "3", "operand", "add", "."], "TS_V_token": ["m68k", "0", "1", "1", "1", "1", "2", "2", "2", "2", "32768", "2", "32767", "\"move%.l %2,%0\\n\\tadd%.l %1,%0\"", "2", "\"lea (%1,%2.l),%0\"", "\"lea %1@(0,%2:l),%0\"", "\"lea (%c2,%1),%0\"", "\"lea %1@(%c2),%0\"", "2", "2", "0", "2", "8", "\"addq%.l %2,%0\"", "2", "0", "2", "8", "2", "2", "\"subq%.l %2,%0\"", "0", "2", "8", "2", "16", "2", "2", "8", "\"addq%.l #8,%0\\n\\taddq%.l %2,%0\"", "2", "8", "2", "16", "2", "2", "8", "\"subq%.l #8,%0\\n\\tsubq%.l %2,%0\"", "0", "2", "0x8000", "2", "0x8000", "\"add%.w %2,%0\"", "\"lea (%c2,%0),%0\"", "\"lea %0@(%c2),%0\"", "\"add%.l %2,%0\""], "File": "m68k3", "Func": "output_addsi3", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42636, "Length": 373}
{"ground_truth": ["<s>", "void", "output_dbcc_and_branch", "(", "rtx", "*", "operands", ")", "{", "switch", "(", "GET_CODE", "(", "operands", "[", "3", "]", ")", ")", "{", "case", "EQ", ":", "output_asm_insn", "(", "MOTOROLA", "?", "\"dbeq %0,%l1\\n\\tjbeq %l2\"", ":", "\"dbeq %0,%l1\\n\\tjeq %l2\"", ",", "operands", ")", ";", "break", ";", "case", "NE", ":", "output_asm_insn", "(", "MOTOROLA", "?", "\"dbne %0,%l1\\n\\tjbne %l2\"", ":", "\"dbne %0,%l1\\n\\tjne %l2\"", ",", "operands", ")", ";", "break", ";", "case", "GT", ":", "output_asm_insn", "(", "MOTOROLA", "?", "\"dbgt %0,%l1\\n\\tjbgt %l2\"", ":", "\"dbgt %0,%l1\\n\\tjgt %l2\"", ",", "operands", ")", ";", "break", ";", "case", "GTU", ":", "output_asm_insn", "(", "MOTOROLA", "?", "\"dbhi %0,%l1\\n\\tjbhi %l2\"", ":", "\"dbhi %0,%l1\\n\\tjhi %l2\"", ",", "operands", ")", ";", "break", ";", "case", "LT", ":", "output_asm_insn", "(", "MOTOROLA", "?", "\"dblt %0,%l1\\n\\tjblt %l2\"", ":", "\"dblt %0,%l1\\n\\tjlt %l2\"", ",", "operands", ")", ";", "break", ";", "case", "LTU", ":", "output_asm_insn", "(", "MOTOROLA", "?", "\"dbcs %0,%l1\\n\\tjbcs %l2\"", ":", "\"dbcs %0,%l1\\n\\tjcs %l2\"", ",", "operands", ")", ";", "break", ";", "case", "GE", ":", "output_asm_insn", "(", "MOTOROLA", "?", "\"dbge %0,%l1\\n\\tjbge %l2\"", ":", "\"dbge %0,%l1\\n\\tjge %l2\"", ",", "operands", ")", ";", "break", ";", "case", "GEU", ":", "output_asm_insn", "(", "MOTOROLA", "?", "\"dbcc %0,%l1\\n\\tjbcc %l2\"", ":", "\"dbcc %0,%l1\\n\\tjcc %l2\"", ",", "operands", ")", ";", "break", ";", "case", "LE", ":", "output_asm_insn", "(", "MOTOROLA", "?", "\"dble %0,%l1\\n\\tjble %l2\"", ":", "\"dble %0,%l1\\n\\tjle %l2\"", ",", "operands", ")", ";", "break", ";", "case", "LEU", ":", "output_asm_insn", "(", "MOTOROLA", "?", "\"dbls %0,%l1\\n\\tjbls %l2\"", ":", "\"dbls %0,%l1\\n\\tjls %l2\"", ",", "operands", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ")", "{", "case", "SImode", ":", "output_asm_insn", "(", "MOTOROLA", "?", "\"clr%.w %0\\n\\tsubq%.l #1,%0\\n\\tjbpl %l1\"", ":", "\"clr%.w %0\\n\\tsubq%.l #1,%0\\n\\tjpl %l1\"", ",", "operands", ")", ";", "break", ";", "case", "HImode", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Output", "a", "dbCC", ";", "jCC", "sequence", ".", "Note", "we", "do", "not", "handle", "the", "floating", "point", "version", "of", "this", "sequence", "(", "Fdbcc", ")", ".", "We", "also", "do", "not", "handle", "alternative", "conditions", "when", "CC_NO_OVERFLOW", "is", "set", ".", "It", "is", "assumed", "that", "valid_dbcc_comparison_p", "and", "flags_in_68881", "will", "kick", "those", "out", "before", "we", "get", "here", "."], "TS_V_token": ["m68k", "3", "\"dbeq %0,%l1\\n\\tjbeq %l2\"", "\"dbeq %0,%l1\\n\\tjeq %l2\"", "\"dbne %0,%l1\\n\\tjbne %l2\"", "\"dbne %0,%l1\\n\\tjne %l2\"", "\"dbgt %0,%l1\\n\\tjbgt %l2\"", "\"dbgt %0,%l1\\n\\tjgt %l2\"", "\"dbhi %0,%l1\\n\\tjbhi %l2\"", "\"dbhi %0,%l1\\n\\tjhi %l2\"", "\"dblt %0,%l1\\n\\tjblt %l2\"", "\"dblt %0,%l1\\n\\tjlt %l2\"", "\"dbcs %0,%l1\\n\\tjbcs %l2\"", "\"dbcs %0,%l1\\n\\tjcs %l2\"", "\"dbge %0,%l1\\n\\tjbge %l2\"", "\"dbge %0,%l1\\n\\tjge %l2\"", "\"dbcc %0,%l1\\n\\tjbcc %l2\"", "\"dbcc %0,%l1\\n\\tjcc %l2\"", "\"dble %0,%l1\\n\\tjble %l2\"", "\"dble %0,%l1\\n\\tjle %l2\"", "\"dbls %0,%l1\\n\\tjbls %l2\"", "\"dbls %0,%l1\\n\\tjls %l2\"", "0", "\"clr%.w %0\\n\\tsubq%.l #1,%0\\n\\tjbpl %l1\"", "\"clr%.w %0\\n\\tsubq%.l #1,%0\\n\\tjpl %l1\""], "File": "m68k3", "Func": "output_dbcc_and_branch", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42637, "Length": 226}
{"ground_truth": ["<s>", "const", "char", "*", "output_move_const_into_data_reg", "(", "rtx", "*", "operands", ")", "{", "int", "i", ";", "i", "=", "INTVAL", "(", "operands", "[", "1", "]", ")", ";", "switch", "(", "const_method", "(", "operands", "[", "1", "]", ")", ")", "{", "case", "MVZ", ":", "return", "\"mvsw %1,%0\"", ";", "case", "MVS", ":", "return", "\"mvzw %1,%0\"", ";", "case", "MOVQ", ":", "return", "\"moveq %1,%0\"", ";", "case", "NOTB", ":", "CC_STATUS_INIT", ";", "operands", "[", "1", "]", "=", "GEN_INT", "(", "i", "^", "0xff", ")", ";", "return", "\"moveq %1,%0\\n\\tnot%.b %0\"", ";", "case", "NOTW", ":", "CC_STATUS_INIT", ";", "operands", "[", "1", "]", "=", "GEN_INT", "(", "i", "^", "0xffff", ")", ";", "return", "\"moveq %1,%0\\n\\tnot%.w %0\"", ";", "case", "NEGW", ":", "CC_STATUS_INIT", ";", "return", "\"moveq #-128,%0\\n\\tneg%.w %0\"", ";", "case", "SWAP", ":", "{", "unsigned", "u", "=", "i", ";", "operands", "[", "1", "]", "=", "GEN_INT", "(", "(", "u", "<<", "16", ")", "|", "(", "u", ">>", "16", ")", ")", ";", "return", "\"moveq %1,%0\\n\\tswap %0\"", ";", "}", "case", "MOVL", ":", "return", "\"move%.l %1,%0\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Return", "an", "instruction", "to", "move", "CONST_INT", "OPERANDS", "[", "1", "]", "into", "data", "register", "OPERANDS", "[", "0", "]", "."], "TS_V_token": ["m68k", "1", "1", "\"mvsw %1,%0\"", "\"mvzw %1,%0\"", "\"moveq %1,%0\"", "1", "0xff", "\"moveq %1,%0\\n\\tnot%.b %0\"", "1", "0xffff", "\"moveq %1,%0\\n\\tnot%.w %0\"", "\"moveq #-128,%0\\n\\tneg%.w %0\"", "1", "16", "16", "\"moveq %1,%0\\n\\tswap %0\"", "\"move%.l %1,%0\""], "File": "m68k3", "Func": "output_move_const_into_data_reg", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42638, "Length": 147}
{"ground_truth": ["<s>", "const", "char", "*", "output_move_simode_const", "(", "rtx", "*", "operands", ")", "{", "if", "(", "operands", "[", "1", "]", "==", "const0_rtx", "&&", "(", "DATA_REG_P", "(", "operands", "[", "0", "]", ")", "||", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "MEM", ")", "&&", "(", "(", "TARGET_68020", "||", "TARGET_COLDFIRE", ")", "||", "!", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "MEM", "&&", "MEM_VOLATILE_P", "(", "operands", "[", "0", "]", ")", ")", ")", ")", "return", "\"clr%.l %0\"", ";", "else", "if", "(", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", "==", "SImode", ")", "&&", "valid_mov3q_const", "(", "operands", "[", "1", "]", ")", ")", "return", "\"mov3q%.l %1,%0\"", ";", "else", "if", "(", "operands", "[", "1", "]", "==", "const0_rtx", "&&", "ADDRESS_REG_P", "(", "operands", "[", "0", "]", ")", ")", "return", "\"sub%.l %0,%0\"", ";", "else", "if", "(", "DATA_REG_P", "(", "operands", "[", "0", "]", ")", ")", "return", "output_move_const_into_data_reg", "(", "operands", ")", ";", "else", "if", "(", "ADDRESS_REG_P", "(", "operands", "[", "0", "]", ")", "&&", "INTVAL", "(", "operands", "[", "1", "]", ")", "<", "0x8000", "&&", "INTVAL", "(", "operands", "[", "1", "]", ")", ">=", "-", "0x8000", ")", "{", "if", "(", "valid_mov3q_const", "(", "operands", "[", "1", "]", ")", ")", "return", "\"mov3q%.l %1,%0\"", ";", "return", "\"move%.w %1,%0\"", ";", "}", "else", "if", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ")", "==", "PRE_DEC", "&&", "REGNO", "(", "XEXP", "(", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ",", "0", ")", ")", "==", "STACK_POINTER_REGNUM", "&&", "INTVAL", "(", "operands", "[", "1", "]", ")", "<", "0x8000", "&&", "INTVAL", "(", "operands", "[", "1", "]", ")", ">=", "-", "0x8000", ")", "{", "if", "(", "valid_mov3q_const", "(", "operands", "[", "1", "]", ")", ")", "return", "\"mov3q%.l %1,%-\"", ";", "return", "\"pea %a1\"", ";", "}", "return", "\"move%.l %1,%0\"", ";", "}", "</s>"], "natrual_language": ["Return", "an", "instruction", "to", "move", "CONST_INT", "OPERANDS", "[", "1", "]", "into", "OPERANDS", "[", "0", "]", ".", "I", "is", "the", "value", "of", "OPERANDS", "[", "1", "]", "."], "TS_V_token": ["m68k", "1", "0", "0", "0", "0", "\"clr%.l %0\"", "0", "1", "\"mov3q%.l %1,%0\"", "1", "0", "\"sub%.l %0,%0\"", "0", "0", "1", "0x8000", "1", "0x8000", "1", "\"mov3q%.l %1,%0\"", "\"move%.w %1,%0\"", "0", "0", "0", "0", "0", "0", "1", "0x8000", "1", "0x8000", "1", "\"mov3q%.l %1,%-\"", "\"pea %a1\"", "\"move%.l %1,%0\""], "File": "m68k3", "Func": "output_move_simode_const", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42639, "Length": 276}
{"ground_truth": ["<s>", "void", "override_options", "(", "void", ")", "{", "if", "(", "TARGET_SEP_DATA", "&&", "TARGET_ID_SHARED_LIBRARY", ")", "error", "(", "\"cannot specify both -msep-data and -mid-shared-library\"", ")", ";", "if", "(", "TARGET_SEP_DATA", "||", "TARGET_ID_SHARED_LIBRARY", ")", "flag_pic", "=", "2", ";", "if", "(", "!", "TARGET_68020", "&&", "!", "TARGET_COLDFIRE", "&&", "(", "flag_pic", "==", "2", ")", ")", "error", "(", "\"-fPIC is not currently supported on the 68000 or 68010\"", ")", ";", "if", "(", "TARGET_PCREL", "&&", "flag_pic", "==", "0", ")", "flag_pic", "=", "1", ";", "if", "(", "flag_pic", ")", "flag_no_function_cse", "=", "1", ";", "SUBTARGET_OVERRIDE_OPTIONS", ";", "}", "</s>"], "natrual_language": ["Set", "global", "variables", "as", "needed", "for", "the", "options", "enabled", "."], "TS_V_token": ["m68k", "\"cannot specify both -msep-data and -mid-shared-library\"", "2", "2", "\"-fPIC is not currently supported on the 68000 or 68010\"", "0", "1", "1"], "File": "m68k3", "Func": "override_options", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42640, "Length": 69}
{"ground_truth": ["<s>", "void", "print_operand", "(", "FILE", "*", "file", ",", "rtx", "op", ",", "int", "letter", ")", "{", "if", "(", "letter", "==", "'.'", ")", "{", "if", "(", "MOTOROLA", ")", "fprintf", "(", "file", ",", "\".\"", ")", ";", "}", "else", "if", "(", "letter", "==", "'#'", ")", "asm_fprintf", "(", "file", ",", "\"%I\"", ")", ";", "else", "if", "(", "letter", "==", "'-'", ")", "asm_fprintf", "(", "file", ",", "MOTOROLA", "?", "\"-(%Rsp)\"", ":", "\"%Rsp@-\"", ")", ";", "else", "if", "(", "letter", "==", "'+'", ")", "asm_fprintf", "(", "file", ",", "MOTOROLA", "?", "\"(%Rsp)+\"", ":", "\"%Rsp@+\"", ")", ";", "else", "if", "(", "letter", "==", "'@'", ")", "asm_fprintf", "(", "file", ",", "MOTOROLA", "?", "\"(%Rsp)\"", ":", "\"%Rsp@\"", ")", ";", "else", "if", "(", "letter", "==", "'!'", ")", "asm_fprintf", "(", "file", ",", "\"%Rfpcr\"", ")", ";", "else", "if", "(", "letter", "==", "'$'", ")", "{", "if", "(", "TARGET_68040_ONLY", ")", "fprintf", "(", "file", ",", "\"s\"", ")", ";", "}", "else", "if", "(", "letter", "==", "'&'", ")", "{", "if", "(", "TARGET_68040_ONLY", ")", "fprintf", "(", "file", ",", "\"d\"", ")", ";", "}", "else", "if", "(", "letter", "==", "'/'", ")", "asm_fprintf", "(", "file", ",", "\"%R\"", ")", ";", "else", "if", "(", "letter", "==", "'o'", ")", "{", "gcc_assert", "(", "GET_CODE", "(", "op", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "SYMBOL_REF", "&&", "TARGET_PCREL", ")", ";", "output_addr_const", "(", "file", ",", "XEXP", "(", "op", ",", "0", ")", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "op", ")", "==", "REG", ")", "{", "if", "(", "letter", "==", "'R'", ")", "fputs", "(", "M68K_REGNAME", "(", "REGNO", "(", "op", ")", "+", "1", ")", ",", "file", ")", ";", "else", "fputs", "(", "M68K_REGNAME", "(", "REGNO", "(", "op", ")", ")", ",", "file", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "op", ")", "==", "MEM", ")", "{", "output_address", "(", "XEXP", "(", "op", ",", "0", ")", ")", ";", "if", "(", "letter", "==", "'d'", "&&", "!", "TARGET_68020", "&&", "CONSTANT_ADDRESS_P", "(", "XEXP", "(", "op", ",", "0", ")", ")", "&&", "!", "(", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "XEXP", "(", "op", ",", "0", ")", ")", "<", "0x8000", "&&", "INTVAL", "(", "XEXP", "(", "op", ",", "0", ")", ")", ">=", "-", "0x8000", ")", ")", "fprintf", "(", "file", ",", "MOTOROLA", "?", "\".l\"", ":", "\":l\"", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_DOUBLE", "&&", "GET_MODE", "(", "op", ")", "==", "SFmode", ")", "{", "REAL_VALUE_TYPE", "r", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "r", ",", "op", ")", ";", "ASM_OUTPUT_FLOAT_OPERAND", "(", "letter", ",", "file", ",", "r", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_DOUBLE", "&&", "GET_MODE", "(", "op", ")", "==", "XFmode", ")", "{", "REAL_VALUE_TYPE", "r", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "r", ",", "op", ")", ";", "ASM_OUTPUT_LONG_DOUBLE_OPERAND", "(", "file", ",", "r", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_DOUBLE", "&&", "GET_MODE", "(", "op", ")", "==", "DFmode", ")", "{", "REAL_VALUE_TYPE", "r", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "r", ",", "op", ")", ";", "ASM_OUTPUT_DOUBLE_OPERAND", "(", "file", ",", "r", ")", ";", "}", "else", "{", "asm_fprintf", "(", "file", ",", "\"%I\"", ")", ";", "if", "(", "TARGET_PCREL", "&&", "(", "GET_CODE", "(", "op", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "op", ")", "==", "CONST", ")", ")", "print_operand_address", "(", "file", ",", "op", ")", ";", "else", "output_addr_const", "(", "file", ",", "op", ")", ";", "}", "}", "</s>"], "natrual_language": ["Use", "S", "for", "SI", "regsUse", "B", "&", "T", "for", "parts", "of", "DI", "regs", "X", "-", "stack", "pointer", "name", "Registers", "Q", "-", "byte", "sized", "register", "name", "U", "-", "high", "byte", "of", "word", "register", "V", "-", "low", "byte", "of", "word", "register", "H", "-", "word", "register", "name", "I", "-", "next", "word", "register", "name", "S", "&", "B", "-", "long", "register", "name", "T", "-", "next", "long", "register", "name", "D", "-", "quad", "register", "name", "P", "-", "register", "name", "in", "size", "of", "pointer", "Integers", "O", "-", "log", "two", "of", "value", "P", "-", "inverted", "log", "two", "H", "-", "bottom", "16", "bits", "I", "-", "top", "16", "bits", "N", "-", "negative", "B", "-", "high", "32", "bits", "of", "32bit", "number", ".", "default", ":", "value", "Memory", "I", "-", "adjusted", "upwards", "by", "two", "T", "-", "adjusted", "upwards", "by", "four", "default", ":", "value", "Address", "H", "-", "low", "16", "bits", "I", "-", "high", "16", "bits", "A", "-", "as", "long", "constant", "S", "-", "as", "A", "but", "with", "#", "default", ":", "error", "Misc", "C", "-", "conditional", "name", "D", "-", "reverse", "conditional", "name", "F", "-", "clear", "v", "flag", "if", "necessary"], "TS_V_token": ["m68k", "\".\"", "\"%I\"", "\"-(%Rsp)\"", "\"%Rsp@-\"", "\"(%Rsp)+\"", "\"%Rsp@+\"", "\"(%Rsp)\"", "\"%Rsp@\"", "\"%Rfpcr\"", "\"s\"", "\"d\"", "\"%R\"", "0", "0", "1", "0", "0", "0", "0", "0x8000", "0", "0x8000", "\".l\"", "\":l\"", "\"%I\""], "File": "m68k3", "Func": "print_operand", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42641, "Length": 509}
{"ground_truth": ["<s>", "bool", "strict_low_part_peephole_ok", "(", "enum", "machine_mode", "mode", ",", "rtx", "first_insn", ",", "rtx", "target", ")", "{", "rtx", "p", ";", "p", "=", "prev_nonnote_insn", "(", "first_insn", ")", ";", "while", "(", "p", ")", "{", "if", "(", "GET_CODE", "(", "p", ")", "!=", "INSN", ")", "return", "false", ";", "if", "(", "reg_set_p", "(", "target", ",", "p", ")", ")", "{", "rtx", "set", "=", "single_set", "(", "p", ")", ";", "rtx", "dest", ";", "if", "(", "!", "set", ")", "return", "false", ";", "dest", "=", "SET_DEST", "(", "set", ")", ";", "if", "(", "rtx_equal_p", "(", "dest", ",", "target", ")", "&&", "SET_SRC", "(", "set", ")", "==", "const0_rtx", ")", "return", "true", ";", "else", "if", "(", "GET_CODE", "(", "dest", ")", "==", "STRICT_LOW_PART", "&&", "GET_CODE", "(", "XEXP", "(", "dest", ",", "0", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "dest", ",", "0", ")", ")", "==", "REGNO", "(", "target", ")", "&&", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "XEXP", "(", "dest", ",", "0", ")", ")", ")", "<=", "GET_MODE_SIZE", "(", "mode", ")", ")", ")", ";", "else", "return", "false", ";", "}", "p", "=", "prev_nonnote_insn", "(", "p", ")", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Check", "for", "cases", "where", "a", "clr", "insns", "can", "be", "omitted", "from", "code", "using", "strict_low_part", "sets", ".", "For", "example", ",", "the", "second", "clrl", "here", "is", "not", "needed", ":", "clrl", "d0", ";", "movw", "a0", "@", "+", ",", "d0", ";", "use", "d0", ";", "clrl", "d0", ";", "movw", "a0", "@", "+", ";", "use", "d0", ";", "...", "MODE", "is", "the", "mode", "of", "this", "STRICT_LOW_PART", "set", ".", "FIRST_INSN", "is", "the", "clear", "insn", "we", "are", "checking", "for", "redundancy", ".", "TARGET", "is", "the", "register", "set", "by", "the", "clear", "insn", "."], "TS_V_token": ["m68k", "0", "0", "0"], "File": "m68k3", "Func": "strict_low_part_peephole_ok", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42642, "Length": 171}
{"ground_truth": ["<s>", "bool", "use_return_insn", "(", "void", ")", "{", "if", "(", "!", "reload_completed", "||", "frame_pointer_needed", "||", "get_frame_size", "(", ")", "!=", "0", ")", "return", "false", ";", "m68k_compute_frame_layout", "(", ")", ";", "return", "current_frame", ".", "reg_no", "?", "false", ":", "true", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "this", "function", "'s", "epilogue", "can", "be", "output", "as", "RTL", "."], "TS_V_token": ["m68k", "0"], "File": "m68k3", "Func": "use_return_insn", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42643, "Length": 36}
{"ground_truth": ["<s>", "int", "valid_dbcc_comparison_p_2", "(", "rtx", "x", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "EQ", ":", "case", "NE", ":", "case", "GTU", ":", "case", "LTU", ":", "case", "GEU", ":", "case", "LEU", ":", "return", "1", ";", "case", "GT", ":", "case", "LT", ":", "case", "GE", ":", "case", "LE", ":", "return", "!", "(", "cc_prev_status", ".", "flags", "&", "CC_NO_OVERFLOW", ")", ";", "default", ":", "return", "0", ";", "}", "}", "</s>"], "natrual_language": ["Return", "true", "if", "X", "is", "a", "valid", "comparison", "operator", "for", "the", "dbcc", "instruction", ".", "Note", "it", "rejects", "floating", "point", "comparison", "operators", ".", "(", "In", "the", "future", "we", "could", "use", "Fdbcc", ")", ".", "It", "also", "rejects", "some", "comparisons", "when", "CC_NO_OVERFLOW", "is", "set", "."], "TS_V_token": ["m68k", "1", "0"], "File": "m68k3", "Func": "valid_dbcc_comparison_p_2", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42644, "Length": 70}
{"ground_truth": ["<s>", "int", "valid_mov3q_const", "(", "rtx", "constant", ")", "{", "int", "i", ";", "if", "(", "TARGET_CFV4", "&&", "GET_CODE", "(", "constant", ")", "==", "CONST_INT", ")", "{", "i", "=", "INTVAL", "(", "constant", ")", ";", "if", "(", "(", "i", "==", "-", "1", ")", "||", "(", "i", ">=", "1", "&&", "i", "<=", "7", ")", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>"], "natrual_language": ["Return", "1", "if", "'constant", "'", "can", "be", "represented", "by", "mov3q", "on", "a", "ColdFire", "V4", "core", "."], "TS_V_token": ["m68k", "1", "1", "7", "1", "0"], "File": "m68k3", "Func": "valid_mov3q_const", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42645, "Length": 56}
{"ground_truth": ["<s>", "static", "void", "emit_reg_adjust", "(", "rtx", "reg1", ",", "int", "n", ")", "{", "rtx", "reg2", ";", "gcc_assert", "(", "GET_MODE", "(", "reg1", ")", "==", "SImode", "&&", "-", "12", "<=", "n", "&&", "n", "!=", "0", "&&", "n", "<=", "12", ")", ";", "reg1", "=", "copy_rtx", "(", "reg1", ")", ";", "reg2", "=", "copy_rtx", "(", "reg1", ")", ";", "if", "(", "n", "<", "0", ")", "emit_insn", "(", "gen_subsi3", "(", "reg1", ",", "reg2", ",", "GEN_INT", "(", "-", "n", ")", ")", ")", ";", "else", "if", "(", "n", ">", "0", ")", "emit_insn", "(", "gen_addsi3", "(", "reg1", ",", "reg2", ",", "GEN_INT", "(", "n", ")", ")", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>"], "natrual_language": ["Emit", "rtl", "code", "to", "adjust", "REG", "by", "N", "."], "TS_V_token": ["m68k", "12", "0", "12", "0", "0"], "File": "m68k4", "Func": "emit_reg_adjust", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42646, "Length": 101}
{"ground_truth": ["<s>", "int", "floating_exact_log2", "(", "rtx", "x", ")", "{", "REAL_VALUE_TYPE", "r", ",", "r1", ";", "int", "exp", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "r", ",", "x", ")", ";", "if", "(", "REAL_VALUES_LESS", "(", "r", ",", "dconst1", ")", ")", "return", "0", ";", "exp", "=", "real_exponent", "(", "&", "r", ")", ";", "real_2expN", "(", "&", "r1", ",", "exp", ",", "DFmode", ")", ";", "if", "(", "REAL_VALUES_EQUAL", "(", "r1", ",", "r", ")", ")", "return", "exp", ";", "return", "0", ";", "}", "</s>"], "natrual_language": ["If", "X", "is", "a", "floating-point", "constant", ",", "return", "the", "logarithm", "of", "X", "base", "2", ",", "or", "0", "if", "X", "is", "not", "a", "power", "of", "2", "."], "TS_V_token": ["m68k", "0", "0"], "File": "m68k4", "Func": "floating_exact_log2", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42647, "Length": 68}
{"ground_truth": ["<s>", "static", "rtx", "m68k_call_m68k_read_tp", "(", "void", ")", "{", "rtx", "a0", ";", "rtx", "eqv", ";", "rtx_insn", "*", "insns", ";", "rtx", "dest", ";", "start_sequence", "(", ")", ";", "m68k_libcall_value_in_a0_p", "=", "true", ";", "a0", "=", "emit_library_call_value", "(", "m68k_get_m68k_read_tp", "(", ")", ",", "NULL_RTX", ",", "LCT_PURE", ",", "Pmode", ",", "0", ")", ";", "m68k_libcall_value_in_a0_p", "=", "false", ";", "insns", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "eqv", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "const1_rtx", ")", ",", "UNSPEC_RELOC32", ")", ";", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "dest", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_libcall_block", "(", "insns", ",", "dest", ",", "a0", ",", "eqv", ")", ";", "return", "dest", ";", "}", "</s>"], "natrual_language": ["Emit", "instruction", "sequence", "that", "calls", "__m68k_read_tp", ".", "A", "pseudo", "register", "with", "result", "of", "__m68k_read_tp", "call", "is", "returned", "."], "TS_V_token": ["m68k", "0", "1"], "File": "m68k4", "Func": "m68k_call_m68k_read_tp", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42648, "Length": 104}
{"ground_truth": ["<s>", "static", "rtx", "m68k_call_tls_get_addr", "(", "rtx", "x", ",", "rtx", "eqv", ",", "enum", "m68k_reloc", "reloc", ")", "{", "rtx", "a0", ";", "rtx_insn", "*", "insns", ";", "rtx", "dest", ";", "start_sequence", "(", ")", ";", "x", "=", "m68k_wrap_symbol", "(", "x", ",", "reloc", ",", "m68k_get_gp", "(", ")", ",", "NULL_RTX", ")", ";", "m68k_libcall_value_in_a0_p", "=", "true", ";", "a0", "=", "emit_library_call_value", "(", "m68k_get_tls_get_addr", "(", ")", ",", "NULL_RTX", ",", "LCT_PURE", ",", "Pmode", ",", "1", ",", "x", ",", "Pmode", ")", ";", "m68k_libcall_value_in_a0_p", "=", "false", ";", "insns", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "dest", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_libcall_block", "(", "insns", ",", "dest", ",", "a0", ",", "eqv", ")", ";", "return", "dest", ";", "}", "</s>"], "natrual_language": ["Emit", "instruction", "sequence", "that", "calls", "__tls_get_addr", ".", "X", "is", "the", "TLS", "symbol", "we", "are", "referencing", "and", "RELOC", "is", "the", "symbol", "type", "to", "use", "(", "either", "TLSGD", "or", "TLSLDM", ")", ".", "EQV", "is", "the", "REG_EQUAL", "note", "for", "the", "sequence", "emitted", ".", "A", "pseudo", "register", "with", "result", "of", "__tls_get_addr", "call", "is", "returned", "."], "TS_V_token": ["m68k", "1"], "File": "m68k4", "Func": "m68k_call_tls_get_addr", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42649, "Length": 112}
{"ground_truth": ["<s>", "static", "void", "m68k_conditional_register_usage", "(", "void", ")", "{", "int", "i", ";", "HARD_REG_SET", "x", ";", "if", "(", "!", "TARGET_HARD_FLOAT", ")", "{", "COPY_HARD_REG_SET", "(", "x", ",", "reg_class_contents", "[", "(", "int", ")", "FP_REGS", "]", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "if", "(", "TEST_HARD_REG_BIT", "(", "x", ",", "i", ")", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "1", ";", "}", "if", "(", "flag_pic", ")", "fixed_regs", "[", "PIC_REG", "]", "=", "call_used_regs", "[", "PIC_REG", "]", "=", "1", ";", "}", "</s>"], "natrual_language": ["Make", "sure", "everything", "'s", "fine", "if", "we", "*", "do", "n't", "*", "have", "a", "given", "processor", ".", "This", "assumes", "that", "putting", "a", "register", "in", "fixed_regs", "will", "keep", "the", "compiler", "'s", "mitts", "completely", "off", "it", ".", "We", "do", "n't", "bother", "to", "zero", "it", "out", "of", "register", "classes", "."], "TS_V_token": ["m68k", "0", "1", "1"], "File": "m68k4", "Func": "m68k_conditional_register_usage", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42650, "Length": 84}
{"ground_truth": ["<s>", "static", "rtx_insn", "*", "m68k_emit_movem", "(", "rtx", "base", ",", "HOST_WIDE_INT", "offset", ",", "unsigned", "int", "count", ",", "unsigned", "int", "regno", ",", "unsigned", "int", "mask", ",", "bool", "store_p", ",", "bool", "adjust_stack_p", ")", "{", "int", "i", ";", "rtx", "body", ",", "addr", ",", "src", ",", "operands", "[", "2", "]", ";", "machine_mode", "mode", ";", "body", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "adjust_stack_p", "+", "count", ")", ")", ";", "mode", "=", "reg_raw_mode", "[", "regno", "]", ";", "i", "=", "0", ";", "if", "(", "adjust_stack_p", ")", "{", "src", "=", "plus_constant", "(", "Pmode", ",", "base", ",", "(", "count", "*", "GET_MODE_SIZE", "(", "mode", ")", "*", "(", "HOST_WIDE_INT", ")", "(", "store_p", "?", "-", "1", ":", "1", ")", ")", ")", ";", "XVECEXP", "(", "body", ",", "0", ",", "i", "++", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "base", ",", "src", ")", ";", "}", "for", "(", ";", "mask", "!=", "0", ";", "mask", ">>=", "1", ",", "regno", "++", ")", "if", "(", "mask", "&", "1", ")", "{", "addr", "=", "plus_constant", "(", "Pmode", ",", "base", ",", "offset", ")", ";", "operands", "[", "!", "store_p", "]", "=", "gen_frame_mem", "(", "mode", ",", "addr", ")", ";", "operands", "[", "store_p", "]", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "XVECEXP", "(", "body", ",", "0", ",", "i", "++", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "offset", "+=", "GET_MODE_SIZE", "(", "mode", ")", ";", "}", "gcc_assert", "(", "i", "==", "XVECLEN", "(", "body", ",", "0", ")", ")", ";", "return", "emit_insn", "(", "body", ")", ";", "}", "</s>"], "natrual_language": ["Emit", "RTL", "for", "a", "MOVEM", "or", "FMOVEM", "instruction", ".", "BASE", "+", "OFFSET", "represents", "the", "lowest", "memory", "address", ".", "COUNT", "is", "the", "number", "of", "registers", "to", "be", "moved", ",", "with", "register", "REGNO", "+", "I", "being", "moved", "if", "bit", "I", "of", "MASK", "is", "set", ".", "STORE_P", "specifies", "the", "direction", "of", "the", "move", "and", "ADJUST_STACK_P", "says", "whether", "or", "not", "this", "is", "pre-decrement", "(", "if", "STORE_P", ")", "or", "post-increment", "(", "if", "!", "STORE_P", ")", "operation", "."], "TS_V_token": ["m68k", "2", "0", "1", "1", "0", "0", "1", "1", "0", "0", "1", "0"], "File": "m68k4", "Func": "m68k_emit_movem", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42651, "Length": 237}
{"ground_truth": ["<s>", "static", "rtx", "m68k_function_arg", "(", "cumulative_args_t", "cum", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "return", "NULL_RTX", ";", "}", "</s>"], "natrual_language": ["On", "the", "m68k", "all", "args", "are", "always", "pushed", "."], "TS_V_token": ["m68k"], "File": "m68k4", "Func": "m68k_function_arg", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42652, "Length": 25}
{"ground_truth": ["<s>", "rtx", "m68k_function_value", "(", "const_tree", "valtype", ",", "const_tree", "func", "ATTRIBUTE_UNUSED", ")", "{", "machine_mode", "mode", ";", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "switch", "(", "mode", ")", "{", "case", "SFmode", ":", "case", "DFmode", ":", "case", "XFmode", ":", "if", "(", "TARGET_68881", ")", "return", "gen_rtx_REG", "(", "mode", ",", "FP0_REG", ")", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "func", "&&", "POINTER_TYPE_P", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "func", ")", ")", ")", ")", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "2", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode", ",", "A0_REG", ")", ",", "const0_rtx", ")", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode", ",", "D0_REG", ")", ",", "const0_rtx", ")", ")", ")", ";", "else", "if", "(", "POINTER_TYPE_P", "(", "valtype", ")", ")", "return", "gen_rtx_REG", "(", "mode", ",", "A0_REG", ")", ";", "else", "return", "gen_rtx_REG", "(", "mode", ",", "D0_REG", ")", ";", "}", "</s>"], "natrual_language": ["Location", "in", "which", "function", "value", "is", "returned", ".", "NOTE", ":", "Due", "to", "differences", "in", "ABIs", ",", "do", "n't", "call", "this", "function", "directly", ",", "use", "FUNCTION_VALUE", "instead", "."], "TS_V_token": ["m68k", "2"], "File": "m68k4", "Func": "m68k_function_value", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42653, "Length": 134}
{"ground_truth": ["<s>", "static", "const", "char", "*", "m68k_get_reloc_decoration", "(", "enum", "m68k_reloc", "reloc", ")", "{", "gcc_assert", "(", "MOTOROLA", "||", "reloc", "==", "RELOC_GOT", ")", ";", "switch", "(", "reloc", ")", "{", "case", "RELOC_GOT", ":", "if", "(", "MOTOROLA", ")", "{", "if", "(", "flag_pic", "==", "1", "&&", "TARGET_68020", ")", "return", "\"@GOT.w\"", ";", "else", "return", "\"@GOT\"", ";", "}", "else", "{", "if", "(", "TARGET_68020", ")", "{", "switch", "(", "flag_pic", ")", "{", "case", "1", ":", "return", "\":w\"", ";", "case", "2", ":", "return", "\":l\"", ";", "default", ":", "return", "\"\"", ";", "}", "}", "}", "case", "RELOC_TLSGD", ":", "return", "\"@TLSGD\"", ";", "case", "RELOC_TLSLDM", ":", "return", "\"@TLSLDM\"", ";", "case", "RELOC_TLSLDO", ":", "return", "\"@TLSLDO\"", ";", "case", "RELOC_TLSIE", ":", "return", "\"@TLSIE\"", ";", "case", "RELOC_TLSLE", ":", "return", "\"@TLSLE\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Return", "string", "for", "TLS", "relocation", "RELOC", "."], "TS_V_token": ["m68k", "1", "\"@GOT.w\"", "\"@GOT\"", "1", "\":w\"", "2", "\":l\"", "\"\"", "\"@TLSGD\"", "\"@TLSLDM\"", "\"@TLSLDO\"", "\"@TLSIE\"", "\"@TLSLE\""], "File": "m68k4", "Func": "m68k_get_reloc_decoration", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42654, "Length": 119}
{"ground_truth": ["<s>", "rtx", "m68k_libcall_value", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "SFmode", ":", "case", "DFmode", ":", "case", "XFmode", ":", "if", "(", "TARGET_68881", ")", "return", "gen_rtx_REG", "(", "mode", ",", "FP0_REG", ")", ";", "break", ";", "default", ":", "break", ";", "}", "return", "gen_rtx_REG", "(", "mode", ",", "m68k_libcall_value_in_a0_p", "?", "A0_REG", ":", "D0_REG", ")", ";", "}", "</s>"], "natrual_language": ["Return", "floating", "point", "values", "in", "a", "68881", "register", ".", "This", "makes", "68881", "code", "a", "little", "bit", "faster", ".", "It", "also", "makes", "-msoft-float", "code", "incompatible", "with", "hard-float", "code", ",", "so", "people", "have", "to", "be", "careful", "not", "to", "mix", "the", "two", ".", "For", "ColdFire", "it", "was", "decided", "the", "ABI", "incompatibility", "is", "undesirable", ".", "If", "there", "is", "need", "for", "a", "hard-float", "ABI", "it", "is", "probably", "worth", "doing", "it", "properly", "and", "also", "passing", "function", "arguments", "in", "FP", "registers", "."], "TS_V_token": ["m68k"], "File": "m68k4", "Func": "m68k_libcall_value", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42655, "Length": 53}
{"ground_truth": ["<s>", "bool", "m68k_regno_mode_ok", "(", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "DATA_REGNO_P", "(", "regno", ")", ")", "{", "if", "(", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", "/", "4", "<=", "8", ")", "return", "true", ";", "}", "else", "if", "(", "ADDRESS_REGNO_P", "(", "regno", ")", ")", "{", "if", "(", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", "/", "4", "<=", "16", ")", "return", "true", ";", "}", "else", "if", "(", "FP_REGNO_P", "(", "regno", ")", ")", "{", "if", "(", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", ")", "&&", "GET_MODE_UNIT_SIZE", "(", "mode", ")", "<=", "TARGET_FP_REG_SIZE", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Value", "is", "true", "if", "hard", "register", "REGNO", "can", "hold", "a", "value", "of", "machine-mode", "MODE", ".", "On", "the", "68000", ",", "we", "let", "the", "cpu", "registers", "can", "hold", "any", "mode", ",", "but", "restrict", "the", "68881", "registers", "to", "floating-point", "modes", "."], "TS_V_token": ["m68k", "4", "8", "4", "16"], "File": "m68k4", "Func": "m68k_regno_mode_ok", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42656, "Length": 103}
{"ground_truth": ["<s>", "static", "int", "m68k_return_pops_args", "(", "tree", "fundecl", ",", "tree", "funtype", ",", "int", "size", ")", "{", "return", "(", "(", "TARGET_RTD", "&&", "(", "!", "fundecl", "||", "TREE_CODE", "(", "fundecl", ")", "!=", "IDENTIFIER_NODE", ")", "&&", "(", "!", "stdarg_p", "(", "funtype", ")", ")", ")", "?", "size", ":", "0", ")", ";", "}", "</s>"], "natrual_language": ["On", "the", "68000", ",", "the", "RTS", "insn", "can", "not", "pop", "anything", ".", "On", "the", "68010", ",", "the", "RTD", "insn", "may", "be", "used", "to", "pop", "them", "if", "the", "number", "of", "args", "is", "fixed", ",", "but", "if", "the", "number", "is", "variable", "then", "the", "caller", "must", "pop", "them", "all", ".", "RTD", "ca", "n't", "be", "used", "for", "library", "calls", "now", "because", "the", "library", "is", "compiled", "with", "the", "Unix", "compiler", ".", "Use", "of", "RTD", "is", "a", "selectable", "option", ",", "since", "it", "is", "incompatible", "with", "standard", "Unix", "calling", "sequences", ".", "If", "the", "option", "is", "not", "selected", ",", "the", "caller", "must", "always", "pop", "the", "args", "."], "TS_V_token": ["m68k", "0"], "File": "m68k4", "Func": "m68k_return_pops_args", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42657, "Length": 46}
{"ground_truth": ["<s>", "static", "bool", "m68k_save_reg", "(", "unsigned", "int", "regno", ",", "bool", "interrupt_handler", ")", "{", "if", "(", "flag_pic", "&&", "regno", "==", "PIC_REG", ")", "{", "if", "(", "crtl", "->", "saves_all_registers", ")", "return", "true", ";", "if", "(", "crtl", "->", "uses_pic_offset_table", ")", "return", "true", ";", "if", "(", "crtl", "->", "uses_const_pool", ")", "return", "true", ";", "}", "if", "(", "crtl", "->", "calls_eh_return", ")", "{", "unsigned", "int", "i", ";", "for", "(", "i", "=", "0", ";", ";", "i", "++", ")", "{", "unsigned", "int", "test", "=", "EH_RETURN_DATA_REGNO", "(", "i", ")", ";", "if", "(", "test", "==", "INVALID_REGNUM", ")", "break", ";", "if", "(", "test", "==", "regno", ")", "return", "true", ";", "}", "}", "if", "(", "fixed_regs", "[", "regno", "]", ")", "return", "false", ";", "if", "(", "regno", "==", "FRAME_POINTER_REGNUM", "&&", "frame_pointer_needed", ")", "return", "false", ";", "if", "(", "interrupt_handler", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", ")", "return", "true", ";", "if", "(", "!", "crtl", "->", "is_leaf", "&&", "call_used_regs", "[", "regno", "]", ")", "return", "true", ";", "}", "if", "(", "!", "df_regs_ever_live_p", "(", "regno", ")", ")", "return", "false", ";", "return", "!", "call_used_regs", "[", "regno", "]", ";", "}", "</s>"], "natrual_language": ["Refer", "to", "the", "array", "`", "regs_ever_live", "'", "to", "determine", "which", "registers", "to", "save", ";", "`", "regs_ever_live", "[", "I", "]", "'", "is", "nonzero", "if", "register", "number", "I", "is", "ever", "used", "in", "the", "function", ".", "This", "function", "is", "responsible", "for", "knowing", "which", "registers", "should", "not", "be", "saved", "even", "if", "used", ".", "Return", "true", "if", "we", "need", "to", "save", "REGNO", "."], "TS_V_token": ["m68k", "0"], "File": "m68k4", "Func": "m68k_save_reg", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42658, "Length": 170}
{"ground_truth": ["<s>", "static", "int", "m68k_sched_adjust_cost", "(", "rtx_insn", "*", "insn", ",", "rtx", "link", "ATTRIBUTE_UNUSED", ",", "rtx_insn", "*", "def_insn", ",", "int", "cost", ")", "{", "int", "delay", ";", "if", "(", "recog_memoized", "(", "def_insn", ")", "<", "0", "||", "recog_memoized", "(", "insn", ")", "<", "0", ")", "return", "cost", ";", "if", "(", "sched_cfv4_bypass_data", ".", "scale", "==", "1", ")", "{", "gcc_assert", "(", "sched_cfv4_bypass_data", ".", "pro", "==", "def_insn", "&&", "sched_cfv4_bypass_data", ".", "con", "==", "insn", ")", ";", "if", "(", "cost", "<", "3", ")", "cost", "=", "3", ";", "sched_cfv4_bypass_data", ".", "pro", "=", "NULL", ";", "sched_cfv4_bypass_data", ".", "con", "=", "NULL", ";", "sched_cfv4_bypass_data", ".", "scale", "=", "0", ";", "}", "else", "gcc_assert", "(", "sched_cfv4_bypass_data", ".", "pro", "==", "NULL", "&&", "sched_cfv4_bypass_data", ".", "con", "==", "NULL", "&&", "sched_cfv4_bypass_data", ".", "scale", "==", "0", ")", ";", "delay", "=", "min_insn_conflict_delay", "(", "sched_adjust_cost_state", ",", "def_insn", ",", "insn", ")", ";", "if", "(", "delay", ">", "cost", ")", "cost", "=", "delay", ";", "return", "cost", ";", "}", "</s>"], "natrual_language": ["Implement", "adjust_cost", "scheduler", "hook", ".", "Return", "adjusted", "COST", "of", "dependency", "LINK", "between", "DEF_INSN", "and", "INSN", "."], "TS_V_token": ["m68k", "0", "0", "1", "3", "3", "0", "0"], "File": "m68k4", "Func": "m68k_sched_adjust_cost", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42659, "Length": 142}
{"ground_truth": ["<s>", "void", "output_dbcc_and_branch", "(", "rtx", "*", "operands", ")", "{", "switch", "(", "GET_CODE", "(", "operands", "[", "3", "]", ")", ")", "{", "case", "EQ", ":", "output_asm_insn", "(", "\"dbeq %0,%l1\\n\\tjeq %l2\"", ",", "operands", ")", ";", "break", ";", "case", "NE", ":", "output_asm_insn", "(", "\"dbne %0,%l1\\n\\tjne %l2\"", ",", "operands", ")", ";", "break", ";", "case", "GT", ":", "output_asm_insn", "(", "\"dbgt %0,%l1\\n\\tjgt %l2\"", ",", "operands", ")", ";", "break", ";", "case", "GTU", ":", "output_asm_insn", "(", "\"dbhi %0,%l1\\n\\tjhi %l2\"", ",", "operands", ")", ";", "break", ";", "case", "LT", ":", "output_asm_insn", "(", "\"dblt %0,%l1\\n\\tjlt %l2\"", ",", "operands", ")", ";", "break", ";", "case", "LTU", ":", "output_asm_insn", "(", "\"dbcs %0,%l1\\n\\tjcs %l2\"", ",", "operands", ")", ";", "break", ";", "case", "GE", ":", "output_asm_insn", "(", "\"dbge %0,%l1\\n\\tjge %l2\"", ",", "operands", ")", ";", "break", ";", "case", "GEU", ":", "output_asm_insn", "(", "\"dbcc %0,%l1\\n\\tjcc %l2\"", ",", "operands", ")", ";", "break", ";", "case", "LE", ":", "output_asm_insn", "(", "\"dble %0,%l1\\n\\tjle %l2\"", ",", "operands", ")", ";", "break", ";", "case", "LEU", ":", "output_asm_insn", "(", "\"dbls %0,%l1\\n\\tjls %l2\"", ",", "operands", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ")", "{", "case", "SImode", ":", "output_asm_insn", "(", "\"clr%.w %0\\n\\tsubq%.l #1,%0\\n\\tjpl %l1\"", ",", "operands", ")", ";", "break", ";", "case", "HImode", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Output", "a", "dbCC", ";", "jCC", "sequence", ".", "Note", "we", "do", "not", "handle", "the", "floating", "point", "version", "of", "this", "sequence", "(", "Fdbcc", ")", ".", "We", "also", "do", "not", "handle", "alternative", "conditions", "when", "CC_NO_OVERFLOW", "is", "set", ".", "It", "is", "assumed", "that", "valid_dbcc_comparison_p", "and", "flags_in_68881", "will", "kick", "those", "out", "before", "we", "get", "here", "."], "TS_V_token": ["m68k", "3", "\"dbeq %0,%l1\\n\\tjeq %l2\"", "\"dbne %0,%l1\\n\\tjne %l2\"", "\"dbgt %0,%l1\\n\\tjgt %l2\"", "\"dbhi %0,%l1\\n\\tjhi %l2\"", "\"dblt %0,%l1\\n\\tjlt %l2\"", "\"dbcs %0,%l1\\n\\tjcs %l2\"", "\"dbge %0,%l1\\n\\tjge %l2\"", "\"dbcc %0,%l1\\n\\tjcc %l2\"", "\"dble %0,%l1\\n\\tjle %l2\"", "\"dbls %0,%l1\\n\\tjls %l2\"", "0", "\"clr%.w %0\\n\\tsubq%.l #1,%0\\n\\tjpl %l1\""], "File": "m68k4", "Func": "output_dbcc_and_branch", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42660, "Length": 182}
{"ground_truth": ["<s>", "static", "void", "output_reg_adjust", "(", "rtx", "reg", ",", "int", "n", ")", "{", "const", "char", "*", "s", ";", "gcc_assert", "(", "GET_MODE", "(", "reg", ")", "==", "SImode", "&&", "-", "12", "<=", "n", "&&", "n", "!=", "0", "&&", "n", "<=", "12", ")", ";", "switch", "(", "n", ")", "{", "case", "12", ":", "s", "=", "\"add%.l #12,%0\"", ";", "break", ";", "case", "8", ":", "s", "=", "\"addq%.l #8,%0\"", ";", "break", ";", "case", "4", ":", "s", "=", "\"addq%.l #4,%0\"", ";", "break", ";", "case", "-", "12", ":", "s", "=", "\"sub%.l #12,%0\"", ";", "break", ";", "case", "-", "8", ":", "s", "=", "\"subq%.l #8,%0\"", ";", "break", ";", "case", "-", "4", ":", "s", "=", "\"subq%.l #4,%0\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "s", "=", "NULL", ";", "}", "output_asm_insn", "(", "s", ",", "&", "reg", ")", ";", "}", "</s>"], "natrual_language": ["Output", "assembler", "code", "to", "adjust", "REG", "by", "N", "."], "TS_V_token": ["m68k", "12", "0", "12", "12", "\"add%.l #12,%0\"", "8", "\"addq%.l #8,%0\"", "4", "\"addq%.l #4,%0\"", "12", "\"sub%.l #12,%0\"", "8", "\"subq%.l #8,%0\"", "4", "\"subq%.l #4,%0\""], "File": "m68k4", "Func": "output_reg_adjust", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42661, "Length": 121}
{"ground_truth": ["<s>", "static", "enum", "attr_op_type", "sched_attr_op_type", "(", "rtx_insn", "*", "insn", ",", "bool", "opx_p", ",", "bool", "address_p", ")", "{", "rtx", "op", ";", "op", "=", "sched_get_operand", "(", "insn", ",", "opx_p", ")", ";", "if", "(", "op", "==", "NULL", ")", "{", "gcc_assert", "(", "!", "reload_completed", ")", ";", "return", "OP_TYPE_RN", ";", "}", "if", "(", "address_p", ")", "return", "sched_address_type", "(", "QImode", ",", "op", ")", ";", "if", "(", "memory_operand", "(", "op", ",", "VOIDmode", ")", ")", "return", "sched_address_type", "(", "GET_MODE", "(", "op", ")", ",", "XEXP", "(", "op", ",", "0", ")", ")", ";", "if", "(", "register_operand", "(", "op", ",", "VOIDmode", ")", ")", "{", "if", "(", "(", "!", "reload_completed", "&&", "FLOAT_MODE_P", "(", "GET_MODE", "(", "op", ")", ")", ")", "||", "(", "reload_completed", "&&", "FP_REG_P", "(", "op", ")", ")", ")", "return", "OP_TYPE_FPN", ";", "return", "OP_TYPE_RN", ";", "}", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", ")", "{", "int", "ival", ";", "ival", "=", "INTVAL", "(", "op", ")", ";", "switch", "(", "get_attr_type", "(", "insn", ")", ")", "{", "case", "TYPE_ALUQ_L", ":", "if", "(", "IN_RANGE", "(", "ival", ",", "1", ",", "8", ")", "||", "IN_RANGE", "(", "ival", ",", "-", "8", ",", "-", "1", ")", ")", "return", "OP_TYPE_IMM_Q", ";", "gcc_assert", "(", "!", "reload_completed", ")", ";", "break", ";", "case", "TYPE_MOVEQ_L", ":", "if", "(", "USE_MOVQ", "(", "ival", ")", ")", "return", "OP_TYPE_IMM_Q", ";", "gcc_assert", "(", "!", "reload_completed", ")", ";", "break", ";", "case", "TYPE_MOV3Q_L", ":", "if", "(", "valid_mov3q_const", "(", "ival", ")", ")", "return", "OP_TYPE_IMM_Q", ";", "gcc_assert", "(", "!", "reload_completed", ")", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "IN_RANGE", "(", "ival", ",", "-", "0x8000", ",", "0x7fff", ")", ")", "return", "OP_TYPE_IMM_W", ";", "return", "OP_TYPE_IMM_L", ";", "}", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_DOUBLE", ")", "{", "switch", "(", "GET_MODE", "(", "op", ")", ")", "{", "case", "SFmode", ":", "return", "OP_TYPE_IMM_W", ";", "case", "VOIDmode", ":", "case", "DFmode", ":", "return", "OP_TYPE_IMM_L", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST", "||", "symbolic_operand", "(", "op", ",", "VOIDmode", ")", "||", "LABEL_P", "(", "op", ")", ")", "{", "switch", "(", "GET_MODE", "(", "op", ")", ")", "{", "case", "QImode", ":", "return", "OP_TYPE_IMM_Q", ";", "case", "HImode", ":", "return", "OP_TYPE_IMM_W", ";", "case", "SImode", ":", "return", "OP_TYPE_IMM_L", ";", "default", ":", "if", "(", "symbolic_operand", "(", "m68k_unwrap_symbol", "(", "op", ",", "false", ")", ",", "VOIDmode", ")", ")", "return", "OP_TYPE_IMM_W", ";", "return", "OP_TYPE_IMM_L", ";", "}", "}", "gcc_assert", "(", "!", "reload_completed", ")", ";", "if", "(", "FLOAT_MODE_P", "(", "GET_MODE", "(", "op", ")", ")", ")", "return", "OP_TYPE_FPN", ";", "return", "OP_TYPE_RN", ";", "}", "</s>"], "natrual_language": ["Return", "type", "of", "INSN", "'s", "operand", "X", "(", "if", "OPX_P", ")", "or", "operand", "Y", "(", "if", "!", "OPX_P", ")", ".", "If", "ADDRESS_P", "is", "true", ",", "return", "type", "of", "memory", "location", "operand", "refers", "to", "."], "TS_V_token": ["m68k", "0", "1", "8", "8", "1", "0x8000", "0x7fff"], "File": "m68k4", "Func": "sched_attr_op_type", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42662, "Length": 389}
{"ground_truth": ["<s>", "int", "valid_dbcc_comparison_p_2", "(", "rtx", "x", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "EQ", ":", "case", "NE", ":", "case", "GTU", ":", "case", "LTU", ":", "case", "GEU", ":", "case", "LEU", ":", "return", "1", ";", "case", "GT", ":", "case", "LT", ":", "case", "GE", ":", "case", "LE", ":", "return", "!", "(", "cc_prev_status", ".", "flags", "&", "CC_NO_OVERFLOW", ")", ";", "default", ":", "return", "0", ";", "}", "}", "</s>"], "natrual_language": ["Return", "true", "if", "X", "is", "a", "valid", "comparison", "operator", "for", "the", "dbcc", "instruction", ".", "Note", "it", "rejects", "floating", "point", "comparison", "operators", ".", "(", "In", "the", "future", "we", "could", "use", "Fdbcc", ")", ".", "It", "also", "rejects", "some", "comparisons", "when", "CC_NO_OVERFLOW", "is", "set", "."], "TS_V_token": ["m68k", "1", "0"], "File": "m68k4", "Func": "valid_dbcc_comparison_p_2", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42663, "Length": 69}
{"ground_truth": ["<s>", "void", "output_dbcc_and_branch", "(", "rtx", "*", "operands", ")", "{", "switch", "(", "GET_CODE", "(", "operands", "[", "3", "]", ")", ")", "{", "case", "EQ", ":", "output_asm_insn", "(", "\"dbeq %0,%l1\\n\\tjeq %l2\"", ",", "operands", ")", ";", "break", ";", "case", "NE", ":", "output_asm_insn", "(", "\"dbne %0,%l1\\n\\tjne %l2\"", ",", "operands", ")", ";", "break", ";", "case", "GT", ":", "output_asm_insn", "(", "\"dbgt %0,%l1\\n\\tjgt %l2\"", ",", "operands", ")", ";", "break", ";", "case", "GTU", ":", "output_asm_insn", "(", "\"dbhi %0,%l1\\n\\tjhi %l2\"", ",", "operands", ")", ";", "break", ";", "case", "LT", ":", "output_asm_insn", "(", "\"dblt %0,%l1\\n\\tjlt %l2\"", ",", "operands", ")", ";", "break", ";", "case", "LTU", ":", "output_asm_insn", "(", "\"dbcs %0,%l1\\n\\tjcs %l2\"", ",", "operands", ")", ";", "break", ";", "case", "GE", ":", "output_asm_insn", "(", "\"dbge %0,%l1\\n\\tjge %l2\"", ",", "operands", ")", ";", "break", ";", "case", "GEU", ":", "output_asm_insn", "(", "\"dbcc %0,%l1\\n\\tjcc %l2\"", ",", "operands", ")", ";", "break", ";", "case", "LE", ":", "output_asm_insn", "(", "\"dble %0,%l1\\n\\tjle %l2\"", ",", "operands", ")", ";", "break", ";", "case", "LEU", ":", "output_asm_insn", "(", "\"dbls %0,%l1\\n\\tjls %l2\"", ",", "operands", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ")", "{", "case", "E_SImode", ":", "output_asm_insn", "(", "\"clr%.w %0\\n\\tsubq%.l #1,%0\\n\\tjpl %l1\"", ",", "operands", ")", ";", "break", ";", "case", "E_HImode", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Output", "a", "dbCC", ";", "jCC", "sequence", ".", "Note", "we", "do", "not", "handle", "the", "floating", "point", "version", "of", "this", "sequence", "(", "Fdbcc", ")", ".", "We", "also", "do", "not", "handle", "alternative", "conditions", "when", "CC_NO_OVERFLOW", "is", "set", ".", "It", "is", "assumed", "that", "valid_dbcc_comparison_p", "and", "flags_in_68881", "will", "kick", "those", "out", "before", "we", "get", "here", "."], "TS_V_token": ["m68k", "3", "\"dbeq %0,%l1\\n\\tjeq %l2\"", "\"dbne %0,%l1\\n\\tjne %l2\"", "\"dbgt %0,%l1\\n\\tjgt %l2\"", "\"dbhi %0,%l1\\n\\tjhi %l2\"", "\"dblt %0,%l1\\n\\tjlt %l2\"", "\"dbcs %0,%l1\\n\\tjcs %l2\"", "\"dbge %0,%l1\\n\\tjge %l2\"", "\"dbcc %0,%l1\\n\\tjcc %l2\"", "\"dble %0,%l1\\n\\tjle %l2\"", "\"dbls %0,%l1\\n\\tjls %l2\"", "0", "\"clr%.w %0\\n\\tsubq%.l #1,%0\\n\\tjpl %l1\""], "File": "m68k7", "Func": "output_dbcc_and_branch", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42664, "Length": 182}
{"ground_truth": ["<s>", "static", "int", "const_int_cost", "(", "HOST_WIDE_INT", "i", ")", "{", "switch", "(", "m68k_const_method", "(", "i", ")", ")", "{", "case", "MOVQ", ":", "return", "0", ";", "case", "MVZ", ":", "case", "MVS", ":", "case", "NOTB", ":", "case", "NOTW", ":", "case", "NEGW", ":", "case", "SWAP", ":", "return", "1", ";", "case", "MOVL", ":", "return", "2", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Return", "the", "cost", "of", "moving", "constant", "I", "into", "a", "data", "register", "."], "TS_V_token": ["m68k", "0", "1", "2"], "File": "m68k", "Func": "const_int_cost", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42665, "Length": 57}
{"ground_truth": ["<s>", "static", "rtx", "copy_operand", "(", "rtx", "op", ",", "machine_mode", "mode", ")", "{", "if", "(", "GET_MODE", "(", "op", ")", "!=", "VOIDmode", ")", "{", "if", "(", "REG_P", "(", "op", ")", ")", "op", "=", "gen_rtx_REG", "(", "mode", ",", "REGNO", "(", "op", ")", ")", ";", "else", "{", "op", "=", "copy_rtx", "(", "op", ")", ";", "PUT_MODE", "(", "op", ",", "mode", ")", ";", "}", "}", "return", "op", ";", "}", "</s>"], "natrual_language": ["Copy", "OP", "and", "change", "its", "mode", "to", "MODE", "."], "TS_V_token": ["m68k"], "File": "m68k", "Func": "copy_operand", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42666, "Length": 62}
{"ground_truth": ["<s>", "static", "void", "emit_movsi", "(", "rtx", "operands", "[", "2", "]", ")", "{", "operands", "[", "0", "]", "=", "copy_operand", "(", "operands", "[", "0", "]", ",", "SImode", ")", ";", "operands", "[", "1", "]", "=", "copy_operand", "(", "operands", "[", "1", "]", ",", "SImode", ")", ";", "emit_insn", "(", "gen_movsi", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", ";", "}", "</s>"], "natrual_language": ["Emit", "rtl", "code", "for", "moving", "operands", "[", "1", "]", "into", "operands", "[", "0", "]", "as", "a", "fullword", "."], "TS_V_token": ["m68k", "2", "0", "0", "1", "1", "0", "1"], "File": "m68k", "Func": "emit_movsi", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42667, "Length": 58}
{"ground_truth": ["<s>", "static", "void", "emit_reg_adjust", "(", "rtx", "reg1", ",", "int", "n", ")", "{", "rtx", "reg2", ";", "gcc_assert", "(", "GET_MODE", "(", "reg1", ")", "==", "SImode", "&&", "n", ">=", "-", "12", "&&", "n", "!=", "0", "&&", "n", "<=", "12", ")", ";", "reg1", "=", "copy_rtx", "(", "reg1", ")", ";", "reg2", "=", "copy_rtx", "(", "reg1", ")", ";", "if", "(", "n", "<", "0", ")", "emit_insn", "(", "gen_subsi3", "(", "reg1", ",", "reg2", ",", "GEN_INT", "(", "-", "n", ")", ")", ")", ";", "else", "if", "(", "n", ">", "0", ")", "emit_insn", "(", "gen_addsi3", "(", "reg1", ",", "reg2", ",", "GEN_INT", "(", "n", ")", ")", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>"], "natrual_language": ["Emit", "rtl", "code", "to", "adjust", "REG", "by", "N", "."], "TS_V_token": ["m68k", "12", "0", "12", "0", "0"], "File": "m68k", "Func": "emit_reg_adjust", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42668, "Length": 101}
{"ground_truth": ["<s>", "static", "rtx", "find_addr_reg", "(", "rtx", "addr", ")", "{", "while", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "REG", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "==", "REG", ")", "addr", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "if", "(", "CONSTANT_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", "addr", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "if", "(", "CONSTANT_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "addr", ")", "==", "REG", ")", ";", "return", "addr", ";", "}", "</s>"], "natrual_language": ["Return", "a", "REG", "that", "occurs", "in", "ADDR", "with", "coefficient", "1", ".", "ADDR", "can", "be", "effectively", "incremented", "by", "incrementing", "REG", ".", "r0", "is", "special", "and", "we", "must", "not", "select", "it", "as", "an", "address", "register", "by", "this", "routine", "since", "our", "caller", "will", "try", "to", "increment", "the", "returned", "register", "via", "an", "``", "la", "''", "instruction", "."], "TS_V_token": ["m68k", "0", "0", "1", "1", "0", "1", "1", "0"], "File": "m68k", "Func": "find_addr_reg", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42669, "Length": 129}
{"ground_truth": ["<s>", "int", "floating_exact_log2", "(", "rtx", "x", ")", "{", "const", "REAL_VALUE_TYPE", "*", "r", ";", "REAL_VALUE_TYPE", "r1", ";", "int", "exp", ";", "r", "=", "CONST_DOUBLE_REAL_VALUE", "(", "x", ")", ";", "if", "(", "real_less", "(", "r", ",", "&", "dconst1", ")", ")", "return", "0", ";", "exp", "=", "real_exponent", "(", "r", ")", ";", "real_2expN", "(", "&", "r1", ",", "exp", ",", "DFmode", ")", ";", "if", "(", "real_equal", "(", "&", "r1", ",", "r", ")", ")", "return", "exp", ";", "return", "0", ";", "}", "</s>"], "natrual_language": ["If", "X", "is", "a", "floating-point", "constant", ",", "return", "the", "logarithm", "of", "X", "base", "2", ",", "or", "0", "if", "X", "is", "not", "a", "power", "of", "2", "."], "TS_V_token": ["m68k", "0", "0"], "File": "m68k", "Func": "floating_exact_log2", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42670, "Length": 72}
{"ground_truth": ["<s>", "static", "rtx", "force_mode", "(", "machine_mode", "mode", ",", "rtx", "orig", ")", "{", "if", "(", "mode", "==", "GET_MODE", "(", "orig", ")", ")", "return", "orig", ";", "if", "(", "REGNO", "(", "orig", ")", ">=", "FIRST_PSEUDO_REGISTER", ")", "abort", "(", ")", ";", "return", "gen_rtx_REG", "(", "mode", ",", "REGNO", "(", "orig", ")", ")", ";", "}", "</s>"], "natrual_language": ["Ensure", "mode", "of", "ORIG", ",", "a", "REG", "rtx", ",", "is", "MODE", ".", "Returns", "either", "ORIG", "or", "a", "new", "rtx", "with", "the", "correct", "mode", "."], "TS_V_token": ["m68k"], "File": "m68k", "Func": "force_mode", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42671, "Length": 48}
{"ground_truth": ["<s>", "static", "int", "fp_reg_operand", "(", "rtx", "op", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "return", "reg_renumber", "&&", "FP_REG_P", "(", "op", ")", ";", "}", "</s>"], "natrual_language": ["Return", "truth", "value", "of", "whether", "OP", "can", "be", "used", "as", "a", "float", "register", "operand", ".", "Reject", "(", "SUBREG", ":", "SF", "(", "REG", ":", "SI", ")", ")", ")", ")"], "TS_V_token": ["m68k"], "File": "m68k", "Func": "fp_reg_operand", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42672, "Length": 21}
{"ground_truth": ["<s>", "static", "void", "handle_flags_for_move", "(", "rtx", "*", "operands", ")", "{", "flags_compare_op0", "=", "flags_compare_op1", "=", "NULL_RTX", ";", "if", "(", "!", "ADDRESS_REG_P", "(", "operands", "[", "0", "]", ")", ")", "{", "flags_valid", "=", "FLAGS_VALID_MOVE", ";", "flags_operand1", "=", "side_effects_p", "(", "operands", "[", "0", "]", ")", "?", "NULL_RTX", ":", "operands", "[", "0", "]", ";", "if", "(", "side_effects_p", "(", "operands", "[", "1", "]", ")", "||", "modified_in_p", "(", "operands", "[", "1", "]", ",", "current_output_insn", ")", ")", "flags_operand2", "=", "NULL_RTX", ";", "else", "flags_operand2", "=", "operands", "[", "1", "]", ";", "return", ";", "}", "if", "(", "flags_operand1", "!=", "NULL_RTX", "&&", "modified_in_p", "(", "flags_operand1", ",", "current_output_insn", ")", ")", "flags_operand1", "=", "NULL_RTX", ";", "if", "(", "flags_operand2", "!=", "NULL_RTX", "&&", "modified_in_p", "(", "flags_operand2", ",", "current_output_insn", ")", ")", "flags_operand2", "=", "NULL_RTX", ";", "}", "</s>"], "natrual_language": ["Update", "flags", "for", "a", "move", "operation", "with", "OPERANDS", ".", "Called", "for", "move", "operations", "where", "attr_flags_valid", "returns", "``", "set", "''", "."], "TS_V_token": ["m68k", "0", "0", "0", "1", "1", "1"], "File": "m68k", "Func": "handle_flags_for_move", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42673, "Length": 118}
{"ground_truth": ["<s>", "void", "init_68881_table", "(", "void", ")", "{", "int", "i", ";", "REAL_VALUE_TYPE", "r", ";", "machine_mode", "mode", ";", "mode", "=", "SFmode", ";", "for", "(", "i", "=", "0", ";", "i", "<", "7", ";", "i", "++", ")", "{", "if", "(", "i", "==", "6", ")", "mode", "=", "DFmode", ";", "r", "=", "REAL_VALUE_ATOF", "(", "strings_68881", "[", "i", "]", ",", "mode", ")", ";", "values_68881", "[", "i", "]", "=", "r", ";", "}", "inited_68881_table", "=", "1", ";", "}", "</s>"], "natrual_language": ["Set", "up", "values_68881", "array", "by", "converting", "the", "decimal", "values", "strings_68881", "to", "binary", "."], "TS_V_token": ["m68k", "0", "7", "6", "1"], "File": "m68k", "Func": "init_68881_table", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42674, "Length": 68}
{"ground_truth": ["<s>", "rtx", "legitimize_pic_address", "(", "rtx", "orig", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "reg", ")", "{", "rtx", "pic_ref", "=", "orig", ";", "if", "(", "GET_CODE", "(", "orig", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "orig", ")", "==", "LABEL_REF", ")", "{", "gcc_assert", "(", "reg", ")", ";", "pic_ref", "=", "m68k_wrap_symbol_into_got_ref", "(", "orig", ",", "RELOC_GOT", ",", "reg", ")", ";", "pic_ref", "=", "m68k_move_to_reg", "(", "pic_ref", ",", "orig", ",", "reg", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "orig", ")", "==", "CONST", ")", "{", "rtx", "base", ";", "if", "(", "m68k_unwrap_symbol", "(", "orig", ",", "true", ")", "!=", "orig", ")", "return", "orig", ";", "gcc_assert", "(", "reg", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "orig", ",", "0", ")", ")", "==", "PLUS", ")", ";", "base", "=", "legitimize_pic_address", "(", "XEXP", "(", "XEXP", "(", "orig", ",", "0", ")", ",", "0", ")", ",", "Pmode", ",", "reg", ")", ";", "orig", "=", "legitimize_pic_address", "(", "XEXP", "(", "XEXP", "(", "orig", ",", "0", ")", ",", "1", ")", ",", "Pmode", ",", "base", "==", "reg", "?", "0", ":", "reg", ")", ";", "if", "(", "GET_CODE", "(", "orig", ")", "==", "CONST_INT", ")", "pic_ref", "=", "plus_constant", "(", "Pmode", ",", "base", ",", "INTVAL", "(", "orig", ")", ")", ";", "else", "pic_ref", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "base", ",", "orig", ")", ";", "}", "return", "pic_ref", ";", "}", "</s>"], "natrual_language": ["Legitimize", "PIC", "addresses", ".", "If", "the", "address", "is", "already", "position-independent", ",", "we", "return", "ORIG", ".", "Newly", "generated", "position-independent", "addresses", "go", "into", "a", "reg", ".", "This", "is", "REG", "if", "nonzero", ",", "otherwise", "we", "allocate", "register", "(", "s", ")", "as", "necessary", "."], "TS_V_token": ["m68k", "0", "0", "0", "0", "1", "0"], "File": "m68k", "Func": "legitimize_pic_address", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42675, "Length": 200}
{"ground_truth": ["<s>", "static", "void", "m68k_adjust_decorated_operand", "(", "rtx", "op", ")", "{", "subrtx_var_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX_VAR", "(", "iter", ",", "array", ",", "op", ",", "ALL", ")", "{", "rtx", "x", "=", "*", "iter", ";", "if", "(", "m68k_unwrap_symbol", "(", "x", ",", "true", ")", "!=", "x", ")", "{", "rtx", "plus", ";", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", ";", "plus", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "plus", ")", "==", "PLUS", "||", "GET_CODE", "(", "plus", ")", "==", "MINUS", ")", "{", "rtx", "unspec", ";", "rtx", "addend", ";", "unspec", "=", "XEXP", "(", "plus", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "unspec", ")", "==", "UNSPEC", ")", ";", "addend", "=", "XEXP", "(", "plus", ",", "1", ")", ";", "gcc_assert", "(", "CONST_INT_P", "(", "addend", ")", ")", ";", "XEXP", "(", "plus", ",", "0", ")", "=", "XVECEXP", "(", "unspec", ",", "0", ",", "0", ")", ";", "XVECEXP", "(", "unspec", ",", "0", ",", "0", ")", "=", "plus", ";", "XEXP", "(", "x", ",", "0", ")", "=", "unspec", ";", "}", "iter", ".", "skip_subrtxes", "(", ")", ";", "}", "}", "}", "</s>"], "natrual_language": ["Adjust", "decorated", "address", "operand", "before", "outputing", "assembler", "for", "it", "."], "TS_V_token": ["m68k", "0", "0", "1", "0", "0", "0", "0", "0", "0"], "File": "m68k", "Func": "m68k_adjust_decorated_operand", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42676, "Length": 169}
{"ground_truth": ["<s>", "static", "void", "m68k_asm_final_postscan_insn", "(", "FILE", "*", ",", "rtx_insn", "*", "insn", ",", "rtx", "[", "]", ",", "int", ")", "{", "enum", "attr_flags_valid", "v", "=", "get_attr_flags_valid", "(", "insn", ")", ";", "if", "(", "v", "==", "FLAGS_VALID_SET", ")", "return", ";", "flags_compare_op0", "=", "flags_compare_op1", "=", "NULL_RTX", ";", "if", "(", "v", "==", "FLAGS_VALID_NO", ")", "{", "flags_operand1", "=", "flags_operand2", "=", "NULL_RTX", ";", "return", ";", "}", "else", "if", "(", "v", "==", "FLAGS_VALID_UNCHANGED", ")", "{", "if", "(", "flags_operand1", "!=", "NULL_RTX", "&&", "modified_in_p", "(", "flags_operand1", ",", "insn", ")", ")", "flags_operand1", "=", "NULL_RTX", ";", "if", "(", "flags_operand2", "!=", "NULL_RTX", "&&", "modified_in_p", "(", "flags_operand2", ",", "insn", ")", ")", "flags_operand2", "=", "NULL_RTX", ";", "return", ";", "}", "flags_valid", "=", "v", ";", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "rtx", "dest", "=", "SET_DEST", "(", "set", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "set", ")", ";", "if", "(", "side_effects_p", "(", "dest", ")", ")", "dest", "=", "NULL_RTX", ";", "switch", "(", "v", ")", "{", "case", "FLAGS_VALID_YES", ":", "case", "FLAGS_VALID_NOOV", ":", "flags_operand1", "=", "dest", ";", "flags_operand2", "=", "NULL_RTX", ";", "break", ";", "case", "FLAGS_VALID_MOVE", ":", "if", "(", "dest", "!=", "NULL_RTX", "&&", "!", "FP_REG_P", "(", "dest", ")", "&&", "(", "FP_REG_P", "(", "src", ")", "||", "GET_CODE", "(", "src", ")", "==", "FIX", "||", "FLOAT_MODE_P", "(", "GET_MODE", "(", "dest", ")", ")", ")", ")", "flags_operand1", "=", "flags_operand2", "=", "NULL_RTX", ";", "else", "{", "flags_operand1", "=", "dest", ";", "if", "(", "GET_MODE", "(", "src", ")", "!=", "VOIDmode", "&&", "!", "side_effects_p", "(", "src", ")", "&&", "!", "modified_in_p", "(", "src", ",", "insn", ")", ")", "flags_operand2", "=", "src", ";", "else", "flags_operand2", "=", "NULL_RTX", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", ";", "}", "</s>"], "natrual_language": ["Process", "INSN", "to", "remember", "flag", "operands", "if", "possible", "."], "TS_V_token": ["m68k"], "File": "m68k", "Func": "m68k_asm_final_postscan_insn", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42677, "Length": 256}
{"ground_truth": ["<s>", "static", "rtx", "m68k_call_m68k_read_tp", "(", "void", ")", "{", "rtx", "a0", ";", "rtx", "eqv", ";", "rtx_insn", "*", "insns", ";", "rtx", "dest", ";", "start_sequence", "(", ")", ";", "m68k_libcall_value_in_a0_p", "=", "true", ";", "a0", "=", "emit_library_call_value", "(", "m68k_get_m68k_read_tp", "(", ")", ",", "NULL_RTX", ",", "LCT_PURE", ",", "Pmode", ")", ";", "m68k_libcall_value_in_a0_p", "=", "false", ";", "insns", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "eqv", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "const1_rtx", ")", ",", "UNSPEC_RELOC32", ")", ";", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "dest", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_libcall_block", "(", "insns", ",", "dest", ",", "a0", ",", "eqv", ")", ";", "return", "dest", ";", "}", "</s>"], "natrual_language": ["Emit", "instruction", "sequence", "that", "calls", "__m68k_read_tp", ".", "A", "pseudo", "register", "with", "result", "of", "__m68k_read_tp", "call", "is", "returned", "."], "TS_V_token": ["m68k", "1"], "File": "m68k", "Func": "m68k_call_m68k_read_tp", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42678, "Length": 102}
{"ground_truth": ["<s>", "static", "rtx", "m68k_call_tls_get_addr", "(", "rtx", "x", ",", "rtx", "eqv", ",", "enum", "m68k_reloc", "reloc", ")", "{", "rtx", "a0", ";", "rtx_insn", "*", "insns", ";", "rtx", "dest", ";", "start_sequence", "(", ")", ";", "x", "=", "m68k_wrap_symbol", "(", "x", ",", "reloc", ",", "m68k_get_gp", "(", ")", ",", "NULL_RTX", ")", ";", "m68k_libcall_value_in_a0_p", "=", "true", ";", "a0", "=", "emit_library_call_value", "(", "m68k_get_tls_get_addr", "(", ")", ",", "NULL_RTX", ",", "LCT_PURE", ",", "Pmode", ",", "x", ",", "Pmode", ")", ";", "m68k_libcall_value_in_a0_p", "=", "false", ";", "insns", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "dest", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_libcall_block", "(", "insns", ",", "dest", ",", "a0", ",", "eqv", ")", ";", "return", "dest", ";", "}", "</s>"], "natrual_language": ["Emit", "instruction", "sequence", "that", "calls", "__tls_get_addr", ".", "X", "is", "the", "TLS", "symbol", "we", "are", "referencing", "and", "RELOC", "is", "the", "symbol", "type", "to", "use", "(", "either", "TLSGD", "or", "TLSLDM", ")", ".", "EQV", "is", "the", "REG_EQUAL", "note", "for", "the", "sequence", "emitted", ".", "A", "pseudo", "register", "with", "result", "of", "__tls_get_addr", "call", "is", "returned", "."], "TS_V_token": ["m68k"], "File": "m68k", "Func": "m68k_call_tls_get_addr", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42679, "Length": 110}
{"ground_truth": ["<s>", "static", "bool", "m68k_cannot_force_const_mem", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ")", "{", "return", "m68k_illegitimate_symbolic_constant_p", "(", "x", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_CANNOT_FORCE_CONST_MEM", "."], "TS_V_token": ["m68k"], "File": "m68k", "Func": "m68k_cannot_force_const_mem", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42680, "Length": 19}
{"ground_truth": ["<s>", "bool", "m68k_can_eliminate", "(", "const", "int", "from", "ATTRIBUTE_UNUSED", ",", "const", "int", "to", ")", "{", "return", "(", "to", "==", "STACK_POINTER_REGNUM", "?", "!", "frame_pointer_needed", ":", "true", ")", ";", "}", "</s>"], "natrual_language": ["Worker", "function", "for", "TARGET_CAN_ELIMINATE", "."], "TS_V_token": ["m68k"], "File": "m68k", "Func": "m68k_can_eliminate", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42681, "Length": 26}
{"ground_truth": ["<s>", "static", "void", "m68k_conditional_register_usage", "(", "void", ")", "{", "int", "i", ";", "HARD_REG_SET", "x", ";", "if", "(", "!", "TARGET_HARD_FLOAT", ")", "{", "x", "=", "reg_class_contents", "[", "FP_REGS", "]", ";", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "if", "(", "TEST_HARD_REG_BIT", "(", "x", ",", "i", ")", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "1", ";", "}", "if", "(", "flag_pic", ")", "fixed_regs", "[", "PIC_REG", "]", "=", "call_used_regs", "[", "PIC_REG", "]", "=", "1", ";", "}", "</s>"], "natrual_language": ["Make", "sure", "everything", "'s", "fine", "if", "we", "*", "do", "n't", "*", "have", "a", "given", "processor", ".", "This", "assumes", "that", "putting", "a", "register", "in", "fixed_regs", "will", "keep", "the", "compiler", "'s", "mitts", "completely", "off", "it", ".", "We", "do", "n't", "bother", "to", "zero", "it", "out", "of", "register", "classes", "."], "TS_V_token": ["m68k", "0", "1", "1"], "File": "m68k", "Func": "m68k_conditional_register_usage", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42682, "Length": 78}
{"ground_truth": ["<s>", "M68K_CONST_METHOD", "m68k_const_method", "(", "HOST_WIDE_INT", "i", ")", "{", "unsigned", "u", ";", "if", "(", "USE_MOVQ", "(", "i", ")", ")", "return", "MOVQ", ";", "if", "(", "!", "TARGET_COLDFIRE", ")", "{", "if", "(", "USE_MOVQ", "(", "i", "^", "0xff", ")", ")", "return", "NOTB", ";", "if", "(", "USE_MOVQ", "(", "i", "^", "0xffff", ")", ")", "return", "NOTW", ";", "if", "(", "i", "==", "-", "65408", ")", "return", "NEGW", ";", "}", "u", "=", "i", ";", "if", "(", "USE_MOVQ", "(", "(", "u", ">>", "16", ")", "|", "(", "u", "<<", "16", ")", ")", ")", "return", "SWAP", ";", "if", "(", "TARGET_ISAB", ")", "{", "if", "(", "i", ">=", "0", "&&", "i", "<=", "65535", ")", "return", "MVZ", ";", "if", "(", "i", ">=", "-", "32768", "&&", "i", "<=", "32767", ")", "return", "MVS", ";", "}", "return", "MOVL", ";", "}", "</s>"], "natrual_language": ["Return", "the", "type", "of", "move", "that", "should", "be", "used", "for", "integer", "I", "."], "TS_V_token": ["m68k", "0xff", "0xffff", "65408", "16", "16", "0", "65535", "32768", "32767"], "File": "m68k", "Func": "m68k_const_method", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42683, "Length": 122}
{"ground_truth": ["<s>", "const", "char", "*", "m68k_cpp_cpu_family", "(", "const", "char", "*", "prefix", ")", "{", "if", "(", "!", "m68k_cpu_entry", ")", "return", "NULL", ";", "return", "concat", "(", "\"__m\"", ",", "prefix", ",", "\"_family_\"", ",", "m68k_cpu_entry", "->", "family", ",", "NULL", ")", ";", "}", "</s>"], "natrual_language": ["Generate", "a", "macro", "of", "the", "form", "__mPREFIX_family_NAME", ",", "where", "PREFIX", "is", "the", "given", "argument", "and", "NAME", "is", "the", "name", "of", "the", "representative", "device", "for", "the", "-mcpu", "argument", "'s", "family", ".", "Return", "NULL", "if", "-mcpu", "was", "not", "passed", "."], "TS_V_token": ["m68k", "\"__m\"", "\"_family_\""], "File": "m68k", "Func": "m68k_cpp_cpu_family", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42684, "Length": 36}
{"ground_truth": ["<s>", "const", "char", "*", "m68k_cpp_cpu_ident", "(", "const", "char", "*", "prefix", ")", "{", "if", "(", "!", "m68k_cpu_entry", ")", "return", "NULL", ";", "return", "concat", "(", "\"__m\"", ",", "prefix", ",", "\"_cpu_\"", ",", "m68k_cpu_entry", "->", "name", ",", "NULL", ")", ";", "}", "</s>"], "natrual_language": ["Generate", "a", "macro", "of", "the", "form", "__mPREFIX_cpu_NAME", ",", "where", "PREFIX", "is", "the", "given", "argument", "and", "NAME", "is", "the", "argument", "passed", "to", "-mcpu", ".", "Return", "NULL", "if", "-mcpu", "was", "not", "passed", "."], "TS_V_token": ["m68k", "\"__m\"", "\"_cpu_\""], "File": "m68k", "Func": "m68k_cpp_cpu_ident", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42685, "Length": 36}
{"ground_truth": ["<s>", "static", "bool", "m68k_decompose_index", "(", "rtx", "x", ",", "bool", "strict_p", ",", "struct", "m68k_address", "*", "address", ")", "{", "int", "scale", ";", "scale", "=", "1", ";", "if", "(", "(", "TARGET_68020", "||", "TARGET_COLDFIRE", ")", "&&", "GET_CODE", "(", "x", ")", "==", "MULT", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", "&&", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "2", "||", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "4", "||", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "8", "&&", "(", "TARGET_COLDFIRE_FPU", "||", "!", "TARGET_COLDFIRE", ")", ")", ")", ")", "{", "scale", "=", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "}", "if", "(", "!", "TARGET_COLDFIRE", "&&", "GET_CODE", "(", "x", ")", "==", "SIGN_EXTEND", "&&", "GET_MODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "HImode", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "m68k_legitimate_index_reg_p", "(", "x", ",", "strict_p", ")", ")", "{", "address", "->", "scale", "=", "scale", ";", "address", "->", "index", "=", "x", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "X", "is", "a", "legitimate", "index", "expression", "for", "a", "(", "d8", ",", "An", ",", "Xn", ")", "or", "(", "bd", ",", "An", ",", "Xn", ")", "addressing", "mode", ".", "Fill", "in", "the", "INDEX", "and", "SCALE", "fields", "of", "ADDRESS", "if", "so", ".", "STRICT_P", "says", "whether", "we", "need", "strict", "checking", "."], "TS_V_token": ["m68k", "1", "1", "1", "2", "1", "4", "1", "8", "1", "0", "0", "0"], "File": "m68k", "Func": "m68k_decompose_index", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42686, "Length": 183}
{"ground_truth": ["<s>", "static", "rtx", "m68k_delegitimize_address", "(", "rtx", "orig_x", ")", "{", "rtx", "x", ";", "struct", "m68k_address", "addr", ";", "rtx", "unspec", ";", "orig_x", "=", "delegitimize_mem_from_attrs", "(", "orig_x", ")", ";", "x", "=", "orig_x", ";", "if", "(", "MEM_P", "(", "x", ")", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "PLUS", "||", "GET_MODE", "(", "x", ")", "!=", "Pmode", ")", "return", "orig_x", ";", "if", "(", "!", "m68k_decompose_address", "(", "GET_MODE", "(", "x", ")", ",", "x", ",", "false", ",", "&", "addr", ")", "||", "addr", ".", "offset", "==", "NULL_RTX", "||", "GET_CODE", "(", "addr", ".", "offset", ")", "!=", "CONST", ")", "return", "orig_x", ";", "unspec", "=", "XEXP", "(", "addr", ".", "offset", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "unspec", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "unspec", ",", "1", ")", ")", ")", "unspec", "=", "XEXP", "(", "unspec", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "unspec", ")", "!=", "UNSPEC", "||", "(", "XINT", "(", "unspec", ",", "1", ")", "!=", "UNSPEC_RELOC16", "&&", "XINT", "(", "unspec", ",", "1", ")", "!=", "UNSPEC_RELOC32", ")", ")", "return", "orig_x", ";", "x", "=", "XVECEXP", "(", "unspec", ",", "0", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", ";", "if", "(", "unspec", "!=", "XEXP", "(", "addr", ".", "offset", ",", "0", ")", ")", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "x", ",", "XEXP", "(", "XEXP", "(", "addr", ".", "offset", ",", "0", ")", ",", "1", ")", ")", ";", "if", "(", "addr", ".", "index", ")", "{", "rtx", "idx", "=", "addr", ".", "index", ";", "if", "(", "addr", ".", "scale", "!=", "1", ")", "idx", "=", "gen_rtx_MULT", "(", "Pmode", ",", "idx", ",", "GEN_INT", "(", "addr", ".", "scale", ")", ")", ";", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "idx", ",", "x", ")", ";", "}", "if", "(", "addr", ".", "base", ")", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "addr", ".", "base", ",", "x", ")", ";", "if", "(", "MEM_P", "(", "orig_x", ")", ")", "x", "=", "replace_equiv_address_nv", "(", "orig_x", ",", "x", ")", ";", "return", "x", ";", "}", "</s>"], "natrual_language": ["In", "the", "name", "of", "slightly", "smaller", "debug", "output", ",", "and", "to", "cater", "to", "general", "assembler", "lossage", ",", "recognize", "various", "UNSPEC", "sequences", "and", "turn", "them", "back", "into", "a", "direct", "symbol", "reference", "."], "TS_V_token": ["m68k", "0", "0", "1", "0", "1", "1", "0", "0", "0", "0", "1", "1"], "File": "m68k", "Func": "m68k_delegitimize_address", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42687, "Length": 324}
{"ground_truth": ["<s>", "static", "rtx_insn", "*", "m68k_emit_movem", "(", "rtx", "base", ",", "HOST_WIDE_INT", "offset", ",", "unsigned", "int", "count", ",", "unsigned", "int", "regno", ",", "unsigned", "int", "mask", ",", "bool", "store_p", ",", "bool", "adjust_stack_p", ")", "{", "int", "i", ";", "rtx", "body", ",", "addr", ",", "src", ",", "operands", "[", "2", "]", ";", "machine_mode", "mode", ";", "body", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "adjust_stack_p", "+", "count", ")", ")", ";", "mode", "=", "reg_raw_mode", "[", "regno", "]", ";", "i", "=", "0", ";", "if", "(", "adjust_stack_p", ")", "{", "src", "=", "plus_constant", "(", "Pmode", ",", "base", ",", "(", "count", "*", "GET_MODE_SIZE", "(", "mode", ")", "*", "(", "HOST_WIDE_INT", ")", "(", "store_p", "?", "-", "1", ":", "1", ")", ")", ")", ";", "XVECEXP", "(", "body", ",", "0", ",", "i", "++", ")", "=", "gen_rtx_SET", "(", "base", ",", "src", ")", ";", "}", "for", "(", ";", "mask", "!=", "0", ";", "mask", ">>=", "1", ",", "regno", "++", ")", "if", "(", "mask", "&", "1", ")", "{", "addr", "=", "plus_constant", "(", "Pmode", ",", "base", ",", "offset", ")", ";", "operands", "[", "!", "store_p", "]", "=", "gen_frame_mem", "(", "mode", ",", "addr", ")", ";", "operands", "[", "store_p", "]", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "XVECEXP", "(", "body", ",", "0", ",", "i", "++", ")", "=", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "offset", "+=", "GET_MODE_SIZE", "(", "mode", ")", ";", "}", "gcc_assert", "(", "i", "==", "XVECLEN", "(", "body", ",", "0", ")", ")", ";", "return", "emit_insn", "(", "body", ")", ";", "}", "</s>"], "natrual_language": ["Emit", "RTL", "for", "a", "MOVEM", "or", "FMOVEM", "instruction", ".", "BASE", "+", "OFFSET", "represents", "the", "lowest", "memory", "address", ".", "COUNT", "is", "the", "number", "of", "registers", "to", "be", "moved", ",", "with", "register", "REGNO", "+", "I", "being", "moved", "if", "bit", "I", "of", "MASK", "is", "set", ".", "STORE_P", "specifies", "the", "direction", "of", "the", "move", "and", "ADJUST_STACK_P", "says", "whether", "or", "not", "this", "is", "pre-decrement", "(", "if", "STORE_P", ")", "or", "post-increment", "(", "if", "!", "STORE_P", ")", "operation", "."], "TS_V_token": ["m68k", "2", "0", "1", "1", "0", "0", "1", "1", "0", "0", "1", "0"], "File": "m68k", "Func": "m68k_emit_movem", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42688, "Length": 233}
{"ground_truth": ["<s>", "void", "m68k_emit_move_double", "(", "rtx", "operands", "[", "2", "]", ")", "{", "handle_move_double", "(", "operands", ",", "emit_reg_adjust", ",", "emit_movsi", ",", "emit_movsi", ")", ";", "}", "</s>"], "natrual_language": ["Output", "rtl", "code", "to", "perform", "a", "doubleword", "move", "insn", "with", "operands", "OPERANDS", "."], "TS_V_token": ["m68k", "2"], "File": "m68k", "Func": "m68k_emit_move_double", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42689, "Length": 22}
{"ground_truth": ["<s>", "bool", "m68k_epilogue_uses", "(", "int", "regno", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "reload_completed", "&&", "(", "m68k_get_function_kind", "(", "current_function_decl", ")", "==", "m68k_fk_interrupt_handler", ")", ")", ";", "}", "</s>"], "natrual_language": ["Implements", "EPILOGUE_USES", ".", "All", "registers", "are", "live", "on", "exit", "from", "an", "interrupt", "routine", "."], "TS_V_token": ["m68k"], "File": "m68k", "Func": "m68k_epilogue_uses", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42690, "Length": 23}
{"ground_truth": ["<s>", "static", "enum", "flt_eval_method", "m68k_excess_precision", "(", "enum", "excess_precision_type", "type", ")", "{", "switch", "(", "type", ")", "{", "case", "EXCESS_PRECISION_TYPE_FAST", ":", "return", "FLT_EVAL_METHOD_PROMOTE_TO_FLOAT", ";", "case", "EXCESS_PRECISION_TYPE_STANDARD", ":", "case", "EXCESS_PRECISION_TYPE_IMPLICIT", ":", "if", "(", "TARGET_68040", "||", "!", "TARGET_68881", ")", "return", "FLT_EVAL_METHOD_PROMOTE_TO_FLOAT", ";", "return", "FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE", ";", "case", "EXCESS_PRECISION_TYPE_FLOAT16", ":", "error", "(", "\"%<-fexcess-precision=16%> is not supported on this target\"", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "FLT_EVAL_METHOD_UNPREDICTABLE", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_C_EXCESS_PRECISION", ".", "Set", "the", "value", "of", "FLT_EVAL_METHOD", "in", "float.h", ".", "When", "using", "68040", "fp", "instructions", ",", "we", "get", "proper", "intermediate", "rounding", ",", "otherwise", "we", "get", "extended", "precision", "results", "."], "TS_V_token": ["m68k", "\"%<-fexcess-precision=16%> is not supported on this target\""], "File": "m68k", "Func": "m68k_excess_precision", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42691, "Length": 61}
{"ground_truth": ["<s>", "rtx_code", "m68k_find_flags_value", "(", "rtx", "op0", ",", "rtx", "op1", ",", "rtx_code", "code", ")", "{", "if", "(", "flags_compare_op0", "!=", "NULL_RTX", ")", "{", "if", "(", "rtx_equal_p", "(", "op0", ",", "flags_compare_op0", ")", "&&", "rtx_equal_p", "(", "op1", ",", "flags_compare_op1", ")", ")", "return", "code", ";", "if", "(", "rtx_equal_p", "(", "op0", ",", "flags_compare_op1", ")", "&&", "rtx_equal_p", "(", "op1", ",", "flags_compare_op0", ")", ")", "return", "swap_condition", "(", "code", ")", ";", "return", "UNKNOWN", ";", "}", "machine_mode", "mode", "=", "GET_MODE", "(", "op0", ")", ";", "if", "(", "op1", "!=", "CONST0_RTX", "(", "mode", ")", ")", "return", "UNKNOWN", ";", "gcc_assert", "(", "code", "!=", "LTU", "&&", "code", "!=", "GEU", ")", ";", "if", "(", "flags_valid", "==", "FLAGS_VALID_NOOV", "&&", "(", "code", "==", "GT", "||", "code", "==", "LE", ")", ")", "return", "UNKNOWN", ";", "if", "(", "rtx_equal_p", "(", "flags_operand1", ",", "op0", ")", "||", "rtx_equal_p", "(", "flags_operand2", ",", "op0", ")", ")", "return", "(", "FLOAT_MODE_P", "(", "mode", ")", "?", "code", ":", "code", "==", "GE", "?", "PLUS", ":", "code", "==", "LT", "?", "MINUS", ":", "code", ")", ";", "if", "(", "code", "!=", "GE", "&&", "code", "!=", "LT", ")", "return", "UNKNOWN", ";", "if", "(", "mode", "==", "SImode", "&&", "flags_operand1", "!=", "NULL_RTX", "&&", "GET_MODE", "(", "flags_operand1", ")", "==", "DImode", "&&", "REG_P", "(", "flags_operand1", ")", "&&", "REG_P", "(", "op0", ")", "&&", "hard_regno_nregs", "(", "REGNO", "(", "flags_operand1", ")", ",", "DImode", ")", "==", "2", "&&", "REGNO", "(", "flags_operand1", ")", "==", "REGNO", "(", "op0", ")", ")", "return", "code", "==", "GE", "?", "PLUS", ":", "MINUS", ";", "if", "(", "mode", "==", "SImode", "&&", "flags_operand2", "!=", "NULL_RTX", "&&", "GET_MODE", "(", "flags_operand2", ")", "==", "DImode", "&&", "REG_P", "(", "flags_operand2", ")", "&&", "REG_P", "(", "op0", ")", "&&", "hard_regno_nregs", "(", "REGNO", "(", "flags_operand2", ")", ",", "DImode", ")", "==", "2", "&&", "REGNO", "(", "flags_operand2", ")", "==", "REGNO", "(", "op0", ")", ")", "return", "code", "==", "GE", "?", "PLUS", ":", "MINUS", ";", "return", "UNKNOWN", ";", "}", "</s>"], "natrual_language": ["Return", "a", "code", "other", "than", "UNKNOWN", "if", "we", "can", "elide", "a", "CODE", "comparison", "of", "OP0", "with", "OP1", "."], "TS_V_token": ["m68k", "2", "2"], "File": "m68k", "Func": "m68k_find_flags_value", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42692, "Length": 288}
{"ground_truth": ["<s>", "static", "rtx", "m68k_function_arg", "(", "cumulative_args_t", ",", "const", "function_arg_info", "&", ")", "{", "return", "NULL_RTX", ";", "}", "</s>"], "natrual_language": ["On", "the", "m68k", "all", "args", "are", "always", "pushed", "."], "TS_V_token": ["m68k"], "File": "m68k", "Func": "m68k_function_arg", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42693, "Length": 15}
{"ground_truth": ["<s>", "rtx", "m68k_function_value", "(", "const_tree", "valtype", ",", "const_tree", "func", "ATTRIBUTE_UNUSED", ")", "{", "machine_mode", "mode", ";", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_SFmode", ":", "case", "E_DFmode", ":", "case", "E_XFmode", ":", "if", "(", "TARGET_68881", ")", "return", "gen_rtx_REG", "(", "mode", ",", "FP0_REG", ")", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "func", "&&", "POINTER_TYPE_P", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "func", ")", ")", ")", ")", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "2", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode", ",", "A0_REG", ")", ",", "const0_rtx", ")", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode", ",", "D0_REG", ")", ",", "const0_rtx", ")", ")", ")", ";", "else", "if", "(", "POINTER_TYPE_P", "(", "valtype", ")", ")", "return", "gen_rtx_REG", "(", "mode", ",", "A0_REG", ")", ";", "else", "return", "gen_rtx_REG", "(", "mode", ",", "D0_REG", ")", ";", "}", "</s>"], "natrual_language": ["Location", "in", "which", "function", "value", "is", "returned", ".", "NOTE", ":", "Due", "to", "differences", "in", "ABIs", ",", "do", "n't", "call", "this", "function", "directly", ",", "use", "FUNCTION_VALUE", "instead", "."], "TS_V_token": ["m68k", "2"], "File": "m68k", "Func": "m68k_function_value", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42694, "Length": 134}
{"ground_truth": ["<s>", "enum", "m68k_function_kind", "m68k_get_function_kind", "(", "tree", "func", ")", "{", "tree", "a", ";", "gcc_assert", "(", "TREE_CODE", "(", "func", ")", "==", "FUNCTION_DECL", ")", ";", "a", "=", "lookup_attribute", "(", "\"interrupt\"", ",", "DECL_ATTRIBUTES", "(", "func", ")", ")", ";", "if", "(", "a", "!=", "NULL_TREE", ")", "return", "m68k_fk_interrupt_handler", ";", "a", "=", "lookup_attribute", "(", "\"interrupt_handler\"", ",", "DECL_ATTRIBUTES", "(", "func", ")", ")", ";", "if", "(", "a", "!=", "NULL_TREE", ")", "return", "m68k_fk_interrupt_handler", ";", "a", "=", "lookup_attribute", "(", "\"interrupt_thread\"", ",", "DECL_ATTRIBUTES", "(", "func", ")", ")", ";", "if", "(", "a", "!=", "NULL_TREE", ")", "return", "m68k_fk_interrupt_thread", ";", "return", "m68k_fk_normal_function", ";", "}", "</s>"], "natrual_language": ["Return", "m68k_fk_interrupt_handler", "if", "FUNC", "has", "an", "``", "interrupt", "''", "or", "``", "interrupt_handler", "''", "attribute", "and", "interrupt_thread", "if", "FUNC", "has", "an", "``", "interrupt_thread", "''", "attribute", ".", "Otherwise", ",", "return", "m68k_fk_normal_function", "."], "TS_V_token": ["m68k", "\"interrupt\"", "\"interrupt_handler\"", "\"interrupt_thread\""], "File": "m68k", "Func": "m68k_get_function_kind", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42695, "Length": 88}
{"ground_truth": ["<s>", "static", "rtx", "m68k_get_gp", "(", "void", ")", "{", "if", "(", "pic_offset_table_rtx", "==", "NULL_RTX", ")", "pic_offset_table_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "PIC_REG", ")", ";", "crtl", "->", "uses_pic_offset_table", "=", "1", ";", "return", "pic_offset_table_rtx", ";", "}", "</s>"], "natrual_language": ["Return", "GOT", "pointer", "."], "TS_V_token": ["m68k", "1"], "File": "m68k", "Func": "m68k_get_gp", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42696, "Length": 32}
{"ground_truth": ["<s>", "static", "rtx", "m68k_get_m68k_read_tp", "(", "void", ")", "{", "if", "(", "m68k_read_tp", "==", "NULL_RTX", ")", "m68k_read_tp", "=", "init_one_libfunc", "(", "\"__m68k_read_tp\"", ")", ";", "return", "m68k_read_tp", ";", "}", "</s>"], "natrual_language": ["Return", "SYMBOL_REF", "for", "__m68k_read_tp", "."], "TS_V_token": ["m68k", "\"__m68k_read_tp\""], "File": "m68k", "Func": "m68k_get_m68k_read_tp", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42697, "Length": 24}
{"ground_truth": ["<s>", "static", "const", "char", "*", "m68k_get_reloc_decoration", "(", "enum", "m68k_reloc", "reloc", ")", "{", "gcc_assert", "(", "MOTOROLA", "||", "reloc", "==", "RELOC_GOT", ")", ";", "switch", "(", "reloc", ")", "{", "case", "RELOC_GOT", ":", "if", "(", "MOTOROLA", ")", "{", "if", "(", "flag_pic", "==", "1", "&&", "TARGET_68020", ")", "return", "\"@GOT.w\"", ";", "else", "return", "\"@GOT\"", ";", "}", "else", "{", "if", "(", "TARGET_68020", ")", "{", "switch", "(", "flag_pic", ")", "{", "case", "1", ":", "return", "\":w\"", ";", "case", "2", ":", "return", "\":l\"", ";", "default", ":", "return", "\"\"", ";", "}", "}", "}", "gcc_unreachable", "(", ")", ";", "case", "RELOC_TLSGD", ":", "return", "\"@TLSGD\"", ";", "case", "RELOC_TLSLDM", ":", "return", "\"@TLSLDM\"", ";", "case", "RELOC_TLSLDO", ":", "return", "\"@TLSLDO\"", ";", "case", "RELOC_TLSIE", ":", "return", "\"@TLSIE\"", ";", "case", "RELOC_TLSLE", ":", "return", "\"@TLSLE\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Return", "string", "for", "TLS", "relocation", "RELOC", "."], "TS_V_token": ["m68k", "1", "\"@GOT.w\"", "\"@GOT\"", "1", "\":w\"", "2", "\":l\"", "\"\"", "\"@TLSGD\"", "\"@TLSLDM\"", "\"@TLSLDO\"", "\"@TLSIE\"", "\"@TLSLE\""], "File": "m68k", "Func": "m68k_get_reloc_decoration", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42698, "Length": 123}
{"ground_truth": ["<s>", "static", "rtx", "m68k_get_tls_get_addr", "(", "void", ")", "{", "if", "(", "m68k_tls_get_addr", "==", "NULL_RTX", ")", "m68k_tls_get_addr", "=", "init_one_libfunc", "(", "\"__tls_get_addr\"", ")", ";", "return", "m68k_tls_get_addr", ";", "}", "</s>"], "natrual_language": ["Return", "SYMBOL_REF", "for", "__tls_get_addr", "."], "TS_V_token": ["m68k", "\"__tls_get_addr\""], "File": "m68k", "Func": "m68k_get_tls_get_addr", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42699, "Length": 24}
{"ground_truth": ["<s>", "static", "tree", "m68k_handle_fndecl_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_DECL", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute only applies to functions\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "if", "(", "m68k_get_function_kind", "(", "*", "node", ")", "!=", "m68k_fk_normal_function", ")", "{", "error", "(", "\"multiple interrupt attributes not allowed\"", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "if", "(", "!", "TARGET_FIDOA", "&&", "!", "strcmp", "(", "IDENTIFIER_POINTER", "(", "name", ")", ",", "\"interrupt_thread\"", ")", ")", "{", "error", "(", "\"%<interrupt_thread%> is available only on fido\"", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>"], "natrual_language": ["Handle", "an", "attribute", "requiring", "a", "FUNCTION_DECL", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "."], "TS_V_token": ["m68k", "\"%qE attribute only applies to functions\"", "\"multiple interrupt attributes not allowed\"", "\"interrupt_thread\"", "\"%<interrupt_thread%> is available only on fido\""], "File": "m68k", "Func": "m68k_handle_fndecl_attribute", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42700, "Length": 104}
{"ground_truth": ["<s>", "static", "bool", "m68k_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "DATA_REGNO_P", "(", "regno", ")", ")", "{", "if", "(", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", "/", "4", "<=", "8", ")", "return", "true", ";", "}", "else", "if", "(", "ADDRESS_REGNO_P", "(", "regno", ")", ")", "{", "if", "(", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", "/", "4", "<=", "16", ")", "return", "true", ";", "}", "else", "if", "(", "FP_REGNO_P", "(", "regno", ")", ")", "{", "if", "(", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", ")", "&&", "GET_MODE_UNIT_SIZE", "(", "mode", ")", "<=", "TARGET_FP_REG_SIZE", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_HARD_REGNO_MODE_OK", ".", "On", "the", "68000", ",", "we", "let", "the", "cpu", "registers", "can", "hold", "any", "mode", ",", "but", "restrict", "the", "68881", "registers", "to", "floating-point", "modes", "."], "TS_V_token": ["m68k", "4", "8", "4", "16"], "File": "m68k", "Func": "m68k_hard_regno_mode_ok", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42701, "Length": 105}
{"ground_truth": ["<s>", "static", "unsigned", "int", "m68k_hard_regno_nregs", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "regno", ">=", "16", ")", "return", "GET_MODE_NUNITS", "(", "mode", ")", ";", "return", "CEIL", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "UNITS_PER_WORD", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_HARD_REGNO_NREGS", ".", "On", "the", "m68k", ",", "ordinary", "registers", "hold", "32", "bits", "worth", ";", "for", "the", "68881", "registers", ",", "a", "single", "register", "is", "always", "enough", "for", "anything", "that", "can", "be", "stored", "in", "them", "at", "all", "."], "TS_V_token": ["m68k", "16"], "File": "m68k", "Func": "m68k_hard_regno_nregs", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42702, "Length": 37}
{"ground_truth": ["<s>", "int", "m68k_hard_regno_rename_ok", "(", "unsigned", "int", "old_reg", "ATTRIBUTE_UNUSED", ",", "unsigned", "int", "new_reg", ")", "{", "if", "(", "(", "m68k_get_function_kind", "(", "current_function_decl", ")", "==", "m68k_fk_interrupt_handler", ")", "&&", "!", "df_regs_ever_live_p", "(", "new_reg", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>"], "natrual_language": ["Return", "nonzero", "if", "register", "old_reg", "can", "be", "renamed", "to", "register", "new_reg", "."], "TS_V_token": ["m68k", "0", "1"], "File": "m68k", "Func": "m68k_hard_regno_rename_ok", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42703, "Length": 37}
{"ground_truth": ["<s>", "bool", "m68k_illegitimate_symbolic_constant_p", "(", "rtx", "x", ")", "{", "rtx", "base", ",", "offset", ";", "if", "(", "M68K_OFFSETS_MUST_BE_WITHIN_SECTIONS_P", ")", "{", "split_const", "(", "x", ",", "&", "base", ",", "&", "offset", ")", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "SYMBOL_REF", "&&", "!", "offset_within_block_p", "(", "base", ",", "INTVAL", "(", "offset", ")", ")", ")", "return", "true", ";", "}", "return", "m68k_tls_reference_p", "(", "x", ",", "false", ")", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "X", "is", "an", "illegitimate", "symbolic", "constant", "."], "TS_V_token": ["m68k"], "File": "m68k", "Func": "m68k_illegitimate_symbolic_constant_p", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42704, "Length": 61}
{"ground_truth": ["<s>", "void", "m68k_init_cc", "(", ")", "{", "flags_compare_op0", "=", "flags_compare_op1", "=", "NULL_RTX", ";", "flags_operand1", "=", "flags_operand2", "=", "NULL_RTX", ";", "flags_valid", "=", "FLAGS_VALID_NO", ";", "}", "</s>"], "natrual_language": ["Called", "through", "CC_STATUS_INIT", ",", "which", "is", "invoked", "by", "final", "whenever", "a", "label", "is", "encountered", "."], "TS_V_token": ["m68k"], "File": "m68k", "Func": "m68k_init_cc", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42705, "Length": 22}
{"ground_truth": ["<s>", "static", "bool", "m68k_jump_table_ref_p", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "!=", "LABEL_REF", ")", "return", "false", ";", "rtx_insn", "*", "insn", "=", "as_a", "<", "rtx_insn", "*", ">", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "if", "(", "!", "NEXT_INSN", "(", "insn", ")", "&&", "!", "PREV_INSN", "(", "insn", ")", ")", "return", "true", ";", "insn", "=", "next_nonnote_insn", "(", "insn", ")", ";", "return", "insn", "&&", "JUMP_TABLE_DATA_P", "(", "insn", ")", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "X", "is", "a", "LABEL_REF", "for", "a", "jump", "table", ".", "Assume", "that", "unplaced", "labels", "will", "become", "jump", "tables", "."], "TS_V_token": ["m68k", "0"], "File": "m68k", "Func": "m68k_jump_table_ref_p", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42706, "Length": 71}
{"ground_truth": ["<s>", "bool", "m68k_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "strict_p", ")", "{", "struct", "m68k_address", "address", ";", "return", "m68k_decompose_address", "(", "mode", ",", "x", ",", "strict_p", ",", "&", "address", ")", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "X", "is", "a", "legitimate", "address", "for", "values", "of", "mode", "MODE", ".", "STRICT_P", "says", "whether", "strict", "checking", "is", "needed", "."], "TS_V_token": ["m68k"], "File": "m68k", "Func": "m68k_legitimate_address_p", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42707, "Length": 31}
{"ground_truth": ["<s>", "bool", "m68k_legitimate_base_reg_p", "(", "rtx", "x", ",", "bool", "strict_p", ")", "{", "if", "(", "!", "strict_p", "&&", "GET_CODE", "(", "x", ")", "==", "SUBREG", ")", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "return", "(", "REG_P", "(", "x", ")", "&&", "(", "strict_p", "?", "REGNO_OK_FOR_BASE_P", "(", "REGNO", "(", "x", ")", ")", ":", "REGNO_OK_FOR_BASE_NONSTRICT_P", "(", "REGNO", "(", "x", ")", ")", ")", ")", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "X", "is", "a", "legitimate", "base", "register", ".", "STRICT_P", "says", "whether", "we", "need", "strict", "checking", "."], "TS_V_token": ["m68k"], "File": "m68k", "Func": "m68k_legitimate_base_reg_p", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42708, "Length": 58}
{"ground_truth": ["<s>", "static", "bool", "m68k_legitimate_constant_address_p", "(", "rtx", "x", ",", "unsigned", "int", "reach", ",", "bool", "strict_p", ")", "{", "rtx", "base", ",", "offset", ";", "if", "(", "!", "CONSTANT_ADDRESS_P", "(", "x", ")", ")", "return", "false", ";", "if", "(", "flag_pic", "&&", "!", "(", "strict_p", "&&", "TARGET_PCREL", ")", "&&", "symbolic_operand", "(", "x", ",", "VOIDmode", ")", ")", "return", "false", ";", "if", "(", "M68K_OFFSETS_MUST_BE_WITHIN_SECTIONS_P", "&&", "reach", ">", "1", ")", "{", "split_const", "(", "x", ",", "&", "base", ",", "&", "offset", ")", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "SYMBOL_REF", "&&", "!", "offset_within_block_p", "(", "base", ",", "INTVAL", "(", "offset", ")", "+", "reach", "-", "1", ")", ")", "return", "false", ";", "}", "return", "!", "m68k_tls_reference_p", "(", "x", ",", "false", ")", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "X", "is", "a", "legitimate", "constant", "address", "that", "can", "reach", "bytes", "in", "the", "range", "[", "X", ",", "X", "+", "REACH", ")", ".", "STRICT_P", "says", "whether", "we", "need", "strict", "checking", "."], "TS_V_token": ["m68k", "1", "1"], "File": "m68k", "Func": "m68k_legitimate_constant_address_p", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42709, "Length": 110}
{"ground_truth": ["<s>", "bool", "m68k_legitimate_constant_p", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "return", "mode", "!=", "XFmode", "&&", "!", "m68k_illegitimate_symbolic_constant_p", "(", "x", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_LEGITIMATE_CONSTANT_P", "."], "TS_V_token": ["m68k"], "File": "m68k", "Func": "m68k_legitimate_constant_p", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42710, "Length": 22}
{"ground_truth": ["<s>", "bool", "m68k_legitimate_index_reg_p", "(", "rtx", "x", ",", "bool", "strict_p", ")", "{", "if", "(", "!", "strict_p", "&&", "GET_CODE", "(", "x", ")", "==", "SUBREG", ")", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "return", "(", "REG_P", "(", "x", ")", "&&", "(", "strict_p", "?", "REGNO_OK_FOR_INDEX_P", "(", "REGNO", "(", "x", ")", ")", ":", "REGNO_OK_FOR_INDEX_NONSTRICT_P", "(", "REGNO", "(", "x", ")", ")", ")", ")", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "X", "is", "a", "legitimate", "index", "register", ".", "STRICT_P", "says", "whether", "we", "need", "strict", "checking", "."], "TS_V_token": ["m68k"], "File": "m68k", "Func": "m68k_legitimate_index_reg_p", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42711, "Length": 58}
{"ground_truth": ["<s>", "static", "bool", "m68k_legitimate_mem_p", "(", "rtx", "x", ",", "struct", "m68k_address", "*", "address", ")", "{", "return", "(", "MEM_P", "(", "x", ")", "&&", "m68k_decompose_address", "(", "GET_MODE", "(", "x", ")", ",", "XEXP", "(", "x", ",", "0", ")", ",", "reload_in_progress", "||", "reload_completed", ",", "address", ")", ")", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "X", "is", "a", "memory", ",", "describing", "its", "address", "in", "ADDRESS", "if", "so", ".", "Apply", "strict", "checking", "if", "called", "during", "or", "after", "reload", "."], "TS_V_token": ["m68k", "0"], "File": "m68k", "Func": "m68k_legitimate_mem_p", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42712, "Length": 43}
{"ground_truth": ["<s>", "static", "rtx", "m68k_legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", ",", "machine_mode", "mode", ")", "{", "if", "(", "m68k_tls_symbol_p", "(", "x", ")", ")", "return", "m68k_legitimize_tls_address", "(", "x", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "int", "ch", "=", "(", "x", ")", "!=", "(", "oldx", ")", ";", "int", "copied", "=", "0", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "MULT", ")", "{", "COPY_ONCE", "(", "x", ")", ";", "XEXP", "(", "x", ",", "0", ")", "=", "force_operand", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "MULT", ")", "{", "COPY_ONCE", "(", "x", ")", ";", "XEXP", "(", "x", ",", "1", ")", "=", "force_operand", "(", "XEXP", "(", "x", ",", "1", ")", ",", "0", ")", ";", "}", "if", "(", "ch", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "REG", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "REG", ")", "{", "if", "(", "TARGET_COLDFIRE_FPU", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", "{", "COPY_ONCE", "(", "x", ")", ";", "x", "=", "force_operand", "(", "x", ",", "0", ")", ";", "}", "return", "x", ";", "}", "if", "(", "memory_address_p", "(", "mode", ",", "x", ")", ")", "return", "x", ";", "}", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "REG", "||", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "SIGN_EXTEND", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "REG", "&&", "GET_MODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "HImode", ")", ")", "{", "rtx", "temp", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "rtx", "val", "=", "force_operand", "(", "XEXP", "(", "x", ",", "1", ")", ",", "0", ")", ";", "emit_move_insn", "(", "temp", ",", "val", ")", ";", "COPY_ONCE", "(", "x", ")", ";", "XEXP", "(", "x", ",", "1", ")", "=", "temp", ";", "if", "(", "TARGET_COLDFIRE_FPU", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "REG", ")", "x", "=", "force_operand", "(", "x", ",", "0", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "REG", "||", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "SIGN_EXTEND", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "0", ")", ")", "==", "REG", "&&", "GET_MODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "0", ")", ")", "==", "HImode", ")", ")", "{", "rtx", "temp", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "rtx", "val", "=", "force_operand", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ";", "emit_move_insn", "(", "temp", ",", "val", ")", ";", "COPY_ONCE", "(", "x", ")", ";", "XEXP", "(", "x", ",", "0", ")", "=", "temp", ";", "if", "(", "TARGET_COLDFIRE_FPU", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "REG", ")", "x", "=", "force_operand", "(", "x", ",", "0", ")", ";", "}", "}", "return", "x", ";", "}", "</s>"], "natrual_language": ["Convert", "X", "to", "a", "legitimate", "address", "and", "return", "it", "if", "successful", ".", "Otherwise", "return", "X", ".", "For", "the", "68000", ",", "we", "handle", "X+REG", "by", "loading", "X", "into", "a", "register", "R", "and", "using", "R+REG", ".", "R", "will", "go", "in", "an", "address", "reg", "and", "indexing", "will", "be", "used", ".", "However", ",", "if", "REG", "is", "a", "broken-out", "memory", "address", "or", "multiplication", ",", "nothing", "needs", "to", "be", "done", "because", "REG", "can", "certainly", "go", "in", "an", "address", "reg", "."], "TS_V_token": ["m68k", "0", "0", "0", "0", "0", "1", "1", "1", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "1", "0", "0", "1", "1", "1", "0", "1", "0", "0", "0", "0", "1", "0"], "File": "m68k", "Func": "m68k_legitimize_address", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42713, "Length": 495}
{"ground_truth": ["<s>", "rtx", "m68k_legitimize_call_address", "(", "rtx", "x", ")", "{", "gcc_assert", "(", "MEM_P", "(", "x", ")", ")", ";", "if", "(", "call_operand", "(", "XEXP", "(", "x", ",", "0", ")", ",", "VOIDmode", ")", ")", "return", "x", ";", "return", "replace_equiv_address", "(", "x", ",", "force_reg", "(", "Pmode", ",", "XEXP", "(", "x", ",", "0", ")", ")", ")", ";", "}", "</s>"], "natrual_language": ["Convert", "X", "to", "a", "legitimate", "function", "call", "memory", "reference", "and", "return", "the", "result", "."], "TS_V_token": ["m68k", "0", "0"], "File": "m68k", "Func": "m68k_legitimize_call_address", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42714, "Length": 51}
{"ground_truth": ["<s>", "rtx", "m68k_legitimize_sibcall_address", "(", "rtx", "x", ")", "{", "gcc_assert", "(", "MEM_P", "(", "x", ")", ")", ";", "if", "(", "sibcall_operand", "(", "XEXP", "(", "x", ",", "0", ")", ",", "VOIDmode", ")", ")", "return", "x", ";", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "STATIC_CHAIN_REGNUM", ")", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "return", "replace_equiv_address", "(", "x", ",", "gen_rtx_REG", "(", "Pmode", ",", "STATIC_CHAIN_REGNUM", ")", ")", ";", "}", "</s>"], "natrual_language": ["Likewise", "for", "sibling", "calls", "."], "TS_V_token": ["m68k", "0", "0"], "File": "m68k", "Func": "m68k_legitimize_sibcall_address", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42715, "Length": 63}
{"ground_truth": ["<s>", "rtx", "m68k_legitimize_tls_address", "(", "rtx", "orig", ")", "{", "switch", "(", "SYMBOL_REF_TLS_MODEL", "(", "orig", ")", ")", "{", "case", "TLS_MODEL_GLOBAL_DYNAMIC", ":", "orig", "=", "m68k_call_tls_get_addr", "(", "orig", ",", "orig", ",", "RELOC_TLSGD", ")", ";", "break", ";", "case", "TLS_MODEL_LOCAL_DYNAMIC", ":", "{", "rtx", "eqv", ";", "rtx", "a0", ";", "rtx", "x", ";", "eqv", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "const0_rtx", ")", ",", "UNSPEC_RELOC32", ")", ";", "a0", "=", "m68k_call_tls_get_addr", "(", "orig", ",", "eqv", ",", "RELOC_TLSLDM", ")", ";", "x", "=", "m68k_wrap_symbol", "(", "orig", ",", "RELOC_TLSLDO", ",", "a0", ",", "NULL_RTX", ")", ";", "if", "(", "can_create_pseudo_p", "(", ")", ")", "x", "=", "m68k_move_to_reg", "(", "x", ",", "orig", ",", "NULL_RTX", ")", ";", "orig", "=", "x", ";", "break", ";", "}", "case", "TLS_MODEL_INITIAL_EXEC", ":", "{", "rtx", "a0", ";", "rtx", "x", ";", "a0", "=", "m68k_call_m68k_read_tp", "(", ")", ";", "x", "=", "m68k_wrap_symbol_into_got_ref", "(", "orig", ",", "RELOC_TLSIE", ",", "NULL_RTX", ")", ";", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "x", ",", "a0", ")", ";", "if", "(", "can_create_pseudo_p", "(", ")", ")", "x", "=", "m68k_move_to_reg", "(", "x", ",", "orig", ",", "NULL_RTX", ")", ";", "orig", "=", "x", ";", "break", ";", "}", "case", "TLS_MODEL_LOCAL_EXEC", ":", "{", "rtx", "a0", ";", "rtx", "x", ";", "a0", "=", "m68k_call_m68k_read_tp", "(", ")", ";", "x", "=", "m68k_wrap_symbol", "(", "orig", ",", "RELOC_TLSLE", ",", "a0", ",", "NULL_RTX", ")", ";", "if", "(", "can_create_pseudo_p", "(", ")", ")", "x", "=", "m68k_move_to_reg", "(", "x", ",", "orig", ",", "NULL_RTX", ")", ";", "orig", "=", "x", ";", "break", ";", "}", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "orig", ";", "}", "</s>"], "natrual_language": ["Return", "a", "legitimized", "address", "for", "accessing", "TLS", "SYMBOL_REF", "X", ".", "For", "explanations", "on", "instructions", "sequences", "see", "TLS/NPTL", "ABI", "for", "m68k", "and", "ColdFire", "."], "TS_V_token": ["m68k", "1"], "File": "m68k", "Func": "m68k_legitimize_tls_address", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42716, "Length": 234}
{"ground_truth": ["<s>", "rtx", "m68k_libcall_value", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_SFmode", ":", "case", "E_DFmode", ":", "case", "E_XFmode", ":", "if", "(", "TARGET_68881", ")", "return", "gen_rtx_REG", "(", "mode", ",", "FP0_REG", ")", ";", "break", ";", "default", ":", "break", ";", "}", "return", "gen_rtx_REG", "(", "mode", ",", "m68k_libcall_value_in_a0_p", "?", "A0_REG", ":", "D0_REG", ")", ";", "}", "</s>"], "natrual_language": ["Return", "floating", "point", "values", "in", "a", "68881", "register", ".", "This", "makes", "68881", "code", "a", "little", "bit", "faster", ".", "It", "also", "makes", "-msoft-float", "code", "incompatible", "with", "hard-float", "code", ",", "so", "people", "have", "to", "be", "careful", "not", "to", "mix", "the", "two", ".", "For", "ColdFire", "it", "was", "decided", "the", "ABI", "incompatibility", "is", "undesirable", ".", "If", "there", "is", "need", "for", "a", "hard-float", "ABI", "it", "is", "probably", "worth", "doing", "it", "properly", "and", "also", "passing", "function", "arguments", "in", "FP", "registers", "."], "TS_V_token": ["m68k"], "File": "m68k", "Func": "m68k_libcall_value", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42717, "Length": 53}
{"ground_truth": ["<s>", "bool", "m68k_matches_q_p", "(", "rtx", "x", ")", "{", "struct", "m68k_address", "address", ";", "return", "(", "m68k_legitimate_mem_p", "(", "x", ",", "&", "address", ")", "&&", "address", ".", "code", "==", "UNKNOWN", "&&", "address", ".", "base", "&&", "!", "address", ".", "offset", "&&", "!", "address", ".", "index", ")", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "X", "matches", "the", "'", "Q", "'", "constraint", ".", "It", "must", "be", "a", "memory", "with", "a", "base", "address", "and", "no", "constant", "offset", "or", "index", "."], "TS_V_token": ["m68k"], "File": "m68k", "Func": "m68k_matches_q_p", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42718, "Length": 43}
{"ground_truth": ["<s>", "bool", "m68k_matches_u_p", "(", "rtx", "x", ")", "{", "struct", "m68k_address", "address", ";", "return", "(", "m68k_legitimate_mem_p", "(", "x", ",", "&", "address", ")", "&&", "address", ".", "code", "==", "UNKNOWN", "&&", "address", ".", "base", "&&", "address", ".", "offset", "&&", "!", "address", ".", "index", ")", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "X", "matches", "the", "'", "U", "'", "constraint", ".", "It", "must", "be", "a", "base", "address", "with", "a", "constant", "offset", "and", "no", "index", "."], "TS_V_token": ["m68k"], "File": "m68k", "Func": "m68k_matches_u_p", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42719, "Length": 42}
{"ground_truth": ["<s>", "static", "bool", "m68k_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "return", "(", "!", "TARGET_HARD_FLOAT", "||", "(", "(", "GET_MODE_CLASS", "(", "mode1", ")", "==", "MODE_FLOAT", "||", "GET_MODE_CLASS", "(", "mode1", ")", "==", "MODE_COMPLEX_FLOAT", ")", "==", "(", "GET_MODE_CLASS", "(", "mode2", ")", "==", "MODE_FLOAT", "||", "GET_MODE_CLASS", "(", "mode2", ")", "==", "MODE_COMPLEX_FLOAT", ")", ")", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_MODES_TIEABLE_P", "."], "TS_V_token": ["m68k"], "File": "m68k", "Func": "m68k_modes_tieable_p", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42720, "Length": 52}
{"ground_truth": ["<s>", "bool", "m68k_movem_pattern_p", "(", "rtx", "pattern", ",", "rtx", "automod_base", ",", "HOST_WIDE_INT", "automod_offset", ",", "bool", "store_p", ")", "{", "rtx", "base", ",", "mem_base", ",", "set", ",", "mem", ",", "reg", ",", "last_reg", ";", "HOST_WIDE_INT", "offset", ",", "mem_offset", ";", "int", "i", ",", "first", ",", "len", ";", "enum", "reg_class", "rclass", ";", "len", "=", "XVECLEN", "(", "pattern", ",", "0", ")", ";", "first", "=", "(", "automod_base", "!=", "NULL", ")", ";", "if", "(", "automod_base", ")", "{", "if", "(", "store_p", "!=", "(", "automod_offset", "<", "0", ")", ")", "return", "false", ";", "base", "=", "automod_base", ";", "offset", "=", "(", "automod_offset", "<", "0", "?", "automod_offset", ":", "0", ")", ";", "}", "else", "{", "base", "=", "NULL", ";", "offset", "=", "0", ";", "}", "last_reg", "=", "NULL", ";", "rclass", "=", "NO_REGS", ";", "for", "(", "i", "=", "first", ";", "i", "<", "len", ";", "i", "++", ")", "{", "set", "=", "XVECEXP", "(", "pattern", ",", "0", ",", "i", ")", ";", "if", "(", "GET_CODE", "(", "set", ")", "!=", "SET", ")", "return", "false", ";", "mem", "=", "XEXP", "(", "set", ",", "!", "store_p", ")", ";", "if", "(", "!", "MEM_P", "(", "mem", ")", "||", "!", "memory_operand", "(", "mem", ",", "VOIDmode", ")", ")", "return", "false", ";", "if", "(", "base", "==", "NULL", ")", "{", "m68k_split_offset", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "&", "base", ",", "&", "offset", ")", ";", "if", "(", "TARGET_COLDFIRE", "&&", "!", "m68k_legitimate_base_reg_p", "(", "base", ",", "reload_completed", ")", ")", "return", "false", ";", "}", "else", "{", "m68k_split_offset", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "&", "mem_base", ",", "&", "mem_offset", ")", ";", "if", "(", "!", "rtx_equal_p", "(", "base", ",", "mem_base", ")", "||", "offset", "!=", "mem_offset", ")", "return", "false", ";", "}", "reg", "=", "XEXP", "(", "set", ",", "store_p", ")", ";", "if", "(", "!", "REG_P", "(", "reg", ")", "||", "!", "HARD_REGISTER_P", "(", "reg", ")", "||", "GET_MODE", "(", "reg", ")", "!=", "reg_raw_mode", "[", "REGNO", "(", "reg", ")", "]", ")", "return", "false", ";", "if", "(", "last_reg", ")", "{", "if", "(", "!", "TEST_HARD_REG_BIT", "(", "reg_class_contents", "[", "rclass", "]", ",", "REGNO", "(", "reg", ")", ")", "||", "REGNO", "(", "last_reg", ")", ">=", "REGNO", "(", "reg", ")", ")", "return", "false", ";", "}", "else", "{", "if", "(", "INT_REGNO_P", "(", "REGNO", "(", "reg", ")", ")", ")", "rclass", "=", "GENERAL_REGS", ";", "else", "if", "(", "FP_REGNO_P", "(", "REGNO", "(", "reg", ")", ")", ")", "rclass", "=", "FP_REGS", ";", "else", "return", "false", ";", "}", "last_reg", "=", "reg", ";", "offset", "+=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "reg", ")", ")", ";", "}", "if", "(", "automod_base", "&&", "offset", "!=", "(", "automod_offset", "<", "0", "?", "0", ":", "automod_offset", ")", ")", "return", "false", ";", "if", "(", "len", "<", "first", "+", "(", "rclass", "==", "FP_REGS", "?", "MIN_FMOVEM_REGS", ":", "MIN_MOVEM_REGS", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "PATTERN", "is", "a", "PARALLEL", "suitable", "for", "a", "movem", "or", "fmovem", "instruction", ".", "STORE_P", "says", "whether", "the", "move", "is", "a", "load", "or", "store", ".", "If", "the", "instruction", "uses", "post-increment", "or", "pre-decrement", "addressing", ",", "AUTOMOD_BASE", "is", "the", "base", "register", "and", "AUTOMOD_OFFSET", "is", "the", "total", "adjustment", ".", "This", "adjustment", "will", "be", "made", "by", "the", "first", "element", "of", "PARALLEL", ",", "with", "the", "loads", "or", "stores", "starting", "at", "element", "1", ".", "If", "the", "instruction", "does", "not", "use", "post-increment", "or", "pre-decrement", "addressing", ",", "AUTOMOD_BASE", "is", "null", ",", "AUTOMOD_OFFSET", "is", "0", ",", "and", "the", "loads", "or", "stores", "start", "at", "element", "0", "."], "TS_V_token": ["m68k", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], "File": "m68k", "Func": "m68k_movem_pattern_p", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42721, "Length": 424}
{"ground_truth": ["<s>", "static", "rtx", "m68k_move_to_reg", "(", "rtx", "x", ",", "rtx", "orig", ",", "rtx", "reg", ")", "{", "rtx_insn", "*", "insn", ";", "if", "(", "reg", "==", "NULL_RTX", ")", "{", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "}", "insn", "=", "emit_move_insn", "(", "reg", ",", "x", ")", ";", "set_unique_reg_note", "(", "insn", ",", "REG_EQUAL", ",", "orig", ")", ";", "return", "reg", ";", "}", "</s>"], "natrual_language": ["Move", "X", "to", "a", "register", "and", "add", "REG_EQUAL", "note", "pointing", "to", "ORIG", ".", "If", "REG", "is", "non-null", ",", "use", "it", ";", "generate", "new", "pseudo", "otherwise", "."], "TS_V_token": ["m68k"], "File": "m68k", "Func": "m68k_move_to_reg", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42722, "Length": 62}
{"ground_truth": ["<s>", "static", "bool", "m68k_ok_for_sibcall_p", "(", "tree", "decl", ",", "tree", "exp", ")", "{", "enum", "m68k_function_kind", "kind", ";", "if", "(", "CALL_EXPR_STATIC_CHAIN", "(", "exp", ")", ")", "return", "false", ";", "if", "(", "!", "VOID_TYPE_P", "(", "TREE_TYPE", "(", "DECL_RESULT", "(", "cfun", "->", "decl", ")", ")", ")", ")", "{", "rtx", "cfun_value", ";", "rtx", "call_value", ";", "cfun_value", "=", "FUNCTION_VALUE", "(", "TREE_TYPE", "(", "DECL_RESULT", "(", "cfun", "->", "decl", ")", ")", ",", "cfun", "->", "decl", ")", ";", "call_value", "=", "FUNCTION_VALUE", "(", "TREE_TYPE", "(", "exp", ")", ",", "decl", ")", ";", "if", "(", "!", "(", "rtx_equal_p", "(", "cfun_value", ",", "call_value", ")", "||", "(", "REG_P", "(", "cfun_value", ")", "&&", "m68k_reg_present_p", "(", "call_value", ",", "REGNO", "(", "cfun_value", ")", ")", ")", ")", ")", "return", "false", ";", "}", "kind", "=", "m68k_get_function_kind", "(", "current_function_decl", ")", ";", "if", "(", "kind", "==", "m68k_fk_normal_function", ")", "return", "true", ";", "if", "(", "decl", "&&", "m68k_get_function_kind", "(", "decl", ")", "==", "kind", ")", "return", "true", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_FUNCTION_OK_FOR_SIBCALL_P", "."], "TS_V_token": ["m68k"], "File": "m68k", "Func": "m68k_ok_for_sibcall_p", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42723, "Length": 146}
{"ground_truth": ["<s>", "static", "bool", "m68k_output_addr_const_extra", "(", "FILE", "*", "file", ",", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", ")", "{", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "case", "UNSPEC_RELOC16", ":", "case", "UNSPEC_RELOC32", ":", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ")", ";", "fputs", "(", "m68k_get_reloc_decoration", "(", "(", "enum", "m68k_reloc", ")", "INTVAL", "(", "XVECEXP", "(", "x", ",", "0", ",", "1", ")", ")", ")", ",", "file", ")", ";", "return", "true", ";", "default", ":", "break", ";", "}", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["m68k", "implementation", "of", "TARGET_OUTPUT_ADDR_CONST_EXTRA", "."], "TS_V_token": ["m68k", "1", "0", "0", "0", "1"], "File": "m68k", "Func": "m68k_output_addr_const_extra", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42724, "Length": 89}
{"ground_truth": ["<s>", "rtx_code", "m68k_output_bftst", "(", "rtx", "zxop0", ",", "rtx", "zxop1", ",", "rtx", "zxop2", ",", "rtx_code", "code", ")", "{", "if", "(", "zxop1", "==", "const1_rtx", "&&", "GET_CODE", "(", "zxop2", ")", "==", "CONST_INT", ")", "{", "int", "width", "=", "GET_CODE", "(", "zxop0", ")", "==", "REG", "?", "31", ":", "7", ";", "return", "m68k_output_btst", "(", "GEN_INT", "(", "width", "-", "INTVAL", "(", "zxop2", ")", ")", ",", "zxop0", ",", "code", ",", "1000", ")", ";", "}", "rtx", "ops", "[", "3", "]", "=", "{", "zxop0", ",", "zxop1", ",", "zxop2", "}", ";", "output_asm_insn", "(", "\"bftst %0{%b2:%b1}\"", ",", "ops", ")", ";", "return", "code", ";", "}", "</s>"], "natrual_language": ["Output", "a", "bftst", "instruction", "for", "a", "zero_extract", "with", "ZXOP0", ",", "ZXOP1", "and", "ZXOP2", "operands", ".", "CODE", "is", "the", "code", "of", "the", "comparison", ",", "and", "we", "return", "the", "code", "to", "be", "actually", "used", "in", "the", "jump", "."], "TS_V_token": ["m68k", "31", "7", "1000", "3", "\"bftst %0{%b2:%b1}\""], "File": "m68k", "Func": "m68k_output_bftst", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42725, "Length": 90}
{"ground_truth": ["<s>", "const", "char", "*", "m68k_output_branch_float", "(", "rtx_code", "code", ")", "{", "switch", "(", "code", ")", "{", "case", "EQ", ":", "return", "\"fjeq %l3\"", ";", "case", "NE", ":", "return", "\"fjne %l3\"", ";", "case", "GT", ":", "return", "\"fjgt %l3\"", ";", "case", "LT", ":", "return", "\"fjlt %l3\"", ";", "case", "GE", ":", "return", "\"fjge %l3\"", ";", "case", "LE", ":", "return", "\"fjle %l3\"", ";", "case", "ORDERED", ":", "return", "\"fjor %l3\"", ";", "case", "UNORDERED", ":", "return", "\"fjun %l3\"", ";", "case", "UNEQ", ":", "return", "\"fjueq %l3\"", ";", "case", "UNGE", ":", "return", "\"fjuge %l3\"", ";", "case", "UNGT", ":", "return", "\"fjugt %l3\"", ";", "case", "UNLE", ":", "return", "\"fjule %l3\"", ";", "case", "UNLT", ":", "return", "\"fjult %l3\"", ";", "case", "LTGT", ":", "return", "\"fjogl %l3\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Return", "an", "output", "template", "for", "a", "floating", "point", "branch", "instruction", "with", "CODE", "."], "TS_V_token": ["m68k", "\"fjeq %l3\"", "\"fjne %l3\"", "\"fjgt %l3\"", "\"fjlt %l3\"", "\"fjge %l3\"", "\"fjle %l3\"", "\"fjor %l3\"", "\"fjun %l3\"", "\"fjueq %l3\"", "\"fjuge %l3\"", "\"fjugt %l3\"", "\"fjule %l3\"", "\"fjult %l3\"", "\"fjogl %l3\""], "File": "m68k", "Func": "m68k_output_branch_float", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42726, "Length": 106}
{"ground_truth": ["<s>", "const", "char", "*", "m68k_output_branch_float_rev", "(", "rtx_code", "code", ")", "{", "switch", "(", "code", ")", "{", "case", "EQ", ":", "return", "\"fjne %l3\"", ";", "case", "NE", ":", "return", "\"fjeq %l3\"", ";", "case", "GT", ":", "return", "\"fjngt %l3\"", ";", "case", "LT", ":", "return", "\"fjnlt %l3\"", ";", "case", "GE", ":", "return", "\"fjnge %l3\"", ";", "case", "LE", ":", "return", "\"fjnle %l3\"", ";", "case", "ORDERED", ":", "return", "\"fjun %l3\"", ";", "case", "UNORDERED", ":", "return", "\"fjor %l3\"", ";", "case", "UNEQ", ":", "return", "\"fjogl %l3\"", ";", "case", "UNGE", ":", "return", "\"fjolt %l3\"", ";", "case", "UNGT", ":", "return", "\"fjole %l3\"", ";", "case", "UNLE", ":", "return", "\"fjogt %l3\"", ";", "case", "UNLT", ":", "return", "\"fjoge %l3\"", ";", "case", "LTGT", ":", "return", "\"fjueq %l3\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Return", "an", "output", "template", "for", "a", "reversed", "floating", "point", "branch", "instruction", "with", "CODE", "."], "TS_V_token": ["m68k", "\"fjne %l3\"", "\"fjeq %l3\"", "\"fjngt %l3\"", "\"fjnlt %l3\"", "\"fjnge %l3\"", "\"fjnle %l3\"", "\"fjun %l3\"", "\"fjor %l3\"", "\"fjogl %l3\"", "\"fjolt %l3\"", "\"fjole %l3\"", "\"fjogt %l3\"", "\"fjoge %l3\"", "\"fjueq %l3\""], "File": "m68k", "Func": "m68k_output_branch_float_rev", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42727, "Length": 106}
{"ground_truth": ["<s>", "const", "char", "*", "m68k_output_branch_integer", "(", "rtx_code", "code", ")", "{", "switch", "(", "code", ")", "{", "case", "EQ", ":", "return", "\"jeq %l3\"", ";", "case", "NE", ":", "return", "\"jne %l3\"", ";", "case", "GT", ":", "return", "\"jgt %l3\"", ";", "case", "GTU", ":", "return", "\"jhi %l3\"", ";", "case", "LT", ":", "return", "\"jlt %l3\"", ";", "case", "LTU", ":", "return", "\"jcs %l3\"", ";", "case", "GE", ":", "return", "\"jge %l3\"", ";", "case", "GEU", ":", "return", "\"jcc %l3\"", ";", "case", "LE", ":", "return", "\"jle %l3\"", ";", "case", "LEU", ":", "return", "\"jls %l3\"", ";", "case", "PLUS", ":", "return", "\"jpl %l3\"", ";", "case", "MINUS", ":", "return", "\"jmi %l3\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Return", "an", "output", "template", "for", "a", "branch", "with", "CODE", "."], "TS_V_token": ["m68k", "\"jeq %l3\"", "\"jne %l3\"", "\"jgt %l3\"", "\"jhi %l3\"", "\"jlt %l3\"", "\"jcs %l3\"", "\"jge %l3\"", "\"jcc %l3\"", "\"jle %l3\"", "\"jls %l3\"", "\"jpl %l3\"", "\"jmi %l3\""], "File": "m68k", "Func": "m68k_output_branch_integer", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42728, "Length": 94}
{"ground_truth": ["<s>", "const", "char", "*", "m68k_output_branch_integer_rev", "(", "rtx_code", "code", ")", "{", "switch", "(", "code", ")", "{", "case", "EQ", ":", "return", "\"jne %l3\"", ";", "case", "NE", ":", "return", "\"jeq %l3\"", ";", "case", "GT", ":", "return", "\"jle %l3\"", ";", "case", "GTU", ":", "return", "\"jls %l3\"", ";", "case", "LT", ":", "return", "\"jge %l3\"", ";", "case", "LTU", ":", "return", "\"jcc %l3\"", ";", "case", "GE", ":", "return", "\"jlt %l3\"", ";", "case", "GEU", ":", "return", "\"jcs %l3\"", ";", "case", "LE", ":", "return", "\"jgt %l3\"", ";", "case", "LEU", ":", "return", "\"jhi %l3\"", ";", "case", "PLUS", ":", "return", "\"jmi %l3\"", ";", "case", "MINUS", ":", "return", "\"jpl %l3\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Return", "an", "output", "template", "for", "a", "reversed", "branch", "with", "CODE", "."], "TS_V_token": ["m68k", "\"jne %l3\"", "\"jeq %l3\"", "\"jle %l3\"", "\"jls %l3\"", "\"jge %l3\"", "\"jcc %l3\"", "\"jlt %l3\"", "\"jcs %l3\"", "\"jgt %l3\"", "\"jhi %l3\"", "\"jmi %l3\"", "\"jpl %l3\""], "File": "m68k", "Func": "m68k_output_branch_integer_rev", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42729, "Length": 94}
{"ground_truth": ["<s>", "rtx_code", "m68k_output_compare_di", "(", "rtx", "op0", ",", "rtx", "op1", ",", "rtx", "sc1", ",", "rtx", "sc2", ",", "rtx_insn", "*", "insn", ",", "rtx_code", "code", ")", "{", "rtx", "ops", "[", "4", "]", ";", "ops", "[", "0", "]", "=", "op0", ";", "ops", "[", "1", "]", "=", "op1", ";", "ops", "[", "2", "]", "=", "sc1", ";", "ops", "[", "3", "]", "=", "sc2", ";", "if", "(", "op1", "==", "const0_rtx", ")", "{", "if", "(", "!", "REG_P", "(", "op0", ")", "||", "ADDRESS_REG_P", "(", "op0", ")", ")", "{", "rtx", "xoperands", "[", "2", "]", ";", "xoperands", "[", "0", "]", "=", "sc2", ";", "xoperands", "[", "1", "]", "=", "op0", ";", "output_move_double", "(", "xoperands", ")", ";", "output_asm_insn", "(", "\"neg%.l %R0\\n\\tnegx%.l %0\"", ",", "xoperands", ")", ";", "return", "swap_condition", "(", "code", ")", ";", "}", "if", "(", "find_reg_note", "(", "insn", ",", "REG_DEAD", ",", "op0", ")", ")", "{", "output_asm_insn", "(", "\"neg%.l %R0\\n\\tnegx%.l %0\"", ",", "ops", ")", ";", "return", "swap_condition", "(", "code", ")", ";", "}", "else", "{", "output_asm_insn", "(", "\"sub%.l %2,%2\\n\\ttst%.l %R0\\n\\tsubx%.l %2,%0\"", ",", "ops", ")", ";", "return", "code", ";", "}", "}", "if", "(", "rtx_equal_p", "(", "sc2", ",", "op0", ")", ")", "{", "output_asm_insn", "(", "\"sub%.l %R1,%R3\\n\\tsubx%.l %1,%3\"", ",", "ops", ")", ";", "return", "code", ";", "}", "else", "{", "output_asm_insn", "(", "\"sub%.l %R0,%R3\\n\\tsubx%.l %0,%3\"", ",", "ops", ")", ";", "return", "swap_condition", "(", "code", ")", ";", "}", "}", "</s>"], "natrual_language": ["Emit", "a", "comparison", "between", "OP0", "and", "OP1", ".", "Return", "true", "iff", "the", "comparison", "was", "reversed", ".", "SC1", "is", "an", "SImode", "scratch", "reg", ",", "and", "SC2", "a", "DImode", "scratch", "reg", ",", "as", "needed", ".", "CODE", "is", "the", "code", "of", "the", "comparison", ",", "we", "return", "it", "unchanged", "or", "swapped", ",", "as", "necessary", "."], "TS_V_token": ["m68k", "4", "0", "1", "2", "3", "2", "0", "1", "\"neg%.l %R0\\n\\tnegx%.l %0\"", "\"neg%.l %R0\\n\\tnegx%.l %0\"", "\"sub%.l %2,%2\\n\\ttst%.l %R0\\n\\tsubx%.l %2,%0\"", "\"sub%.l %R1,%R3\\n\\tsubx%.l %1,%3\"", "\"sub%.l %R0,%R3\\n\\tsubx%.l %0,%3\""], "File": "m68k", "Func": "m68k_output_compare_di", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42730, "Length": 195}
{"ground_truth": ["<s>", "rtx_code", "m68k_output_compare_fp", "(", "rtx", "op0", ",", "rtx", "op1", ",", "rtx_code", "code", ")", "{", "rtx_code", "tmp", "=", "m68k_find_flags_value", "(", "op0", ",", "op1", ",", "code", ")", ";", "if", "(", "tmp", "!=", "UNKNOWN", ")", "return", "tmp", ";", "rtx", "ops", "[", "2", "]", ";", "ops", "[", "0", "]", "=", "op0", ";", "ops", "[", "1", "]", "=", "op1", ";", "remember_compare_flags", "(", "op0", ",", "op1", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "op0", ")", ";", "std", "::", "string", "prec", "=", "mode", "==", "SFmode", "?", "\"s\"", ":", "mode", "==", "DFmode", "?", "\"d\"", ":", "\"x\"", ";", "if", "(", "op1", "==", "CONST0_RTX", "(", "GET_MODE", "(", "op0", ")", ")", ")", "{", "if", "(", "FP_REG_P", "(", "op0", ")", ")", "{", "if", "(", "TARGET_COLDFIRE_FPU", ")", "output_asm_insn", "(", "\"ftst%.d %0\"", ",", "ops", ")", ";", "else", "output_asm_insn", "(", "\"ftst%.x %0\"", ",", "ops", ")", ";", "}", "else", "output_asm_insn", "(", "(", "\"ftst%.\"", "+", "prec", "+", "\" %0\"", ")", ".", "c_str", "(", ")", ",", "ops", ")", ";", "return", "code", ";", "}", "switch", "(", "which_alternative", ")", "{", "case", "0", ":", "if", "(", "TARGET_COLDFIRE_FPU", ")", "output_asm_insn", "(", "\"fcmp%.d %1,%0\"", ",", "ops", ")", ";", "else", "output_asm_insn", "(", "\"fcmp%.x %1,%0\"", ",", "ops", ")", ";", "break", ";", "case", "1", ":", "output_asm_insn", "(", "(", "\"fcmp%.\"", "+", "prec", "+", "\" %f1,%0\"", ")", ".", "c_str", "(", ")", ",", "ops", ")", ";", "break", ";", "case", "2", ":", "output_asm_insn", "(", "(", "\"fcmp%.\"", "+", "prec", "+", "\" %0,%f1\"", ")", ".", "c_str", "(", ")", ",", "ops", ")", ";", "std", "::", "swap", "(", "flags_compare_op0", ",", "flags_compare_op1", ")", ";", "return", "swap_condition", "(", "code", ")", ";", "case", "3", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "code", ";", "}", "</s>"], "natrual_language": ["Emit", "a", "comparison", "between", "OP0", "and", "OP1", ".", "CODE", "is", "the", "code", "of", "the", "comparison", ".", "It", "is", "returned", ",", "potentially", "modified", "if", "necessary", "."], "TS_V_token": ["m68k", "2", "0", "1", "\"s\"", "\"d\"", "\"x\"", "\"ftst%.d %0\"", "\"ftst%.x %0\"", "\"ftst%.\"", "\" %0\"", "0", "\"fcmp%.d %1,%0\"", "\"fcmp%.x %1,%0\"", "1", "\"fcmp%.\"", "\" %f1,%0\"", "2", "\"fcmp%.\"", "\" %0,%f1\"", "3"], "File": "m68k", "Func": "m68k_output_compare_fp", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42731, "Length": 249}
{"ground_truth": ["<s>", "rtx_code", "m68k_output_compare_hi", "(", "rtx", "op0", ",", "rtx", "op1", ",", "rtx_code", "code", ")", "{", "rtx_code", "tmp", "=", "m68k_find_flags_value", "(", "op0", ",", "op1", ",", "code", ")", ";", "if", "(", "tmp", "!=", "UNKNOWN", ")", "return", "tmp", ";", "remember_compare_flags", "(", "op0", ",", "op1", ")", ";", "rtx", "ops", "[", "2", "]", ";", "ops", "[", "0", "]", "=", "op0", ";", "ops", "[", "1", "]", "=", "op1", ";", "if", "(", "op1", "==", "const0_rtx", ")", "output_asm_insn", "(", "\"tst%.w %d0\"", ",", "ops", ")", ";", "else", "if", "(", "GET_CODE", "(", "op0", ")", "==", "MEM", "&&", "GET_CODE", "(", "op1", ")", "==", "MEM", ")", "output_asm_insn", "(", "\"cmpm%.w %1,%0\"", ",", "ops", ")", ";", "else", "if", "(", "(", "REG_P", "(", "op1", ")", "&&", "!", "ADDRESS_REG_P", "(", "op1", ")", ")", "||", "(", "!", "REG_P", "(", "op0", ")", "&&", "GET_CODE", "(", "op0", ")", "!=", "MEM", ")", ")", "{", "output_asm_insn", "(", "\"cmp%.w %d0,%d1\"", ",", "ops", ")", ";", "std", "::", "swap", "(", "flags_compare_op0", ",", "flags_compare_op1", ")", ";", "return", "swap_condition", "(", "code", ")", ";", "}", "else", "output_asm_insn", "(", "\"cmp%.w %d1,%d0\"", ",", "ops", ")", ";", "return", "code", ";", "}", "</s>"], "natrual_language": ["Emit", "a", "comparison", "between", "OP0", "and", "OP1", ".", "CODE", "is", "the", "code", "of", "the", "comparison", ".", "It", "is", "returned", ",", "potentially", "modified", "if", "necessary", "."], "TS_V_token": ["m68k", "2", "0", "1", "\"tst%.w %d0\"", "\"cmpm%.w %1,%0\"", "\"cmp%.w %d0,%d1\"", "\"cmp%.w %d1,%d0\""], "File": "m68k", "Func": "m68k_output_compare_hi", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42732, "Length": 165}
{"ground_truth": ["<s>", "rtx_code", "m68k_output_compare_qi", "(", "rtx", "op0", ",", "rtx", "op1", ",", "rtx_code", "code", ")", "{", "rtx_code", "tmp", "=", "m68k_find_flags_value", "(", "op0", ",", "op1", ",", "code", ")", ";", "if", "(", "tmp", "!=", "UNKNOWN", ")", "return", "tmp", ";", "remember_compare_flags", "(", "op0", ",", "op1", ")", ";", "rtx", "ops", "[", "2", "]", ";", "ops", "[", "0", "]", "=", "op0", ";", "ops", "[", "1", "]", "=", "op1", ";", "if", "(", "op1", "==", "const0_rtx", ")", "output_asm_insn", "(", "\"tst%.b %d0\"", ",", "ops", ")", ";", "else", "if", "(", "GET_CODE", "(", "op0", ")", "==", "MEM", "&&", "GET_CODE", "(", "op1", ")", "==", "MEM", ")", "output_asm_insn", "(", "\"cmpm%.b %1,%0\"", ",", "ops", ")", ";", "else", "if", "(", "REG_P", "(", "op1", ")", "||", "(", "!", "REG_P", "(", "op0", ")", "&&", "GET_CODE", "(", "op0", ")", "!=", "MEM", ")", ")", "{", "output_asm_insn", "(", "\"cmp%.b %d0,%d1\"", ",", "ops", ")", ";", "std", "::", "swap", "(", "flags_compare_op0", ",", "flags_compare_op1", ")", ";", "return", "swap_condition", "(", "code", ")", ";", "}", "else", "output_asm_insn", "(", "\"cmp%.b %d1,%d0\"", ",", "ops", ")", ";", "return", "code", ";", "}", "</s>"], "natrual_language": ["Emit", "a", "comparison", "between", "OP0", "and", "OP1", ".", "CODE", "is", "the", "code", "of", "the", "comparison", ".", "It", "is", "returned", ",", "potentially", "modified", "if", "necessary", "."], "TS_V_token": ["m68k", "2", "0", "1", "\"tst%.b %d0\"", "\"cmpm%.b %1,%0\"", "\"cmp%.b %d0,%d1\"", "\"cmp%.b %d1,%d0\""], "File": "m68k", "Func": "m68k_output_compare_qi", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42733, "Length": 157}
{"ground_truth": ["<s>", "rtx_code", "m68k_output_compare_si", "(", "rtx", "op0", ",", "rtx", "op1", ",", "rtx_code", "code", ")", "{", "rtx_code", "tmp", "=", "m68k_find_flags_value", "(", "op0", ",", "op1", ",", "code", ")", ";", "if", "(", "tmp", "!=", "UNKNOWN", ")", "return", "tmp", ";", "remember_compare_flags", "(", "op0", ",", "op1", ")", ";", "rtx", "ops", "[", "2", "]", ";", "ops", "[", "0", "]", "=", "op0", ";", "ops", "[", "1", "]", "=", "op1", ";", "if", "(", "op1", "==", "const0_rtx", "&&", "(", "TARGET_68020", "||", "TARGET_COLDFIRE", "||", "!", "ADDRESS_REG_P", "(", "op0", ")", ")", ")", "output_asm_insn", "(", "\"tst%.l %0\"", ",", "ops", ")", ";", "else", "if", "(", "GET_CODE", "(", "op0", ")", "==", "MEM", "&&", "GET_CODE", "(", "op1", ")", "==", "MEM", ")", "output_asm_insn", "(", "\"cmpm%.l %1,%0\"", ",", "ops", ")", ";", "else", "if", "(", "REG_P", "(", "op1", ")", "||", "(", "!", "REG_P", "(", "op0", ")", "&&", "GET_CODE", "(", "op0", ")", "!=", "MEM", ")", ")", "{", "output_asm_insn", "(", "\"cmp%.l %d0,%d1\"", ",", "ops", ")", ";", "std", "::", "swap", "(", "flags_compare_op0", ",", "flags_compare_op1", ")", ";", "return", "swap_condition", "(", "code", ")", ";", "}", "else", "if", "(", "!", "TARGET_COLDFIRE", "&&", "ADDRESS_REG_P", "(", "op0", ")", "&&", "GET_CODE", "(", "op1", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "op1", ")", "<", "0x8000", "&&", "INTVAL", "(", "op1", ")", ">=", "-", "0x8000", ")", "output_asm_insn", "(", "\"cmp%.w %1,%0\"", ",", "ops", ")", ";", "else", "output_asm_insn", "(", "\"cmp%.l %d1,%d0\"", ",", "ops", ")", ";", "return", "code", ";", "}", "</s>"], "natrual_language": ["Emit", "a", "comparison", "between", "OP0", "and", "OP1", ".", "CODE", "is", "the", "code", "of", "the", "comparison", ".", "It", "is", "returned", ",", "potentially", "modified", "if", "necessary", "."], "TS_V_token": ["m68k", "2", "0", "1", "\"tst%.l %0\"", "\"cmpm%.l %1,%0\"", "\"cmp%.l %d0,%d1\"", "0x8000", "0x8000", "\"cmp%.w %1,%0\"", "\"cmp%.l %d1,%d0\""], "File": "m68k", "Func": "m68k_output_compare_si", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42734, "Length": 209}
{"ground_truth": ["<s>", "static", "void", "m68k_output_dwarf_dtprel", "(", "FILE", "*", "file", ",", "int", "size", ",", "rtx", "x", ")", "{", "gcc_assert", "(", "size", "==", "4", ")", ";", "fputs", "(", "\"\\t.long\\t\"", ",", "file", ")", ";", "output_addr_const", "(", "file", ",", "x", ")", ";", "fputs", "(", "\"@TLSLDO+0x8000\"", ",", "file", ")", ";", "}", "</s>"], "natrual_language": ["M68K", "implementation", "of", "TARGET_ASM_OUTPUT_DWARF_DTPREL", "."], "TS_V_token": ["m68k", "4", "\"\\t.long\\t\"", "\"@TLSLDO+0x8000\""], "File": "m68k", "Func": "m68k_output_dwarf_dtprel", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42735, "Length": 44}
{"ground_truth": ["<s>", "const", "char", "*", "m68k_output_movem", "(", "rtx", "*", "operands", ",", "rtx", "pattern", ",", "HOST_WIDE_INT", "automod_offset", ",", "bool", "store_p", ")", "{", "unsigned", "int", "mask", ";", "int", "i", ",", "first", ";", "gcc_assert", "(", "GET_CODE", "(", "pattern", ")", "==", "PARALLEL", ")", ";", "mask", "=", "0", ";", "first", "=", "(", "automod_offset", "!=", "0", ")", ";", "for", "(", "i", "=", "first", ";", "i", "<", "XVECLEN", "(", "pattern", ",", "0", ")", ";", "i", "++", ")", "{", "unsigned", "int", "regno", ";", "gcc_assert", "(", "MEM_P", "(", "XEXP", "(", "XVECEXP", "(", "pattern", ",", "0", ",", "i", ")", ",", "!", "store_p", ")", ")", ")", ";", "gcc_assert", "(", "REG_P", "(", "XEXP", "(", "XVECEXP", "(", "pattern", ",", "0", ",", "i", ")", ",", "store_p", ")", ")", ")", ";", "regno", "=", "REGNO", "(", "XEXP", "(", "XVECEXP", "(", "pattern", ",", "0", ",", "i", ")", ",", "store_p", ")", ")", ";", "if", "(", "automod_offset", "<", "0", ")", "{", "if", "(", "FP_REGNO_P", "(", "regno", ")", ")", "mask", "|=", "1", "<<", "(", "regno", "-", "FP0_REG", ")", ";", "else", "mask", "|=", "1", "<<", "(", "15", "-", "(", "regno", "-", "D0_REG", ")", ")", ";", "}", "else", "{", "if", "(", "FP_REGNO_P", "(", "regno", ")", ")", "mask", "|=", "1", "<<", "(", "7", "-", "(", "regno", "-", "FP0_REG", ")", ")", ";", "else", "mask", "|=", "1", "<<", "(", "regno", "-", "D0_REG", ")", ";", "}", "}", "CC_STATUS_INIT", ";", "if", "(", "automod_offset", "==", "0", ")", "operands", "[", "0", "]", "=", "XEXP", "(", "XEXP", "(", "XVECEXP", "(", "pattern", ",", "0", ",", "first", ")", ",", "!", "store_p", ")", ",", "0", ")", ";", "else", "if", "(", "automod_offset", "<", "0", ")", "operands", "[", "0", "]", "=", "gen_rtx_PRE_DEC", "(", "Pmode", ",", "SET_DEST", "(", "XVECEXP", "(", "pattern", ",", "0", ",", "0", ")", ")", ")", ";", "else", "operands", "[", "0", "]", "=", "gen_rtx_POST_INC", "(", "Pmode", ",", "SET_DEST", "(", "XVECEXP", "(", "pattern", ",", "0", ",", "0", ")", ")", ")", ";", "operands", "[", "1", "]", "=", "GEN_INT", "(", "mask", ")", ";", "if", "(", "FP_REGNO_P", "(", "REGNO", "(", "XEXP", "(", "XVECEXP", "(", "pattern", ",", "0", ",", "first", ")", ",", "store_p", ")", ")", ")", ")", "{", "if", "(", "store_p", ")", "return", "\"fmovem %1,%a0\"", ";", "else", "return", "\"fmovem %a0,%1\"", ";", "}", "else", "{", "if", "(", "store_p", ")", "return", "\"movem%.l %1,%a0\"", ";", "else", "return", "\"movem%.l %a0,%1\"", ";", "}", "}", "</s>"], "natrual_language": ["Return", "the", "assembly", "code", "template", "for", "a", "movem", "or", "fmovem", "instruction", "whose", "pattern", "is", "given", "by", "PATTERN", ".", "Store", "the", "template", "'s", "operands", "in", "OPERANDS", ".", "If", "the", "instruction", "uses", "post-increment", "or", "pre-decrement", "addressing", ",", "AUTOMOD_OFFSET", "is", "the", "total", "adjustment", ",", "otherwise", "it", "is", "0", ".", "STORE_P", "is", "true", "if", "this", "is", "a", "store", "instruction", "."], "TS_V_token": ["m68k", "0", "0", "0", "0", "0", "0", "0", "1", "1", "15", "1", "7", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "\"fmovem %1,%a0\"", "\"fmovem %a0,%1\"", "\"movem%.l %1,%a0\"", "\"movem%.l %a0,%1\""], "File": "m68k", "Func": "m68k_output_movem", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42736, "Length": 354}
{"ground_truth": ["<s>", "const", "char", "*", "m68k_output_scc", "(", "rtx_code", "code", ")", "{", "switch", "(", "code", ")", "{", "case", "EQ", ":", "return", "\"seq %0\"", ";", "case", "NE", ":", "return", "\"sne %0\"", ";", "case", "GT", ":", "return", "\"sgt %0\"", ";", "case", "GTU", ":", "return", "\"shi %0\"", ";", "case", "LT", ":", "return", "\"slt %0\"", ";", "case", "LTU", ":", "return", "\"scs %0\"", ";", "case", "GE", ":", "return", "\"sge %0\"", ";", "case", "GEU", ":", "return", "\"scc %0\"", ";", "case", "LE", ":", "return", "\"sle %0\"", ";", "case", "LEU", ":", "return", "\"sls %0\"", ";", "case", "PLUS", ":", "return", "\"spl %0\"", ";", "case", "MINUS", ":", "return", "\"smi %0\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Return", "an", "output", "template", "for", "a", "scc", "instruction", "with", "CODE", "."], "TS_V_token": ["m68k", "\"seq %0\"", "\"sne %0\"", "\"sgt %0\"", "\"shi %0\"", "\"slt %0\"", "\"scs %0\"", "\"sge %0\"", "\"scc %0\"", "\"sle %0\"", "\"sls %0\"", "\"spl %0\"", "\"smi %0\""], "File": "m68k", "Func": "m68k_output_scc", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42737, "Length": 94}
{"ground_truth": ["<s>", "const", "char", "*", "m68k_output_scc_float", "(", "rtx_code", "code", ")", "{", "switch", "(", "code", ")", "{", "case", "EQ", ":", "return", "\"fseq %0\"", ";", "case", "NE", ":", "return", "\"fsne %0\"", ";", "case", "GT", ":", "return", "\"fsgt %0\"", ";", "case", "GTU", ":", "return", "\"fshi %0\"", ";", "case", "LT", ":", "return", "\"fslt %0\"", ";", "case", "GE", ":", "return", "\"fsge %0\"", ";", "case", "LE", ":", "return", "\"fsle %0\"", ";", "case", "ORDERED", ":", "return", "\"fsor %0\"", ";", "case", "UNORDERED", ":", "return", "\"fsun %0\"", ";", "case", "UNEQ", ":", "return", "\"fsueq %0\"", ";", "case", "UNGE", ":", "return", "\"fsuge %0\"", ";", "case", "UNGT", ":", "return", "\"fsugt %0\"", ";", "case", "UNLE", ":", "return", "\"fsule %0\"", ";", "case", "UNLT", ":", "return", "\"fsult %0\"", ";", "case", "LTGT", ":", "return", "\"fsogl %0\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Return", "an", "output", "template", "for", "a", "floating", "point", "scc", "instruction", "with", "CODE", "."], "TS_V_token": ["m68k", "\"fseq %0\"", "\"fsne %0\"", "\"fsgt %0\"", "\"fshi %0\"", "\"fslt %0\"", "\"fsge %0\"", "\"fsle %0\"", "\"fsor %0\"", "\"fsun %0\"", "\"fsueq %0\"", "\"fsuge %0\"", "\"fsugt %0\"", "\"fsule %0\"", "\"fsult %0\"", "\"fsogl %0\""], "File": "m68k", "Func": "m68k_output_scc_float", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42738, "Length": 112}
{"ground_truth": ["<s>", "static", "void", "m68k_override_options_after_change", "(", "void", ")", "{", "if", "(", "m68k_sched_cpu", "==", "CPU_UNKNOWN", ")", "{", "flag_schedule_insns", "=", "0", ";", "flag_schedule_insns_after_reload", "=", "0", ";", "flag_modulo_sched", "=", "0", ";", "flag_live_range_shrinkage", "=", "0", ";", "}", "}", "</s>"], "natrual_language": ["Implement", "TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE", "."], "TS_V_token": ["m68k", "0", "0", "0", "0"], "File": "m68k", "Func": "m68k_override_options_after_change", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42739, "Length": 32}
{"ground_truth": ["<s>", "enum", "reg_class", "m68k_preferred_reload_class", "(", "rtx", "x", ",", "enum", "reg_class", "rclass", ")", "{", "enum", "reg_class", "secondary_class", ";", "secondary_class", "=", "m68k_secondary_reload_class", "(", "rclass", ",", "GET_MODE", "(", "x", ")", ",", "x", ")", ";", "if", "(", "secondary_class", "!=", "NO_REGS", "&&", "reg_class_subset_p", "(", "secondary_class", ",", "rclass", ")", ")", "return", "secondary_class", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", "&&", "reg_class_subset_p", "(", "DATA_REGS", ",", "rclass", ")", "&&", "IN_RANGE", "(", "INTVAL", "(", "x", ")", ",", "-", "0x80", ",", "0x7f", ")", ")", "return", "DATA_REGS", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", "&&", "GET_MODE_CLASS", "(", "GET_MODE", "(", "x", ")", ")", "==", "MODE_FLOAT", ")", "{", "if", "(", "TARGET_HARD_FLOAT", "&&", "reg_class_subset_p", "(", "FP_REGS", ",", "rclass", ")", ")", "return", "FP_REGS", ";", "return", "NO_REGS", ";", "}", "return", "rclass", ";", "}", "</s>"], "natrual_language": ["Implement", "PREFERRED_RELOAD_CLASS", "."], "TS_V_token": ["m68k", "0x80", "0x7f"], "File": "m68k", "Func": "m68k_preferred_reload_class", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42740, "Length": 120}
{"ground_truth": ["<s>", "static", "machine_mode", "m68k_promote_function_mode", "(", "const_tree", "type", ",", "machine_mode", "mode", ",", "int", "*", "punsignedp", "ATTRIBUTE_UNUSED", ",", "const_tree", "fntype", "ATTRIBUTE_UNUSED", ",", "int", "for_return", ")", "{", "if", "(", "type", "==", "NULL_TREE", "&&", "!", "for_return", "&&", "(", "mode", "==", "QImode", "||", "mode", "==", "HImode", ")", ")", "return", "SImode", ";", "return", "mode", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_PROMOTE_FUNCTION_MODE", "."], "TS_V_token": ["m68k"], "File": "m68k", "Func": "m68k_promote_function_mode", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42741, "Length": 49}
{"ground_truth": ["<s>", "poly_int64", "m68k_push_rounding", "(", "poly_int64", "bytes", ")", "{", "if", "(", "TARGET_COLDFIRE", ")", "return", "bytes", ";", "return", "(", "bytes", "+", "1", ")", "&", "~", "1", ";", "}", "</s>"], "natrual_language": ["Implement", "PUSH_ROUNDING", ".", "On", "the", "680x0", ",", "sp", "@", "-", "in", "a", "byte", "insn", "really", "pushes", "a", "word", ".", "On", "the", "ColdFire", ",", "sp", "@", "-", "in", "a", "byte", "insn", "pushes", "just", "a", "byte", "."], "TS_V_token": ["m68k", "1", "1"], "File": "m68k", "Func": "m68k_push_rounding", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42742, "Length": 25}
{"ground_truth": ["<s>", "static", "bool", "m68k_reg_present_p", "(", "const_rtx", "parallel", ",", "unsigned", "int", "regno", ")", "{", "int", "i", ";", "if", "(", "REG_P", "(", "parallel", ")", "&&", "REGNO", "(", "parallel", ")", "==", "regno", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "parallel", ")", "!=", "PARALLEL", ")", "return", "false", ";", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "parallel", ",", "0", ")", ";", "++", "i", ")", "{", "const_rtx", "x", ";", "x", "=", "XEXP", "(", "XVECEXP", "(", "parallel", ",", "0", ",", "i", ")", ",", "0", ")", ";", "if", "(", "REG_P", "(", "x", ")", "&&", "REGNO", "(", "x", ")", "==", "regno", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "PARALLEL", "contains", "register", "REGNO", "."], "TS_V_token": ["m68k", "0", "0", "0", "0"], "File": "m68k", "Func": "m68k_reg_present_p", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42743, "Length": 104}
{"ground_truth": ["<s>", "static", "poly_int64", "m68k_return_pops_args", "(", "tree", "fundecl", ",", "tree", "funtype", ",", "poly_int64", "size", ")", "{", "return", "(", "(", "TARGET_RTD", "&&", "(", "!", "fundecl", "||", "TREE_CODE", "(", "fundecl", ")", "!=", "IDENTIFIER_NODE", ")", "&&", "(", "!", "stdarg_p", "(", "funtype", ")", ")", ")", "?", "(", "HOST_WIDE_INT", ")", "size", ":", "0", ")", ";", "}", "</s>"], "natrual_language": ["On", "the", "68000", ",", "the", "RTS", "insn", "can", "not", "pop", "anything", ".", "On", "the", "68010", ",", "the", "RTD", "insn", "may", "be", "used", "to", "pop", "them", "if", "the", "number", "of", "args", "is", "fixed", ",", "but", "if", "the", "number", "is", "variable", "then", "the", "caller", "must", "pop", "them", "all", ".", "RTD", "ca", "n't", "be", "used", "for", "library", "calls", "now", "because", "the", "library", "is", "compiled", "with", "the", "Unix", "compiler", ".", "Use", "of", "RTD", "is", "a", "selectable", "option", ",", "since", "it", "is", "incompatible", "with", "standard", "Unix", "calling", "sequences", ".", "If", "the", "option", "is", "not", "selected", ",", "the", "caller", "must", "always", "pop", "the", "args", "."], "TS_V_token": ["m68k", "0"], "File": "m68k", "Func": "m68k_return_pops_args", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42744, "Length": 49}
{"ground_truth": ["<s>", "static", "bool", "m68k_save_reg", "(", "unsigned", "int", "regno", ",", "bool", "interrupt_handler", ")", "{", "if", "(", "flag_pic", "&&", "regno", "==", "PIC_REG", ")", "{", "if", "(", "crtl", "->", "saves_all_registers", ")", "return", "true", ";", "if", "(", "crtl", "->", "uses_pic_offset_table", ")", "return", "true", ";", "if", "(", "crtl", "->", "uses_const_pool", ")", "return", "true", ";", "}", "if", "(", "crtl", "->", "calls_eh_return", ")", "{", "unsigned", "int", "i", ";", "for", "(", "i", "=", "0", ";", ";", "i", "++", ")", "{", "unsigned", "int", "test", "=", "EH_RETURN_DATA_REGNO", "(", "i", ")", ";", "if", "(", "test", "==", "INVALID_REGNUM", ")", "break", ";", "if", "(", "test", "==", "regno", ")", "return", "true", ";", "}", "}", "if", "(", "fixed_regs", "[", "regno", "]", ")", "return", "false", ";", "if", "(", "regno", "==", "FRAME_POINTER_REGNUM", "&&", "frame_pointer_needed", ")", "return", "false", ";", "if", "(", "interrupt_handler", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", ")", "return", "true", ";", "if", "(", "!", "crtl", "->", "is_leaf", "&&", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", "return", "true", ";", "}", "if", "(", "!", "df_regs_ever_live_p", "(", "regno", ")", ")", "return", "false", ";", "return", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", ";", "}", "</s>"], "natrual_language": ["Refer", "to", "the", "array", "`", "regs_ever_live", "'", "to", "determine", "which", "registers", "to", "save", ";", "`", "regs_ever_live", "[", "I", "]", "'", "is", "nonzero", "if", "register", "number", "I", "is", "ever", "used", "in", "the", "function", ".", "This", "function", "is", "responsible", "for", "knowing", "which", "registers", "should", "not", "be", "saved", "even", "if", "used", ".", "Return", "true", "if", "we", "need", "to", "save", "REGNO", "."], "TS_V_token": ["m68k", "0"], "File": "m68k", "Func": "m68k_save_reg", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42745, "Length": 170}
{"ground_truth": ["<s>", "int", "m68k_sched_address_bypass_p", "(", "rtx_insn", "*", "pro", ",", "rtx_insn", "*", "con", ")", "{", "rtx", "pro_x", ";", "rtx", "con_mem_read", ";", "pro_x", "=", "sched_get_reg_operand", "(", "pro", ",", "true", ")", ";", "if", "(", "pro_x", "==", "NULL", ")", "return", "0", ";", "con_mem_read", "=", "sched_get_mem_operand", "(", "con", ",", "true", ",", "false", ")", ";", "gcc_assert", "(", "con_mem_read", "!=", "NULL", ")", ";", "if", "(", "reg_mentioned_p", "(", "pro_x", ",", "con_mem_read", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>"], "natrual_language": ["Return", "non-zero", "if", "PRO", "modifies", "register", "used", "as", "part", "of", "address", "in", "CON", "."], "TS_V_token": ["m68k", "0", "1", "0"], "File": "m68k", "Func": "m68k_sched_address_bypass_p", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42746, "Length": 70}
{"ground_truth": ["<s>", "static", "int", "m68k_sched_adjust_cost", "(", "rtx_insn", "*", "insn", ",", "int", ",", "rtx_insn", "*", "def_insn", ",", "int", "cost", ",", "unsigned", "int", ")", "{", "int", "delay", ";", "if", "(", "recog_memoized", "(", "def_insn", ")", "<", "0", "||", "recog_memoized", "(", "insn", ")", "<", "0", ")", "return", "cost", ";", "if", "(", "sched_cfv4_bypass_data", ".", "scale", "==", "1", ")", "{", "gcc_assert", "(", "sched_cfv4_bypass_data", ".", "pro", "==", "def_insn", "&&", "sched_cfv4_bypass_data", ".", "con", "==", "insn", ")", ";", "if", "(", "cost", "<", "3", ")", "cost", "=", "3", ";", "sched_cfv4_bypass_data", ".", "pro", "=", "NULL", ";", "sched_cfv4_bypass_data", ".", "con", "=", "NULL", ";", "sched_cfv4_bypass_data", ".", "scale", "=", "0", ";", "}", "else", "gcc_assert", "(", "sched_cfv4_bypass_data", ".", "pro", "==", "NULL", "&&", "sched_cfv4_bypass_data", ".", "con", "==", "NULL", "&&", "sched_cfv4_bypass_data", ".", "scale", "==", "0", ")", ";", "delay", "=", "min_insn_conflict_delay", "(", "sched_adjust_cost_state", ",", "def_insn", ",", "insn", ")", ";", "if", "(", "delay", ">", "cost", ")", "cost", "=", "delay", ";", "return", "cost", ";", "}", "</s>"], "natrual_language": ["Implement", "adjust_cost", "scheduler", "hook", ".", "Return", "adjusted", "COST", "of", "dependency", "LINK", "between", "DEF_INSN", "and", "INSN", "."], "TS_V_token": ["m68k", "0", "0", "1", "3", "3", "0", "0"], "File": "m68k", "Func": "m68k_sched_adjust_cost", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42747, "Length": 143}
{"ground_truth": ["<s>", "enum", "attr_opx_type", "m68k_sched_attr_opx_type", "(", "rtx_insn", "*", "insn", ",", "int", "address_p", ")", "{", "switch", "(", "sched_attr_op_type", "(", "insn", ",", "true", ",", "address_p", "!=", "0", ")", ")", "{", "case", "OP_TYPE_RN", ":", "return", "OPX_TYPE_RN", ";", "case", "OP_TYPE_FPN", ":", "return", "OPX_TYPE_FPN", ";", "case", "OP_TYPE_MEM1", ":", "return", "OPX_TYPE_MEM1", ";", "case", "OP_TYPE_MEM234", ":", "return", "OPX_TYPE_MEM234", ";", "case", "OP_TYPE_MEM5", ":", "return", "OPX_TYPE_MEM5", ";", "case", "OP_TYPE_MEM6", ":", "return", "OPX_TYPE_MEM6", ";", "case", "OP_TYPE_MEM7", ":", "return", "OPX_TYPE_MEM7", ";", "case", "OP_TYPE_IMM_Q", ":", "return", "OPX_TYPE_IMM_Q", ";", "case", "OP_TYPE_IMM_W", ":", "return", "OPX_TYPE_IMM_W", ";", "case", "OP_TYPE_IMM_L", ":", "return", "OPX_TYPE_IMM_L", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Implement", "opx_type", "attribute", ".", "Return", "type", "of", "INSN", "'s", "operand", "X", ".", "If", "ADDRESS_P", "is", "true", ",", "return", "type", "of", "memory", "location", "operand", "refers", "to", "."], "TS_V_token": ["m68k", "0"], "File": "m68k", "Func": "m68k_sched_attr_opx_type", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42748, "Length": 94}
{"ground_truth": ["<s>", "enum", "attr_opy_type", "m68k_sched_attr_opy_type", "(", "rtx_insn", "*", "insn", ",", "int", "address_p", ")", "{", "switch", "(", "sched_attr_op_type", "(", "insn", ",", "false", ",", "address_p", "!=", "0", ")", ")", "{", "case", "OP_TYPE_RN", ":", "return", "OPY_TYPE_RN", ";", "case", "OP_TYPE_FPN", ":", "return", "OPY_TYPE_FPN", ";", "case", "OP_TYPE_MEM1", ":", "return", "OPY_TYPE_MEM1", ";", "case", "OP_TYPE_MEM234", ":", "return", "OPY_TYPE_MEM234", ";", "case", "OP_TYPE_MEM5", ":", "return", "OPY_TYPE_MEM5", ";", "case", "OP_TYPE_MEM6", ":", "return", "OPY_TYPE_MEM6", ";", "case", "OP_TYPE_MEM7", ":", "return", "OPY_TYPE_MEM7", ";", "case", "OP_TYPE_IMM_Q", ":", "return", "OPY_TYPE_IMM_Q", ";", "case", "OP_TYPE_IMM_W", ":", "return", "OPY_TYPE_IMM_W", ";", "case", "OP_TYPE_IMM_L", ":", "return", "OPY_TYPE_IMM_L", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Implement", "opy_type", "attribute", ".", "Return", "type", "of", "INSN", "'s", "operand", "Y", ".", "If", "ADDRESS_P", "is", "true", ",", "return", "type", "of", "memory", "location", "operand", "refers", "to", "."], "TS_V_token": ["m68k", "0"], "File": "m68k", "Func": "m68k_sched_attr_opy_type", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42749, "Length": 94}
{"ground_truth": ["<s>", "enum", "attr_op_mem", "m68k_sched_attr_op_mem", "(", "rtx_insn", "*", "insn", ")", "{", "enum", "attr_op_type", "opx", ";", "enum", "attr_op_type", "opy", ";", "opx", "=", "sched_get_opxy_mem_type", "(", "insn", ",", "true", ")", ";", "opy", "=", "sched_get_opxy_mem_type", "(", "insn", ",", "false", ")", ";", "if", "(", "opy", "==", "OP_TYPE_RN", "&&", "opx", "==", "OP_TYPE_RN", ")", "return", "OP_MEM_00", ";", "if", "(", "opy", "==", "OP_TYPE_RN", "&&", "opx", "==", "OP_TYPE_MEM1", ")", "{", "switch", "(", "get_attr_opx_access", "(", "insn", ")", ")", "{", "case", "OPX_ACCESS_R", ":", "return", "OP_MEM_10", ";", "case", "OPX_ACCESS_W", ":", "return", "OP_MEM_01", ";", "case", "OPX_ACCESS_RW", ":", "return", "OP_MEM_11", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "if", "(", "opy", "==", "OP_TYPE_RN", "&&", "opx", "==", "OP_TYPE_MEM6", ")", "{", "switch", "(", "get_attr_opx_access", "(", "insn", ")", ")", "{", "case", "OPX_ACCESS_R", ":", "return", "OP_MEM_I0", ";", "case", "OPX_ACCESS_W", ":", "return", "OP_MEM_0I", ";", "case", "OPX_ACCESS_RW", ":", "return", "OP_MEM_I1", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "if", "(", "opy", "==", "OP_TYPE_MEM1", "&&", "opx", "==", "OP_TYPE_RN", ")", "return", "OP_MEM_10", ";", "if", "(", "opy", "==", "OP_TYPE_MEM1", "&&", "opx", "==", "OP_TYPE_MEM1", ")", "{", "switch", "(", "get_attr_opx_access", "(", "insn", ")", ")", "{", "case", "OPX_ACCESS_W", ":", "return", "OP_MEM_11", ";", "default", ":", "gcc_assert", "(", "!", "reload_completed", ")", ";", "return", "OP_MEM_11", ";", "}", "}", "if", "(", "opy", "==", "OP_TYPE_MEM1", "&&", "opx", "==", "OP_TYPE_MEM6", ")", "{", "switch", "(", "get_attr_opx_access", "(", "insn", ")", ")", "{", "case", "OPX_ACCESS_W", ":", "return", "OP_MEM_1I", ";", "default", ":", "gcc_assert", "(", "!", "reload_completed", ")", ";", "return", "OP_MEM_1I", ";", "}", "}", "if", "(", "opy", "==", "OP_TYPE_MEM6", "&&", "opx", "==", "OP_TYPE_RN", ")", "return", "OP_MEM_I0", ";", "if", "(", "opy", "==", "OP_TYPE_MEM6", "&&", "opx", "==", "OP_TYPE_MEM1", ")", "{", "switch", "(", "get_attr_opx_access", "(", "insn", ")", ")", "{", "case", "OPX_ACCESS_W", ":", "return", "OP_MEM_I1", ";", "default", ":", "gcc_assert", "(", "!", "reload_completed", ")", ";", "return", "OP_MEM_I1", ";", "}", "}", "gcc_assert", "(", "opy", "==", "OP_TYPE_MEM6", "&&", "opx", "==", "OP_TYPE_MEM6", ")", ";", "gcc_assert", "(", "!", "reload_completed", ")", ";", "return", "OP_MEM_I1", ";", "}", "</s>"], "natrual_language": ["Implement", "op_mem", "attribute", "."], "TS_V_token": ["m68k"], "File": "m68k", "Func": "m68k_sched_attr_op_mem", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42750, "Length": 299}
{"ground_truth": ["<s>", "enum", "attr_size", "m68k_sched_attr_size", "(", "rtx_insn", "*", "insn", ")", "{", "switch", "(", "sched_get_attr_size_int", "(", "insn", ")", ")", "{", "case", "1", ":", "return", "SIZE_1", ";", "case", "2", ":", "return", "SIZE_2", ";", "case", "3", ":", "return", "SIZE_3", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Return", "size", "of", "INSN", "as", "attribute", "enum", "value", "."], "TS_V_token": ["m68k", "1", "2", "3"], "File": "m68k", "Func": "m68k_sched_attr_size", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42751, "Length": 43}
{"ground_truth": ["<s>", "static", "void", "m68k_sched_dfa_post_advance_cycle", "(", "void", ")", "{", "int", "i", ";", "if", "(", "!", "sched_ib", ".", "enabled_p", ")", "return", ";", "i", "=", "max_insn_size", "-", "sched_ib", ".", "filled", ";", "while", "(", "--", "i", ">=", "0", ")", "{", "if", "(", "state_transition", "(", "curr_state", ",", "sched_ib", ".", "insn", ")", ">=", "0", ")", "++", "sched_ib", ".", "filled", ";", "}", "}", "</s>"], "natrual_language": ["Implementation", "of", "targetm.sched.dfa_post_advance_cycle", "(", ")", "hook", ".", "It", "is", "invoked", "just", "after", "new", "cycle", "begins", "and", "is", "used", "here", "to", "setup", "number", "of", "filled", "words", "in", "the", "instruction", "buffer", "so", "that", "instructions", "which", "wo", "n't", "have", "all", "their", "words", "prefetched", "would", "be", "stalled", "for", "a", "cycle", "."], "TS_V_token": ["m68k", "0", "0"], "File": "m68k", "Func": "m68k_sched_dfa_post_advance_cycle", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42752, "Length": 55}
{"ground_truth": ["<s>", "static", "void", "m68k_sched_dfa_pre_advance_cycle", "(", "void", ")", "{", "if", "(", "!", "sched_ib", ".", "enabled_p", ")", "return", ";", "if", "(", "!", "cpu_unit_reservation_p", "(", "curr_state", ",", "sched_mem_unit_code", ")", ")", "{", "sched_ib", ".", "filled", "+=", "2", ";", "if", "(", "sched_ib", ".", "filled", ">", "sched_ib", ".", "size", ")", "sched_ib", ".", "filled", "=", "sched_ib", ".", "size", ";", "}", "}", "</s>"], "natrual_language": ["Implementation", "of", "targetm.sched.dfa_pre_advance_cycle", "(", ")", "hook", ".", "It", "is", "invoked", "just", "before", "current", "cycle", "finishes", "and", "is", "used", "here", "to", "track", "if", "instruction", "buffer", "got", "its", "two", "words", "this", "cycle", "."], "TS_V_token": ["m68k", "2"], "File": "m68k", "Func": "m68k_sched_dfa_pre_advance_cycle", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42753, "Length": 53}
{"ground_truth": ["<s>", "static", "int", "m68k_sched_first_cycle_multipass_dfa_lookahead", "(", "void", ")", "{", "return", "m68k_sched_issue_rate", "(", ")", "-", "1", ";", "}", "</s>"], "natrual_language": ["Return", "how", "many", "instructions", "should", "scheduler", "lookahead", "to", "choose", "the", "best", "one", "."], "TS_V_token": ["m68k", "1"], "File": "m68k", "Func": "m68k_sched_first_cycle_multipass_dfa_lookahead", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42754, "Length": 15}
{"ground_truth": ["<s>", "int", "m68k_sched_indexed_address_bypass_p", "(", "rtx_insn", "*", "pro", ",", "rtx_insn", "*", "con", ")", "{", "gcc_assert", "(", "sched_cfv4_bypass_data", ".", "pro", "==", "NULL", "&&", "sched_cfv4_bypass_data", ".", "con", "==", "NULL", "&&", "sched_cfv4_bypass_data", ".", "scale", "==", "0", ")", ";", "switch", "(", "sched_get_indexed_address_scale", "(", "pro", ",", "con", ")", ")", "{", "case", "1", ":", "sched_cfv4_bypass_data", ".", "pro", "=", "pro", ";", "sched_cfv4_bypass_data", ".", "con", "=", "con", ";", "sched_cfv4_bypass_data", ".", "scale", "=", "1", ";", "return", "0", ";", "case", "2", ":", "case", "4", ":", "return", "1", ";", "default", ":", "return", "0", ";", "}", "}", "</s>"], "natrual_language": ["Return", "non-zero", "if", "PRO", "modifies", "register", "used", "as", "index", "with", "scale", "2", "or", "4", "in", "CON", "."], "TS_V_token": ["m68k", "0", "1", "1", "0", "2", "4", "1", "0"], "File": "m68k", "Func": "m68k_sched_indexed_address_bypass_p", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42755, "Length": 83}
{"ground_truth": ["<s>", "static", "int", "m68k_sched_issue_rate", "(", "void", ")", "{", "switch", "(", "m68k_sched_cpu", ")", "{", "case", "CPU_CFV1", ":", "case", "CPU_CFV2", ":", "case", "CPU_CFV3", ":", "return", "1", ";", "case", "CPU_CFV4", ":", "return", "2", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "return", "0", ";", "}", "}", "</s>"], "natrual_language": ["Return", "maximal", "number", "of", "insns", "that", "can", "be", "scheduled", "on", "a", "single", "cycle", "."], "TS_V_token": ["m68k", "1", "2", "0"], "File": "m68k", "Func": "m68k_sched_issue_rate", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42756, "Length": 41}
{"ground_truth": ["<s>", "enum", "reg_class", "m68k_secondary_reload_class", "(", "enum", "reg_class", "rclass", ",", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "int", "regno", ";", "regno", "=", "true_regnum", "(", "x", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "1", "&&", "reg_classes_intersect_p", "(", "rclass", ",", "ADDR_REGS", ")", "&&", "!", "(", "INT_REGNO_P", "(", "regno", ")", "||", "CONSTANT_P", "(", "x", ")", ")", ")", "return", "DATA_REGS", ";", "if", "(", "TARGET_PCREL", "&&", "!", "reg_class_subset_p", "(", "rclass", ",", "ADDR_REGS", ")", "&&", "symbolic_operand", "(", "x", ",", "VOIDmode", ")", ")", "return", "ADDR_REGS", ";", "return", "NO_REGS", ";", "}", "</s>"], "natrual_language": ["Implement", "SECONDARY_RELOAD_CLASS", "."], "TS_V_token": ["m68k", "1"], "File": "m68k", "Func": "m68k_secondary_reload_class", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42757, "Length": 83}
{"ground_truth": ["<s>", "static", "void", "m68k_set_frame_related", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "body", ";", "int", "i", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "body", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "body", ")", "==", "PARALLEL", ")", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "body", ",", "0", ")", ";", "i", "++", ")", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "body", ",", "0", ",", "i", ")", ")", "=", "1", ";", "}", "</s>"], "natrual_language": ["Make", "INSN", "a", "frame-related", "instruction", "."], "TS_V_token": ["m68k", "1", "0", "0", "0", "1"], "File": "m68k", "Func": "m68k_set_frame_related", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42758, "Length": 71}
{"ground_truth": ["<s>", "static", "void", "m68k_split_offset", "(", "rtx", "x", ",", "rtx", "*", "base", ",", "HOST_WIDE_INT", "*", "offset", ")", "{", "*", "offset", "=", "0", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "{", "*", "offset", "+=", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "}", "*", "base", "=", "x", ";", "}", "</s>"], "natrual_language": ["Split", "X", "into", "a", "base", "and", "a", "constant", "offset", ",", "storing", "them", "in", "*", "BASE", "and", "*", "OFFSET", "respectively", "."], "TS_V_token": ["m68k", "0", "1", "1", "0"], "File": "m68k", "Func": "m68k_split_offset", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42759, "Length": 72}
{"ground_truth": ["<s>", "static", "rtx", "m68k_struct_value_rtx", "(", "tree", "fntype", "ATTRIBUTE_UNUSED", ",", "int", "incoming", "ATTRIBUTE_UNUSED", ")", "{", "return", "gen_rtx_REG", "(", "Pmode", ",", "M68K_STRUCT_VALUE_REGNUM", ")", ";", "}", "</s>"], "natrual_language": ["Worker", "function", "for", "TARGET_STRUCT_VALUE_RTX", "."], "TS_V_token": ["m68k"], "File": "m68k", "Func": "m68k_struct_value_rtx", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42760, "Length": 22}
{"ground_truth": ["<s>", "bool", "m68k_tls_reference_p", "(", "rtx", "x", ",", "bool", "legitimate_p", ")", "{", "if", "(", "!", "TARGET_HAVE_TLS", ")", "return", "false", ";", "if", "(", "!", "legitimate_p", ")", "{", "subrtx_var_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX_VAR", "(", "iter", ",", "array", ",", "x", ",", "ALL", ")", "{", "rtx", "x", "=", "*", "iter", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "!=", "0", ")", "return", "true", ";", "if", "(", "m68k_tls_reference_p", "(", "x", ",", "true", ")", ")", "iter", ".", "skip_subrtxes", "(", ")", ";", "}", "return", "false", ";", "}", "else", "{", "enum", "m68k_reloc", "reloc", "=", "RELOC_GOT", ";", "return", "(", "m68k_unwrap_symbol_1", "(", "x", ",", "true", ",", "&", "reloc", ")", "!=", "x", "&&", "TLS_RELOC_P", "(", "reloc", ")", ")", ";", "}", "}", "</s>"], "natrual_language": ["If", "!", "LEGITIMATE_P", ",", "return", "true", "if", "X", "is", "a", "TLS", "symbol", "reference", ",", "though", "illegitimate", "one", ".", "If", "LEGITIMATE_P", ",", "return", "true", "if", "X", "is", "a", "legitimate", "TLS", "symbol", "reference", "."], "TS_V_token": ["m68k", "0"], "File": "m68k", "Func": "m68k_tls_reference_p", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42761, "Length": 115}
{"ground_truth": ["<s>", "static", "bool", "m68k_tls_symbol_p", "(", "rtx", "x", ")", "{", "if", "(", "!", "TARGET_HAVE_TLS", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "SYMBOL_REF", ")", "return", "false", ";", "return", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "!=", "0", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "X", "is", "a", "TLS", "symbol", "."], "TS_V_token": ["m68k", "0"], "File": "m68k", "Func": "m68k_tls_symbol_p", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42762, "Length": 37}
{"ground_truth": ["<s>", "static", "void", "m68k_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "chain_value", ")", "{", "rtx", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "rtx", "mem", ";", "gcc_assert", "(", "ADDRESS_REGNO_P", "(", "STATIC_CHAIN_REGNUM", ")", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "HImode", ",", "0", ")", ";", "emit_move_insn", "(", "mem", ",", "GEN_INT", "(", "0x207C", "+", "(", "(", "STATIC_CHAIN_REGNUM", "-", "8", ")", "<<", "9", ")", ")", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "2", ")", ";", "emit_move_insn", "(", "mem", ",", "chain_value", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "HImode", ",", "6", ")", ";", "emit_move_insn", "(", "mem", ",", "GEN_INT", "(", "0x4EF9", ")", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "8", ")", ";", "emit_move_insn", "(", "mem", ",", "fnaddr", ")", ";", "FINALIZE_TRAMPOLINE", "(", "XEXP", "(", "m_tramp", ",", "0", ")", ")", ";", "}", "</s>"], "natrual_language": ["We", "generate", "a", "two-instructions", "program", "at", "M_TRAMP", ":", "movea.l", "&", "CHAIN_VALUE", ",", "%", "a0", "jmp", "FNADDR", "where", "%", "a0", "can", "be", "modified", "by", "changing", "STATIC_CHAIN_REGNUM", "."], "TS_V_token": ["m68k", "0", "0", "0x207C", "8", "9", "2", "6", "0x4EF9", "8", "0"], "File": "m68k", "Func": "m68k_trampoline_init", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42763, "Length": 137}
{"ground_truth": ["<s>", "rtx", "m68k_unwrap_symbol", "(", "rtx", "orig", ",", "bool", "unwrap_reloc32_p", ")", "{", "return", "m68k_unwrap_symbol_1", "(", "orig", ",", "unwrap_reloc32_p", ",", "NULL", ")", ";", "}", "</s>"], "natrual_language": ["Unwrap", "symbol", "from", "UNSPEC_RELOC16", "and", ",", "if", "unwrap_reloc32_p", ",", "UNSPEC_RELOC32", "wrappers", "."], "TS_V_token": ["m68k"], "File": "m68k", "Func": "m68k_unwrap_symbol", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42764, "Length": 21}
{"ground_truth": ["<s>", "static", "rtx", "m68k_unwrap_symbol_1", "(", "rtx", "orig", ",", "bool", "unwrap_reloc32_p", ",", "enum", "m68k_reloc", "*", "reloc_ptr", ")", "{", "if", "(", "GET_CODE", "(", "orig", ")", "==", "CONST", ")", "{", "rtx", "x", ";", "enum", "m68k_reloc", "dummy", ";", "x", "=", "XEXP", "(", "orig", ",", "0", ")", ";", "if", "(", "reloc_ptr", "==", "NULL", ")", "reloc_ptr", "=", "&", "dummy", ";", "if", "(", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "||", "GET_CODE", "(", "x", ")", "==", "MINUS", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", ")", "{", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "case", "UNSPEC_RELOC16", ":", "orig", "=", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ";", "*", "reloc_ptr", "=", "(", "enum", "m68k_reloc", ")", "INTVAL", "(", "XVECEXP", "(", "x", ",", "0", ",", "1", ")", ")", ";", "break", ";", "case", "UNSPEC_RELOC32", ":", "if", "(", "unwrap_reloc32_p", ")", "{", "orig", "=", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ";", "*", "reloc_ptr", "=", "(", "enum", "m68k_reloc", ")", "INTVAL", "(", "XVECEXP", "(", "x", ",", "0", ",", "1", ")", ")", ";", "}", "break", ";", "default", ":", "break", ";", "}", "}", "}", "return", "orig", ";", "}", "</s>"], "natrual_language": ["Helper", "for", "m68k_unwrap_symbol", ".", "Also", ",", "if", "unwrapping", "was", "successful", "(", "that", "is", "if", "(", "ORIG", "!", "=", "<", "return", "value", ">", ")", ")", ",", "sets", "*", "RELOC_PTR", "to", "relocation", "type", "for", "the", "symbol", "."], "TS_V_token": ["m68k", "0", "1", "0", "1", "0", "0", "0", "1", "0", "0", "0", "1"], "File": "m68k", "Func": "m68k_unwrap_symbol_1", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42765, "Length": 197}
{"ground_truth": ["<s>", "bool", "m68k_use_return_insn", "(", "void", ")", "{", "if", "(", "!", "reload_completed", "||", "frame_pointer_needed", "||", "get_frame_size", "(", ")", "!=", "0", ")", "return", "false", ";", "m68k_compute_frame_layout", "(", ")", ";", "return", "current_frame", ".", "offset", "==", "0", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "a", "simple", "(", "return", ")", "instruction", "is", "sufficient", "for", "this", "instruction", "(", "i.e", ".", "if", "no", "epilogue", "is", "needed", ")", "."], "TS_V_token": ["m68k", "0", "0"], "File": "m68k", "Func": "m68k_use_return_insn", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42766, "Length": 34}
{"ground_truth": ["<s>", "static", "rtx", "m68k_wrap_symbol", "(", "rtx", "x", ",", "enum", "m68k_reloc", "reloc", ",", "rtx", "base_reg", ",", "rtx", "temp_reg", ")", "{", "bool", "use_x_p", ";", "use_x_p", "=", "(", "base_reg", "==", "pic_offset_table_rtx", ")", "?", "TARGET_XGOT", ":", "TARGET_XTLS", ";", "if", "(", "TARGET_COLDFIRE", "&&", "use_x_p", ")", "{", "x", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "2", ",", "x", ",", "GEN_INT", "(", "reloc", ")", ")", ",", "UNSPEC_RELOC32", ")", ";", "x", "=", "gen_rtx_CONST", "(", "Pmode", ",", "x", ")", ";", "if", "(", "temp_reg", "==", "NULL", ")", "{", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "temp_reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "}", "emit_move_insn", "(", "temp_reg", ",", "x", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "temp_reg", ",", "temp_reg", ",", "base_reg", ")", ")", ";", "x", "=", "temp_reg", ";", "}", "else", "{", "x", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "2", ",", "x", ",", "GEN_INT", "(", "reloc", ")", ")", ",", "UNSPEC_RELOC16", ")", ";", "x", "=", "gen_rtx_CONST", "(", "Pmode", ",", "x", ")", ";", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "base_reg", ",", "x", ")", ";", "}", "return", "x", ";", "}", "</s>"], "natrual_language": ["Wrap", "symbol", "X", "into", "unspec", "representing", "relocation", "RELOC", ".", "BASE_REG", "-", "register", "that", "should", "be", "added", "to", "the", "result", ".", "TEMP_REG", "-", "if", "non-null", ",", "temporary", "register", "."], "TS_V_token": ["m68k", "2", "2"], "File": "m68k", "Func": "m68k_wrap_symbol", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42767, "Length": 164}
{"ground_truth": ["<s>", "static", "rtx", "m68k_wrap_symbol_into_got_ref", "(", "rtx", "x", ",", "enum", "m68k_reloc", "reloc", ",", "rtx", "temp_reg", ")", "{", "x", "=", "m68k_wrap_symbol", "(", "x", ",", "reloc", ",", "m68k_get_gp", "(", ")", ",", "temp_reg", ")", ";", "x", "=", "gen_rtx_MEM", "(", "Pmode", ",", "x", ")", ";", "MEM_READONLY_P", "(", "x", ")", "=", "1", ";", "return", "x", ";", "}", "</s>"], "natrual_language": ["Does", "the", "same", "as", "m68k_wrap_symbol", ",", "but", "returns", "a", "memory", "reference", "to", "GOT", "slot", "."], "TS_V_token": ["m68k", "1"], "File": "m68k", "Func": "m68k_wrap_symbol_into_got_ref", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42768, "Length": 50}
{"ground_truth": ["<s>", "const", "char", "*", "output_addsi3", "(", "rtx", "*", "operands", ")", "{", "if", "(", "!", "operands_match_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", "{", "if", "(", "!", "ADDRESS_REG_P", "(", "operands", "[", "1", "]", ")", ")", "{", "rtx", "tmp", "=", "operands", "[", "1", "]", ";", "operands", "[", "1", "]", "=", "operands", "[", "2", "]", ";", "operands", "[", "2", "]", "=", "tmp", ";", "}", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", "&&", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "-", "32768", "||", "INTVAL", "(", "operands", "[", "2", "]", ")", ">", "32767", ")", ")", "return", "\"move%.l %2,%0\\n\\tadd%.l %1,%0\"", ";", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "REG", ")", "return", "MOTOROLA", "?", "\"lea (%1,%2.l),%0\"", ":", "\"lea %1@(0,%2:l),%0\"", ";", "return", "MOTOROLA", "?", "\"lea (%c2,%1),%0\"", ":", "\"lea %1@(%c2),%0\"", ";", "}", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", "{", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ">", "0", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", "<=", "8", ")", "return", "\"addq%.l %2,%0\"", ";", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "0", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", ">=", "-", "8", ")", "{", "operands", "[", "2", "]", "=", "GEN_INT", "(", "-", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", ";", "return", "\"subq%.l %2,%0\"", ";", "}", "if", "(", "TUNE_CPU32", "&&", "REG_P", "(", "operands", "[", "0", "]", ")", ")", "{", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ">", "8", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", "<=", "16", ")", "{", "operands", "[", "2", "]", "=", "GEN_INT", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "-", "8", ")", ";", "return", "\"addq%.l #8,%0\\n\\taddq%.l %2,%0\"", ";", "}", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "-", "8", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", ">=", "-", "16", ")", "{", "operands", "[", "2", "]", "=", "GEN_INT", "(", "-", "INTVAL", "(", "operands", "[", "2", "]", ")", "-", "8", ")", ";", "return", "\"subq%.l #8,%0\\n\\tsubq%.l %2,%0\"", ";", "}", "}", "if", "(", "ADDRESS_REG_P", "(", "operands", "[", "0", "]", ")", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", ">=", "-", "0x8000", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "0x8000", ")", "{", "if", "(", "TUNE_68040", ")", "return", "\"add%.w %2,%0\"", ";", "else", "return", "MOTOROLA", "?", "\"lea (%c2,%0),%0\"", ":", "\"lea %0@(%c2),%0\"", ";", "}", "}", "return", "\"add%.l %2,%0\"", ";", "}", "</s>"], "natrual_language": ["Output", "assembler", "code", "to", "perform", "a", "32", "bit", "3", "operand", "add", "."], "TS_V_token": ["m68k", "0", "1", "1", "1", "1", "2", "2", "2", "2", "32768", "2", "32767", "\"move%.l %2,%0\\n\\tadd%.l %1,%0\"", "2", "\"lea (%1,%2.l),%0\"", "\"lea %1@(0,%2:l),%0\"", "\"lea (%c2,%1),%0\"", "\"lea %1@(%c2),%0\"", "2", "2", "0", "2", "8", "\"addq%.l %2,%0\"", "2", "0", "2", "8", "2", "2", "\"subq%.l %2,%0\"", "0", "2", "8", "2", "16", "2", "2", "8", "\"addq%.l #8,%0\\n\\taddq%.l %2,%0\"", "2", "8", "2", "16", "2", "2", "8", "\"subq%.l #8,%0\\n\\tsubq%.l %2,%0\"", "0", "2", "0x8000", "2", "0x8000", "\"add%.w %2,%0\"", "\"lea (%c2,%0),%0\"", "\"lea %0@(%c2),%0\"", "\"add%.l %2,%0\""], "File": "m68k", "Func": "output_addsi3", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42769, "Length": 373}
{"ground_truth": ["<s>", "const", "char", "*", "output_call", "(", "rtx", "x", ")", "{", "if", "(", "symbolic_operand", "(", "x", ",", "VOIDmode", ")", ")", "return", "m68k_symbolic_call", ";", "else", "return", "\"jsr %a0\"", ";", "}", "</s>"], "natrual_language": ["INSN", "is", "either", "a", "function", "call", "or", "a", "millicode", "call", ".", "It", "may", "have", "an", "unconditional", "jump", "in", "its", "delay", "slot", ".", "CALL_DEST", "is", "the", "routine", "we", "are", "calling", "."], "TS_V_token": ["m68k", "\"jsr %a0\""], "File": "m68k", "Func": "output_call", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42770, "Length": 26}
{"ground_truth": ["<s>", "static", "void", "output_compadr", "(", "rtx", "operands", "[", "2", "]", ")", "{", "output_asm_insn", "(", "\"lea %a1,%0\"", ",", "operands", ")", ";", "}", "</s>"], "natrual_language": ["Output", "assembler", "to", "load", "address", "OPERANDS", "[", "0", "]", "to", "register", "OPERANDS", "[", "1", "]", "."], "TS_V_token": ["m68k", "2", "\"lea %a1,%0\""], "File": "m68k", "Func": "output_compadr", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42771, "Length": 19}
{"ground_truth": ["<s>", "void", "output_dbcc_and_branch", "(", "rtx", "*", "operands", ",", "rtx_code", "code", ")", "{", "switch", "(", "code", ")", "{", "case", "EQ", ":", "output_asm_insn", "(", "\"dbeq %0,%l1\\n\\tjeq %l2\"", ",", "operands", ")", ";", "break", ";", "case", "NE", ":", "output_asm_insn", "(", "\"dbne %0,%l1\\n\\tjne %l2\"", ",", "operands", ")", ";", "break", ";", "case", "GT", ":", "output_asm_insn", "(", "\"dbgt %0,%l1\\n\\tjgt %l2\"", ",", "operands", ")", ";", "break", ";", "case", "GTU", ":", "output_asm_insn", "(", "\"dbhi %0,%l1\\n\\tjhi %l2\"", ",", "operands", ")", ";", "break", ";", "case", "LT", ":", "output_asm_insn", "(", "\"dblt %0,%l1\\n\\tjlt %l2\"", ",", "operands", ")", ";", "break", ";", "case", "LTU", ":", "output_asm_insn", "(", "\"dbcs %0,%l1\\n\\tjcs %l2\"", ",", "operands", ")", ";", "break", ";", "case", "GE", ":", "output_asm_insn", "(", "\"dbge %0,%l1\\n\\tjge %l2\"", ",", "operands", ")", ";", "break", ";", "case", "GEU", ":", "output_asm_insn", "(", "\"dbcc %0,%l1\\n\\tjcc %l2\"", ",", "operands", ")", ";", "break", ";", "case", "LE", ":", "output_asm_insn", "(", "\"dble %0,%l1\\n\\tjle %l2\"", ",", "operands", ")", ";", "break", ";", "case", "LEU", ":", "output_asm_insn", "(", "\"dbls %0,%l1\\n\\tjls %l2\"", ",", "operands", ")", ";", "break", ";", "case", "PLUS", ":", "output_asm_insn", "(", "\"dbpl %0,%l1\\n\\tjle %l2\"", ",", "operands", ")", ";", "break", ";", "case", "MINUS", ":", "output_asm_insn", "(", "\"dbmi %0,%l1\\n\\tjle %l2\"", ",", "operands", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ")", "{", "case", "E_SImode", ":", "output_asm_insn", "(", "\"clr%.w %0\\n\\tsubq%.l #1,%0\\n\\tjpl %l1\"", ",", "operands", ")", ";", "break", ";", "case", "E_HImode", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Output", "a", "dbCC", ";", "jCC", "sequence", ".", "Note", "we", "do", "not", "handle", "the", "floating", "point", "version", "of", "this", "sequence", "(", "Fdbcc", ")", ".", "We", "also", "do", "not", "handle", "alternative", "conditions", "when", "CC_NO_OVERFLOW", "is", "set", ".", "It", "is", "assumed", "that", "valid_dbcc_comparison_p", "and", "flags_in_68881", "will", "kick", "those", "out", "before", "we", "get", "here", "."], "TS_V_token": ["m68k", "\"dbeq %0,%l1\\n\\tjeq %l2\"", "\"dbne %0,%l1\\n\\tjne %l2\"", "\"dbgt %0,%l1\\n\\tjgt %l2\"", "\"dbhi %0,%l1\\n\\tjhi %l2\"", "\"dblt %0,%l1\\n\\tjlt %l2\"", "\"dbcs %0,%l1\\n\\tjcs %l2\"", "\"dbge %0,%l1\\n\\tjge %l2\"", "\"dbcc %0,%l1\\n\\tjcc %l2\"", "\"dble %0,%l1\\n\\tjle %l2\"", "\"dbls %0,%l1\\n\\tjls %l2\"", "\"dbpl %0,%l1\\n\\tjle %l2\"", "\"dbmi %0,%l1\\n\\tjle %l2\"", "0", "\"clr%.w %0\\n\\tsubq%.l #1,%0\\n\\tjpl %l1\""], "File": "m68k", "Func": "output_dbcc_and_branch", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42772, "Length": 203}
{"ground_truth": ["<s>", "static", "const", "char", "*", "output_move_const_into_data_reg", "(", "rtx", "*", "operands", ")", "{", "HOST_WIDE_INT", "i", ";", "i", "=", "INTVAL", "(", "operands", "[", "1", "]", ")", ";", "switch", "(", "m68k_const_method", "(", "i", ")", ")", "{", "case", "MVZ", ":", "return", "\"mvzw %1,%0\"", ";", "case", "MVS", ":", "return", "\"mvsw %1,%0\"", ";", "case", "MOVQ", ":", "return", "\"moveq %1,%0\"", ";", "case", "NOTB", ":", "CC_STATUS_INIT", ";", "operands", "[", "1", "]", "=", "GEN_INT", "(", "i", "^", "0xff", ")", ";", "return", "\"moveq %1,%0\\n\\tnot%.b %0\"", ";", "case", "NOTW", ":", "CC_STATUS_INIT", ";", "operands", "[", "1", "]", "=", "GEN_INT", "(", "i", "^", "0xffff", ")", ";", "return", "\"moveq %1,%0\\n\\tnot%.w %0\"", ";", "case", "NEGW", ":", "CC_STATUS_INIT", ";", "return", "\"moveq #-128,%0\\n\\tneg%.w %0\"", ";", "case", "SWAP", ":", "{", "unsigned", "u", "=", "i", ";", "operands", "[", "1", "]", "=", "GEN_INT", "(", "(", "u", "<<", "16", ")", "|", "(", "u", ">>", "16", ")", ")", ";", "return", "\"moveq %1,%0\\n\\tswap %0\"", ";", "}", "case", "MOVL", ":", "return", "\"move%.l %1,%0\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Return", "an", "instruction", "to", "move", "CONST_INT", "OPERANDS", "[", "1", "]", "into", "data", "register", "OPERANDS", "[", "0", "]", "."], "TS_V_token": ["m68k", "1", "\"mvzw %1,%0\"", "\"mvsw %1,%0\"", "\"moveq %1,%0\"", "1", "0xff", "\"moveq %1,%0\\n\\tnot%.b %0\"", "1", "0xffff", "\"moveq %1,%0\\n\\tnot%.w %0\"", "\"moveq #-128,%0\\n\\tneg%.w %0\"", "1", "16", "16", "\"moveq %1,%0\\n\\tswap %0\"", "\"move%.l %1,%0\""], "File": "m68k", "Func": "output_move_const_into_data_reg", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42773, "Length": 145}
{"ground_truth": ["<s>", "const", "char", "*", "output_move_double", "(", "rtx", "*", "operands", ")", "{", "handle_move_double", "(", "operands", ",", "output_reg_adjust", ",", "output_compadr", ",", "output_movsi", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["Return", "appropriate", "code", "to", "load", "up", "an", "8", "byte", "integer", "or", "floating", "point", "value"], "TS_V_token": ["m68k", "\"\""], "File": "m68k", "Func": "output_move_double", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42774, "Length": 25}
{"ground_truth": ["<s>", "static", "const", "char", "*", "output_move_simode_const", "(", "rtx", "*", "operands", ")", "{", "rtx", "dest", ";", "HOST_WIDE_INT", "src", ";", "dest", "=", "operands", "[", "0", "]", ";", "src", "=", "INTVAL", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "src", "==", "0", "&&", "(", "DATA_REG_P", "(", "dest", ")", "||", "MEM_P", "(", "dest", ")", ")", "&&", "(", "(", "TARGET_68010", "||", "TARGET_COLDFIRE", ")", "||", "!", "(", "MEM_P", "(", "dest", ")", "&&", "MEM_VOLATILE_P", "(", "dest", ")", ")", ")", ")", "return", "\"clr%.l %0\"", ";", "else", "if", "(", "GET_MODE", "(", "dest", ")", "==", "SImode", "&&", "valid_mov3q_const", "(", "src", ")", ")", "return", "\"mov3q%.l %1,%0\"", ";", "else", "if", "(", "src", "==", "0", "&&", "ADDRESS_REG_P", "(", "dest", ")", ")", "return", "\"sub%.l %0,%0\"", ";", "else", "if", "(", "DATA_REG_P", "(", "dest", ")", ")", "return", "output_move_const_into_data_reg", "(", "operands", ")", ";", "else", "if", "(", "ADDRESS_REG_P", "(", "dest", ")", "&&", "IN_RANGE", "(", "src", ",", "-", "0x8000", ",", "0x7fff", ")", ")", "{", "if", "(", "valid_mov3q_const", "(", "src", ")", ")", "return", "\"mov3q%.l %1,%0\"", ";", "return", "\"move%.w %1,%0\"", ";", "}", "else", "if", "(", "MEM_P", "(", "dest", ")", "&&", "GET_CODE", "(", "XEXP", "(", "dest", ",", "0", ")", ")", "==", "PRE_DEC", "&&", "REGNO", "(", "XEXP", "(", "XEXP", "(", "dest", ",", "0", ")", ",", "0", ")", ")", "==", "STACK_POINTER_REGNUM", "&&", "IN_RANGE", "(", "src", ",", "-", "0x8000", ",", "0x7fff", ")", ")", "{", "if", "(", "valid_mov3q_const", "(", "src", ")", ")", "return", "\"mov3q%.l %1,%-\"", ";", "return", "\"pea %a1\"", ";", "}", "return", "\"move%.l %1,%0\"", ";", "}", "</s>"], "natrual_language": ["Return", "an", "instruction", "to", "move", "CONST_INT", "OPERANDS", "[", "1", "]", "into", "OPERANDS", "[", "0", "]", ".", "I", "is", "the", "value", "of", "OPERANDS", "[", "1", "]", "."], "TS_V_token": ["m68k", "0", "1", "0", "\"clr%.l %0\"", "\"mov3q%.l %1,%0\"", "0", "\"sub%.l %0,%0\"", "0x8000", "0x7fff", "\"mov3q%.l %1,%0\"", "\"move%.w %1,%0\"", "0", "0", "0", "0x8000", "0x7fff", "\"mov3q%.l %1,%-\"", "\"pea %a1\"", "\"move%.l %1,%0\""], "File": "m68k", "Func": "output_move_simode_const", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42775, "Length": 222}
{"ground_truth": ["<s>", "static", "void", "output_movsi", "(", "rtx", "operands", "[", "2", "]", ")", "{", "output_asm_insn", "(", "singlemove_string", "(", "operands", ")", ",", "operands", ")", ";", "}", "</s>"], "natrual_language": ["Output", "the", "best", "assembler", "insn", "for", "moving", "operands", "[", "1", "]", "into", "operands", "[", "0", "]", "as", "a", "fullword", "."], "TS_V_token": ["m68k", "2"], "File": "m68k", "Func": "output_movsi", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42776, "Length": 22}
{"ground_truth": ["<s>", "static", "void", "output_reg_adjust", "(", "rtx", "reg", ",", "int", "n", ")", "{", "const", "char", "*", "s", ";", "gcc_assert", "(", "GET_MODE", "(", "reg", ")", "==", "SImode", "&&", "n", ">=", "-", "12", "&&", "n", "!=", "0", "&&", "n", "<=", "12", ")", ";", "switch", "(", "n", ")", "{", "case", "12", ":", "s", "=", "\"add%.l #12,%0\"", ";", "break", ";", "case", "8", ":", "s", "=", "\"addq%.l #8,%0\"", ";", "break", ";", "case", "4", ":", "s", "=", "\"addq%.l #4,%0\"", ";", "break", ";", "case", "-", "12", ":", "s", "=", "\"sub%.l #12,%0\"", ";", "break", ";", "case", "-", "8", ":", "s", "=", "\"subq%.l #8,%0\"", ";", "break", ";", "case", "-", "4", ":", "s", "=", "\"subq%.l #4,%0\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "s", "=", "NULL", ";", "}", "output_asm_insn", "(", "s", ",", "&", "reg", ")", ";", "}", "</s>"], "natrual_language": ["Output", "assembler", "code", "to", "adjust", "REG", "by", "N", "."], "TS_V_token": ["m68k", "12", "0", "12", "12", "\"add%.l #12,%0\"", "8", "\"addq%.l #8,%0\"", "4", "\"addq%.l #4,%0\"", "12", "\"sub%.l #12,%0\"", "8", "\"subq%.l #8,%0\"", "4", "\"subq%.l #4,%0\""], "File": "m68k", "Func": "output_reg_adjust", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42777, "Length": 121}
{"ground_truth": ["<s>", "const", "char", "*", "output_sibcall", "(", "rtx", "x", ")", "{", "if", "(", "symbolic_operand", "(", "x", ",", "VOIDmode", ")", ")", "return", "m68k_symbolic_jump", ";", "else", "return", "\"jmp %a0\"", ";", "}", "</s>"], "natrual_language": ["Output", "a", "sibling", "call", "."], "TS_V_token": ["m68k", "\"jmp %a0\""], "File": "m68k", "Func": "output_sibcall", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42778, "Length": 26}
{"ground_truth": ["<s>", "static", "enum", "attr_op_type", "sched_address_type", "(", "machine_mode", "mode", ",", "rtx", "addr_rtx", ")", "{", "struct", "m68k_address", "address", ";", "if", "(", "symbolic_operand", "(", "addr_rtx", ",", "VOIDmode", ")", ")", "return", "OP_TYPE_MEM7", ";", "if", "(", "!", "m68k_decompose_address", "(", "mode", ",", "addr_rtx", ",", "reload_completed", ",", "&", "address", ")", ")", "{", "gcc_assert", "(", "!", "reload_completed", ")", ";", "return", "OP_TYPE_MEM234", ";", "}", "if", "(", "address", ".", "scale", "!=", "0", ")", "return", "OP_TYPE_MEM6", ";", "if", "(", "address", ".", "base", "!=", "NULL_RTX", ")", "{", "if", "(", "address", ".", "offset", "==", "NULL_RTX", ")", "return", "OP_TYPE_MEM234", ";", "return", "OP_TYPE_MEM5", ";", "}", "gcc_assert", "(", "address", ".", "offset", "!=", "NULL_RTX", ")", ";", "return", "OP_TYPE_MEM7", ";", "}", "</s>"], "natrual_language": ["Return", "type", "of", "memory", "ADDR_RTX", "refers", "to", "."], "TS_V_token": ["m68k", "0"], "File": "m68k", "Func": "sched_address_type", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42779, "Length": 102}
{"ground_truth": ["<s>", "static", "enum", "attr_op_type", "sched_attr_op_type", "(", "rtx_insn", "*", "insn", ",", "bool", "opx_p", ",", "bool", "address_p", ")", "{", "rtx", "op", ";", "op", "=", "sched_get_operand", "(", "insn", ",", "opx_p", ")", ";", "if", "(", "op", "==", "NULL", ")", "{", "gcc_assert", "(", "!", "reload_completed", ")", ";", "return", "OP_TYPE_RN", ";", "}", "if", "(", "address_p", ")", "return", "sched_address_type", "(", "QImode", ",", "op", ")", ";", "if", "(", "memory_operand", "(", "op", ",", "VOIDmode", ")", ")", "return", "sched_address_type", "(", "GET_MODE", "(", "op", ")", ",", "XEXP", "(", "op", ",", "0", ")", ")", ";", "if", "(", "register_operand", "(", "op", ",", "VOIDmode", ")", ")", "{", "if", "(", "(", "!", "reload_completed", "&&", "FLOAT_MODE_P", "(", "GET_MODE", "(", "op", ")", ")", ")", "||", "(", "reload_completed", "&&", "FP_REG_P", "(", "op", ")", ")", ")", "return", "OP_TYPE_FPN", ";", "return", "OP_TYPE_RN", ";", "}", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", ")", "{", "int", "ival", ";", "ival", "=", "INTVAL", "(", "op", ")", ";", "switch", "(", "get_attr_type", "(", "insn", ")", ")", "{", "case", "TYPE_ALUQ_L", ":", "if", "(", "IN_RANGE", "(", "ival", ",", "1", ",", "8", ")", "||", "IN_RANGE", "(", "ival", ",", "-", "8", ",", "-", "1", ")", ")", "return", "OP_TYPE_IMM_Q", ";", "gcc_assert", "(", "!", "reload_completed", ")", ";", "break", ";", "case", "TYPE_MOVEQ_L", ":", "if", "(", "USE_MOVQ", "(", "ival", ")", ")", "return", "OP_TYPE_IMM_Q", ";", "gcc_assert", "(", "!", "reload_completed", ")", ";", "break", ";", "case", "TYPE_MOV3Q_L", ":", "if", "(", "valid_mov3q_const", "(", "ival", ")", ")", "return", "OP_TYPE_IMM_Q", ";", "gcc_assert", "(", "!", "reload_completed", ")", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "IN_RANGE", "(", "ival", ",", "-", "0x8000", ",", "0x7fff", ")", ")", "return", "OP_TYPE_IMM_W", ";", "return", "OP_TYPE_IMM_L", ";", "}", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_DOUBLE", ")", "{", "switch", "(", "GET_MODE", "(", "op", ")", ")", "{", "case", "E_SFmode", ":", "return", "OP_TYPE_IMM_W", ";", "case", "E_VOIDmode", ":", "case", "E_DFmode", ":", "return", "OP_TYPE_IMM_L", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST", "||", "symbolic_operand", "(", "op", ",", "VOIDmode", ")", "||", "LABEL_P", "(", "op", ")", ")", "{", "switch", "(", "GET_MODE", "(", "op", ")", ")", "{", "case", "E_QImode", ":", "return", "OP_TYPE_IMM_Q", ";", "case", "E_HImode", ":", "return", "OP_TYPE_IMM_W", ";", "case", "E_SImode", ":", "return", "OP_TYPE_IMM_L", ";", "default", ":", "if", "(", "symbolic_operand", "(", "m68k_unwrap_symbol", "(", "op", ",", "false", ")", ",", "VOIDmode", ")", ")", "return", "OP_TYPE_IMM_W", ";", "return", "OP_TYPE_IMM_L", ";", "}", "}", "gcc_assert", "(", "!", "reload_completed", ")", ";", "if", "(", "FLOAT_MODE_P", "(", "GET_MODE", "(", "op", ")", ")", ")", "return", "OP_TYPE_FPN", ";", "return", "OP_TYPE_RN", ";", "}", "</s>"], "natrual_language": ["Return", "type", "of", "INSN", "'s", "operand", "X", "(", "if", "OPX_P", ")", "or", "operand", "Y", "(", "if", "!", "OPX_P", ")", ".", "If", "ADDRESS_P", "is", "true", ",", "return", "type", "of", "memory", "location", "operand", "refers", "to", "."], "TS_V_token": ["m68k", "0", "1", "8", "8", "1", "0x8000", "0x7fff"], "File": "m68k", "Func": "sched_attr_op_type", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42780, "Length": 389}
{"ground_truth": ["<s>", "static", "int", "sched_get_attr_size_int", "(", "rtx_insn", "*", "insn", ")", "{", "int", "size", ";", "switch", "(", "get_attr_type", "(", "insn", ")", ")", "{", "case", "TYPE_IGNORE", ":", "gcc_unreachable", "(", ")", ";", "return", "0", ";", "case", "TYPE_MUL_L", ":", "size", "=", "2", ";", "break", ";", "default", ":", "size", "=", "1", ";", "break", ";", "}", "switch", "(", "get_attr_opx_type", "(", "insn", ")", ")", "{", "case", "OPX_TYPE_NONE", ":", "case", "OPX_TYPE_RN", ":", "case", "OPX_TYPE_FPN", ":", "case", "OPX_TYPE_MEM1", ":", "case", "OPX_TYPE_MEM234", ":", "case", "OPY_TYPE_IMM_Q", ":", "break", ";", "case", "OPX_TYPE_MEM5", ":", "case", "OPX_TYPE_MEM6", ":", "case", "OPX_TYPE_MEM7", ":", "case", "OPY_TYPE_IMM_W", ":", "++", "size", ";", "break", ";", "case", "OPY_TYPE_IMM_L", ":", "size", "+=", "2", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "get_attr_opy_type", "(", "insn", ")", ")", "{", "case", "OPY_TYPE_NONE", ":", "case", "OPY_TYPE_RN", ":", "case", "OPY_TYPE_FPN", ":", "case", "OPY_TYPE_MEM1", ":", "case", "OPY_TYPE_MEM234", ":", "case", "OPY_TYPE_IMM_Q", ":", "break", ";", "case", "OPY_TYPE_MEM5", ":", "case", "OPY_TYPE_MEM6", ":", "case", "OPY_TYPE_MEM7", ":", "case", "OPY_TYPE_IMM_W", ":", "++", "size", ";", "break", ";", "case", "OPY_TYPE_IMM_L", ":", "size", "+=", "2", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "size", ">", "3", ")", "{", "gcc_assert", "(", "!", "reload_completed", ")", ";", "size", "=", "3", ";", "}", "return", "size", ";", "}", "</s>"], "natrual_language": ["Return", "size", "of", "INSN", "as", "int", "."], "TS_V_token": ["m68k", "0", "2", "1", "2", "2", "3", "3"], "File": "m68k", "Func": "sched_get_attr_size_int", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42781, "Length": 192}
{"ground_truth": ["<s>", "static", "int", "sched_get_indexed_address_scale", "(", "rtx_insn", "*", "pro", ",", "rtx_insn", "*", "con", ")", "{", "rtx", "reg", ";", "rtx", "mem", ";", "struct", "m68k_address", "address", ";", "reg", "=", "sched_get_reg_operand", "(", "pro", ",", "true", ")", ";", "if", "(", "reg", "==", "NULL", ")", "return", "0", ";", "mem", "=", "sched_get_mem_operand", "(", "con", ",", "true", ",", "false", ")", ";", "gcc_assert", "(", "mem", "!=", "NULL", "&&", "MEM_P", "(", "mem", ")", ")", ";", "if", "(", "!", "m68k_decompose_address", "(", "GET_MODE", "(", "mem", ")", ",", "XEXP", "(", "mem", ",", "0", ")", ",", "reload_completed", ",", "&", "address", ")", ")", "gcc_unreachable", "(", ")", ";", "if", "(", "REGNO", "(", "reg", ")", "==", "REGNO", "(", "address", ".", "index", ")", ")", "{", "gcc_assert", "(", "address", ".", "scale", "!=", "0", ")", ";", "return", "address", ".", "scale", ";", "}", "return", "0", ";", "}", "</s>"], "natrual_language": ["Helper", "function", "for", "m68k_sched_indexed_address_bypass_p", ".", "if", "PRO", "modifies", "register", "used", "as", "index", "in", "CON", ",", "return", "scale", "of", "indexed", "memory", "access", "in", "CON", ".", "Return", "zero", "overwise", "."], "TS_V_token": ["m68k", "0", "0", "0", "0"], "File": "m68k", "Func": "sched_get_indexed_address_scale", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42782, "Length": 125}
{"ground_truth": ["<s>", "static", "rtx", "sched_get_mem_operand", "(", "rtx_insn", "*", "insn", ",", "bool", "must_read_p", ",", "bool", "must_write_p", ")", "{", "bool", "opx_p", ";", "bool", "opy_p", ";", "opx_p", "=", "false", ";", "opy_p", "=", "false", ";", "if", "(", "must_read_p", ")", "{", "opx_p", "=", "true", ";", "opy_p", "=", "true", ";", "}", "if", "(", "must_write_p", ")", "{", "opx_p", "=", "true", ";", "opy_p", "=", "false", ";", "}", "if", "(", "opy_p", "&&", "sched_mem_operand_p", "(", "insn", ",", "false", ")", ")", "return", "sched_get_operand", "(", "insn", ",", "false", ")", ";", "if", "(", "opx_p", "&&", "sched_mem_operand_p", "(", "insn", ",", "true", ")", ")", "return", "sched_get_operand", "(", "insn", ",", "true", ")", ";", "gcc_unreachable", "(", ")", ";", "return", "NULL", ";", "}", "</s>"], "natrual_language": ["Return", "X", "or", "Y", "(", "depending", "on", "OPX_P", ")", "operand", "of", "INSN", ",", "if", "it", "is", "a", "MEM", ",", "or", "NULL", "overwise", "."], "TS_V_token": ["m68k"], "File": "m68k", "Func": "sched_get_mem_operand", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42783, "Length": 103}
{"ground_truth": ["<s>", "static", "rtx", "sched_get_operand", "(", "rtx_insn", "*", "insn", ",", "bool", "opx_p", ")", "{", "int", "i", ";", "if", "(", "recog_memoized", "(", "insn", ")", "<", "0", ")", "gcc_unreachable", "(", ")", ";", "extract_constrain_insn_cached", "(", "insn", ")", ";", "if", "(", "opx_p", ")", "i", "=", "get_attr_opx", "(", "insn", ")", ";", "else", "i", "=", "get_attr_opy", "(", "insn", ")", ";", "if", "(", "i", ">=", "recog_data", ".", "n_operands", ")", "return", "NULL", ";", "return", "recog_data", ".", "operand", "[", "i", "]", ";", "}", "</s>"], "natrual_language": ["Return", "X", "or", "Y", "(", "depending", "on", "OPX_P", ")", "operand", "of", "INSN", "."], "TS_V_token": ["m68k", "0"], "File": "m68k", "Func": "sched_get_operand", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42784, "Length": 72}
{"ground_truth": ["<s>", "static", "enum", "attr_op_type", "sched_get_opxy_mem_type", "(", "rtx_insn", "*", "insn", ",", "bool", "opx_p", ")", "{", "if", "(", "opx_p", ")", "{", "switch", "(", "get_attr_opx_type", "(", "insn", ")", ")", "{", "case", "OPX_TYPE_NONE", ":", "case", "OPX_TYPE_RN", ":", "case", "OPX_TYPE_FPN", ":", "case", "OPX_TYPE_IMM_Q", ":", "case", "OPX_TYPE_IMM_W", ":", "case", "OPX_TYPE_IMM_L", ":", "return", "OP_TYPE_RN", ";", "case", "OPX_TYPE_MEM1", ":", "case", "OPX_TYPE_MEM234", ":", "case", "OPX_TYPE_MEM5", ":", "case", "OPX_TYPE_MEM7", ":", "return", "OP_TYPE_MEM1", ";", "case", "OPX_TYPE_MEM6", ":", "return", "OP_TYPE_MEM6", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "{", "switch", "(", "get_attr_opy_type", "(", "insn", ")", ")", "{", "case", "OPY_TYPE_NONE", ":", "case", "OPY_TYPE_RN", ":", "case", "OPY_TYPE_FPN", ":", "case", "OPY_TYPE_IMM_Q", ":", "case", "OPY_TYPE_IMM_W", ":", "case", "OPY_TYPE_IMM_L", ":", "return", "OP_TYPE_RN", ";", "case", "OPY_TYPE_MEM1", ":", "case", "OPY_TYPE_MEM234", ":", "case", "OPY_TYPE_MEM5", ":", "case", "OPY_TYPE_MEM7", ":", "return", "OP_TYPE_MEM1", ";", "case", "OPY_TYPE_MEM6", ":", "return", "OP_TYPE_MEM6", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "}", "</s>"], "natrual_language": ["Return", "operand", "X", "or", "Y", "(", "depending", "on", "OPX_P", ")", "of", "INSN", ",", "if", "it", "is", "a", "MEM", ",", "or", "NULL", "overwise", "."], "TS_V_token": ["m68k"], "File": "m68k", "Func": "sched_get_opxy_mem_type", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42785, "Length": 137}
{"ground_truth": ["<s>", "static", "rtx", "sched_get_reg_operand", "(", "rtx_insn", "*", "insn", ",", "bool", "opx_p", ")", "{", "rtx", "op", "=", "NULL", ";", "if", "(", "opx_p", ")", "{", "if", "(", "get_attr_opx_type", "(", "insn", ")", "==", "OPX_TYPE_RN", ")", "{", "op", "=", "sched_get_operand", "(", "insn", ",", "true", ")", ";", "gcc_assert", "(", "op", "!=", "NULL", ")", ";", "if", "(", "!", "reload_completed", "&&", "!", "REG_P", "(", "op", ")", ")", "return", "NULL", ";", "}", "}", "else", "{", "if", "(", "get_attr_opy_type", "(", "insn", ")", "==", "OPY_TYPE_RN", ")", "{", "op", "=", "sched_get_operand", "(", "insn", ",", "false", ")", ";", "gcc_assert", "(", "op", "!=", "NULL", ")", ";", "if", "(", "!", "reload_completed", "&&", "!", "REG_P", "(", "op", ")", ")", "return", "NULL", ";", "}", "}", "return", "op", ";", "}", "</s>"], "natrual_language": ["Return", "X", "or", "Y", "(", "depending", "on", "OPX_P", ")", "operand", "of", "INSN", ",", "if", "it", "is", "an", "integer", "register", ",", "or", "NULL", "overwise", "."], "TS_V_token": ["m68k"], "File": "m68k", "Func": "sched_get_reg_operand", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42786, "Length": 112}
{"ground_truth": ["<s>", "static", "bool", "sched_mem_operand_p", "(", "rtx_insn", "*", "insn", ",", "bool", "opx_p", ")", "{", "switch", "(", "sched_get_opxy_mem_type", "(", "insn", ",", "opx_p", ")", ")", "{", "case", "OP_TYPE_MEM1", ":", "case", "OP_TYPE_MEM6", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>"], "natrual_language": ["Return", "true", ",", "if", "X", "or", "Y", "(", "depending", "on", "OPX_P", ")", "operand", "of", "INSN", "is", "a", "MEM", "."], "TS_V_token": ["m68k"], "File": "m68k", "Func": "sched_mem_operand_p", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42787, "Length": 38}
{"ground_truth": ["<s>", "static", "const", "char", "*", "singlemove_string", "(", "rtx", "*", "operands", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "CONST_INT", ")", "return", "output_move_simode_const", "(", "operands", ")", ";", "return", "\"move%.l %1,%0\"", ";", "}", "</s>"], "natrual_language": ["Return", "the", "best", "assembler", "insn", "template", "for", "moving", "operands", "[", "1", "]", "into", "operands", "[", "0", "]", "as", "a", "fullword", "."], "TS_V_token": ["m68k", "1", "\"move%.l %1,%0\""], "File": "m68k", "Func": "singlemove_string", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42788, "Length": 33}
{"ground_truth": ["<s>", "void", "split_di", "(", "rtx", "operands", "[", "]", ",", "int", "num", ",", "rtx", "lo_half", "[", "]", ",", "rtx", "hi_half", "[", "]", ")", "{", "while", "(", "num", "--", ")", "{", "rtx", "op", "=", "operands", "[", "num", "]", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "MEM", ")", "{", "lo_half", "[", "num", "]", "=", "adjust_address", "(", "op", ",", "SImode", ",", "4", ")", ";", "hi_half", "[", "num", "]", "=", "adjust_address", "(", "op", ",", "SImode", ",", "0", ")", ";", "}", "else", "{", "lo_half", "[", "num", "]", "=", "simplify_gen_subreg", "(", "SImode", ",", "op", ",", "GET_MODE", "(", "op", ")", "==", "VOIDmode", "?", "DImode", ":", "GET_MODE", "(", "op", ")", ",", "4", ")", ";", "hi_half", "[", "num", "]", "=", "simplify_gen_subreg", "(", "SImode", ",", "op", ",", "GET_MODE", "(", "op", ")", "==", "VOIDmode", "?", "DImode", ":", "GET_MODE", "(", "op", ")", ",", "0", ")", ";", "}", "}", "}", "</s>"], "natrual_language": ["Split", "one", "or", "more", "DImode", "RTL", "references", "into", "pairs", "of", "SImode", "references", ".", "The", "RTL", "can", "be", "REG", ",", "offsettable", "MEM", ",", "integer", "constant", ",", "or", "CONST_DOUBLE", ".", "``", "operands", "''", "is", "a", "pointer", "to", "an", "array", "of", "DImode", "RTL", "to", "split", "and", "``", "num", "''", "is", "its", "length", ".", "lo_half", "and", "hi_half", "are", "output", "arrays", "that", "parallel", "``", "operands", "''", "."], "TS_V_token": ["m68k", "4", "0", "4", "0"], "File": "m68k", "Func": "split_di", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42789, "Length": 136}
{"ground_truth": ["<s>", "bool", "strict_low_part_peephole_ok", "(", "machine_mode", "mode", ",", "rtx_insn", "*", "first_insn", ",", "rtx", "target", ")", "{", "rtx_insn", "*", "p", "=", "first_insn", ";", "while", "(", "(", "p", "=", "PREV_INSN", "(", "p", ")", ")", ")", "{", "if", "(", "NOTE_INSN_BASIC_BLOCK_P", "(", "p", ")", ")", "return", "false", ";", "if", "(", "NOTE_P", "(", "p", ")", ")", "continue", ";", "if", "(", "!", "INSN_P", "(", "p", ")", ")", "return", "false", ";", "if", "(", "reg_set_p", "(", "target", ",", "p", ")", ")", "{", "rtx", "set", "=", "single_set", "(", "p", ")", ";", "rtx", "dest", ";", "if", "(", "!", "set", ")", "return", "false", ";", "dest", "=", "SET_DEST", "(", "set", ")", ";", "if", "(", "rtx_equal_p", "(", "dest", ",", "target", ")", "&&", "SET_SRC", "(", "set", ")", "==", "const0_rtx", ")", "return", "true", ";", "else", "if", "(", "GET_CODE", "(", "dest", ")", "==", "STRICT_LOW_PART", "&&", "GET_CODE", "(", "XEXP", "(", "dest", ",", "0", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "dest", ",", "0", ")", ")", "==", "REGNO", "(", "target", ")", "&&", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "XEXP", "(", "dest", ",", "0", ")", ")", ")", "<=", "GET_MODE_SIZE", "(", "mode", ")", ")", ")", ";", "else", "return", "false", ";", "}", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Check", "for", "cases", "where", "a", "clr", "insns", "can", "be", "omitted", "from", "code", "using", "strict_low_part", "sets", ".", "For", "example", ",", "the", "second", "clrl", "here", "is", "not", "needed", ":", "clrl", "d0", ";", "movw", "a0", "@", "+", ",", "d0", ";", "use", "d0", ";", "clrl", "d0", ";", "movw", "a0", "@", "+", ";", "use", "d0", ";", "...", "MODE", "is", "the", "mode", "of", "this", "STRICT_LOW_PART", "set", ".", "FIRST_INSN", "is", "the", "clear", "insn", "we", "are", "checking", "for", "redundancy", ".", "TARGET", "is", "the", "register", "set", "by", "the", "clear", "insn", "."], "TS_V_token": ["m68k", "0", "0", "0"], "File": "m68k", "Func": "strict_low_part_peephole_ok", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42790, "Length": 185}
{"ground_truth": ["<s>", "bool", "valid_mov3q_const", "(", "HOST_WIDE_INT", "i", ")", "{", "return", "TARGET_ISAB", "&&", "(", "i", "==", "-", "1", "||", "IN_RANGE", "(", "i", ",", "1", ",", "7", ")", ")", ";", "}", "</s>"], "natrual_language": ["Return", "1", "if", "'constant", "'", "can", "be", "represented", "by", "mov3q", "on", "a", "ColdFire", "V4", "core", "."], "TS_V_token": ["m68k", "1", "1", "7"], "File": "m68k", "Func": "valid_mov3q_const", "Target": "m68k", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 42791, "Length": 27}