{"ground_truth": ["<s>", "void", "arc_cpu_cpp_builtins", "(", "cpp_reader", "*", "pfile", ")", "{", "builtin_assert", "(", "\"cpu=arc\"", ")", ";", "builtin_assert", "(", "\"machine=arc\"", ")", ";", "builtin_define", "(", "\"__arc__\"", ")", ";", "def_or_undef_macro", "(", "pfile", ",", "NAME", ",", "CONDITION", ")", ";", "builtin_define_with_int_value", "(", "\"__ARC_TLS_REGNO__\"", ",", "arc_tp_regno", ")", ";", "builtin_define", "(", "TARGET_BIG_ENDIAN", "?", "\"__BIG_ENDIAN__\"", ":", "\"__LITTLE_ENDIAN__\"", ")", ";", "if", "(", "TARGET_BIG_ENDIAN", ")", "builtin_define", "(", "\"__big_endian__\"", ")", ";", "}", "</s>"], "natrual_language": ["Helper", "for", "TARGET_CPU_CPP_BUILTINS", "hook", "."], "TS_V_token": ["arc", "\"cpu=arc\"", "\"machine=arc\"", "\"__arc__\"", "\"__ARC_TLS_REGNO__\"", "\"__BIG_ENDIAN__\"", "\"__LITTLE_ENDIAN__\"", "\"__big_endian__\""], "File": "arc-c2", "Func": "arc_cpu_cpp_builtins", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33392, "Length": 58}
{"ground_truth": ["<s>", "void", "arc_cpu_cpp_builtins", "(", "cpp_reader", "*", "pfile", ")", "{", "builtin_assert", "(", "\"cpu=arc\"", ")", ";", "builtin_assert", "(", "\"machine=arc\"", ")", ";", "builtin_define", "(", "\"__arc__\"", ")", ";", "def_or_undef_macro", "(", "pfile", ",", "NAME", ",", "CONDITION", ")", ";", "builtin_define_with_int_value", "(", "\"__ARC_TLS_REGNO__\"", ",", "arc_tp_regno", ")", ";", "builtin_define_with_int_value", "(", "\"__ARC_LPC_WIDTH__\"", ",", "arc_lpcwidth", ")", ";", "builtin_define", "(", "TARGET_BIG_ENDIAN", "?", "\"__BIG_ENDIAN__\"", ":", "\"__LITTLE_ENDIAN__\"", ")", ";", "if", "(", "TARGET_BIG_ENDIAN", ")", "builtin_define", "(", "\"__big_endian__\"", ")", ";", "}", "</s>"], "natrual_language": ["Helper", "for", "TARGET_CPU_CPP_BUILTINS", "hook", "."], "TS_V_token": ["arc", "\"cpu=arc\"", "\"machine=arc\"", "\"__arc__\"", "\"__ARC_TLS_REGNO__\"", "\"__ARC_LPC_WIDTH__\"", "\"__BIG_ENDIAN__\"", "\"__LITTLE_ENDIAN__\"", "\"__big_endian__\""], "File": "arc-c3", "Func": "arc_cpu_cpp_builtins", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33393, "Length": 65}
{"ground_truth": ["<s>", "void", "arc_cpu_cpp_builtins", "(", "cpp_reader", "*", "pfile", ")", "{", "builtin_assert", "(", "\"cpu=arc\"", ")", ";", "builtin_assert", "(", "\"machine=arc\"", ")", ";", "builtin_define", "(", "\"__arc__\"", ")", ";", "def_or_undef_macro", "(", "pfile", ",", "NAME", ",", "CONDITION", ")", ";", "builtin_define_with_int_value", "(", "\"__ARC_TLS_REGNO__\"", ",", "arc_tp_regno", ")", ";", "builtin_define_with_int_value", "(", "\"__ARC_LPC_WIDTH__\"", ",", "arc_lpcwidth", ")", ";", "builtin_define", "(", "TARGET_BIG_ENDIAN", "?", "\"__BIG_ENDIAN__\"", ":", "\"__LITTLE_ENDIAN__\"", ")", ";", "if", "(", "TARGET_BIG_ENDIAN", ")", "builtin_define", "(", "\"__big_endian__\"", ")", ";", "if", "(", "TARGET_HARD_FLOAT", ")", "{", "builtin_define", "(", "\"__arc_hard_float__\"", ")", ";", "builtin_define", "(", "\"__ARC_HARD_FLOAT__\"", ")", ";", "}", "else", "{", "builtin_define", "(", "\"__arc_soft_float__\"", ")", ";", "builtin_define", "(", "\"__ARC_SOFT_FLOAT__\"", ")", ";", "}", "}", "</s>"], "natrual_language": ["Helper", "for", "TARGET_CPU_CPP_BUILTINS", "hook", "."], "TS_V_token": ["arc", "\"cpu=arc\"", "\"machine=arc\"", "\"__arc__\"", "\"__ARC_TLS_REGNO__\"", "\"__ARC_LPC_WIDTH__\"", "\"__BIG_ENDIAN__\"", "\"__LITTLE_ENDIAN__\"", "\"__big_endian__\"", "\"__arc_hard_float__\"", "\"__ARC_HARD_FLOAT__\"", "\"__arc_soft_float__\"", "\"__ARC_SOFT_FLOAT__\""], "File": "arc-c", "Func": "arc_cpu_cpp_builtins", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33394, "Length": 94}
{"ground_truth": ["<s>", "static", "void", "def_or_undef_macro", "(", "cpp_reader", "*", "pfile", ",", "const", "char", "*", "name", ",", "bool", "def_p", ")", "{", "if", "(", "def_p", ")", "cpp_define", "(", "pfile", ",", "name", ")", ";", "else", "cpp_undef", "(", "pfile", ",", "name", ")", ";", "}", "</s>"], "natrual_language": ["Define", "or", "undefine", "macros", "based", "on", "the", "current", "target", ".", "If", "the", "user", "does", "#", "pragma", "GCC", "target", ",", "we", "need", "to", "adjust", "the", "macros", "dynamically", "."], "TS_V_token": ["arc"], "File": "arc-c", "Func": "def_or_undef_macro", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33395, "Length": 37}
{"ground_truth": ["<s>", "static", "int", "arc_address_cost", "(", "rtx", "addr", ",", "machine_mode", ",", "addr_space_t", ",", "bool", "speed", ")", "{", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "return", "speed", "||", "arc_check_short_reg_p", "(", "addr", ")", "?", "0", ":", "1", ";", "case", "PRE_INC", ":", "case", "PRE_DEC", ":", "case", "POST_INC", ":", "case", "POST_DEC", ":", "case", "PRE_MODIFY", ":", "case", "POST_MODIFY", ":", "return", "!", "speed", ";", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "case", "CONST", ":", "if", "(", "TARGET_NPS_CMEM", "&&", "cmem_address", "(", "addr", ",", "SImode", ")", ")", "return", "0", ";", "return", "COSTS_N_INSNS", "(", "1", ")", ";", "case", "PLUS", ":", "{", "rtx", "plus0", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "rtx", "plus1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "plus0", ")", "!=", "REG", "&&", "(", "GET_CODE", "(", "plus0", ")", "!=", "MULT", "||", "!", "CONST_INT_P", "(", "XEXP", "(", "plus0", ",", "1", ")", ")", "||", "(", "INTVAL", "(", "XEXP", "(", "plus0", ",", "1", ")", ")", "!=", "2", "&&", "INTVAL", "(", "XEXP", "(", "plus0", ",", "1", ")", ")", "!=", "4", ")", ")", ")", "break", ";", "switch", "(", "GET_CODE", "(", "plus1", ")", ")", "{", "case", "CONST_INT", ":", "return", "(", "!", "RTX_OK_FOR_OFFSET_P", "(", "SImode", ",", "plus1", ")", "?", "COSTS_N_INSNS", "(", "1", ")", ":", "speed", "?", "0", ":", "(", "arc_check_short_reg_p", "(", "plus0", ")", "&&", "satisfies_constraint_O", "(", "plus1", ")", ")", "?", "0", ":", "1", ")", ";", "case", "REG", ":", "return", "(", "speed", "<", "1", "?", "0", ":", "(", "arc_check_short_reg_p", "(", "plus0", ")", "&&", "arc_check_short_reg_p", "(", "plus1", ")", ")", "?", "0", ":", "1", ")", ";", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "return", "COSTS_N_INSNS", "(", "1", ")", ";", "default", ":", "break", ";", "}", "break", ";", "}", "default", ":", "break", ";", "}", "return", "4", ";", "}", "</s>"], "natrual_language": ["Provide", "the", "costs", "of", "an", "addressing", "mode", "that", "contains", "ADDR", ".", "If", "ADDR", "is", "not", "a", "valid", "address", ",", "its", "cost", "is", "irrelevant", "."], "TS_V_token": ["arc", "0", "1", "0", "1", "0", "1", "1", "1", "2", "1", "4", "1", "0", "0", "1", "1", "0", "0", "1", "1", "4"], "File": "arc1", "Func": "arc_address_cost", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33396, "Length": 277}
{"ground_truth": ["<s>", "static", "int", "arc_check_release31a", "(", "rtx_insn", "*", "pred", ",", "rtx_insn", "*", "succ", ")", "{", "if", "(", "!", "pred", "||", "!", "INSN_P", "(", "pred", ")", "||", "!", "succ", "||", "!", "INSN_P", "(", "succ", ")", ")", "return", "0", ";", "if", "(", "!", "JUMP_P", "(", "pred", ")", "&&", "!", "single_set", "(", "pred", ")", ")", "return", "0", ";", "if", "(", "!", "JUMP_P", "(", "succ", ")", "&&", "!", "single_set", "(", "succ", ")", ")", "return", "0", ";", "if", "(", "TARGET_HS", "&&", "(", "arc_tune", "==", "ARC_TUNE_ARCHS4X_REL31A", ")", ")", "switch", "(", "get_attr_type", "(", "pred", ")", ")", "{", "case", "TYPE_STORE", ":", "switch", "(", "get_attr_type", "(", "succ", ")", ")", "{", "case", "TYPE_BRCC", ":", "case", "TYPE_BRCC_NO_DELAY_SLOT", ":", "case", "TYPE_LOOP_END", ":", "return", "1", ";", "default", ":", "break", ";", "}", "break", ";", "case", "TYPE_BRCC", ":", "case", "TYPE_BRCC_NO_DELAY_SLOT", ":", "case", "TYPE_LOOP_END", ":", "if", "(", "get_attr_type", "(", "succ", ")", "==", "TYPE_STORE", ")", "return", "1", ";", "break", ";", "default", ":", "break", ";", "}", "return", "0", ";", "}", "</s>"], "natrual_language": ["When", "compiling", "for", "release", "310a", ",", "insert", "a", "nop", "before", "any", "conditional", "jump", "."], "TS_V_token": ["arc", "0", "0", "0", "1", "1", "0"], "File": "arc1", "Func": "arc_check_release31a", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33397, "Length": 150}
{"ground_truth": ["<s>", "static", "bool", "arc_check_short_reg_p", "(", "rtx", "op", ")", "{", "if", "(", "!", "REG_P", "(", "op", ")", ")", "return", "false", ";", "if", "(", "IN_RANGE", "(", "REGNO", "(", "op", ")", "^", "4", ",", "4", ",", "11", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Return", "TRUE", "if", "reg", "is", "ok", "for", "short", "instrcutions", "."], "TS_V_token": ["arc", "4", "4", "11"], "File": "arc1", "Func": "arc_check_short_reg_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33398, "Length": 42}
{"ground_truth": ["<s>", "int", "arc_output_addsi", "(", "rtx", "*", "operands", ",", "bool", "cond_p", ",", "bool", "output_p", ")", "{", "char", "format", "[", "35", "]", ";", "int", "match", "=", "operands_match_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "int", "match2", "=", "operands_match_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ")", ";", "int", "intval", "=", "(", "REG_P", "(", "operands", "[", "2", "]", ")", "?", "1", ":", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", "?", "INTVAL", "(", "operands", "[", "2", "]", ")", ":", "0xbadc057", ")", ";", "int", "neg_intval", "=", "-", "intval", ";", "int", "short_0", "=", "arc_check_short_reg_p", "(", "operands", "[", "0", "]", ")", ";", "int", "short_p", "=", "(", "!", "cond_p", "&&", "short_0", "&&", "arc_check_short_reg_p", "(", "operands", "[", "1", "]", ")", ")", ";", "int", "ret", "=", "0", ";", "&&", "REGNO", "(", "OP", ")", "!=", "30", ")", "\\", "||", "!", "TARGET_V2", ")", ")", "if", "(", "output_p", ")", "\\", "output_asm_insn", "(", "FORMAT", ",", "operands", ")", ";", "\\", "return", "ret", ";", "\\", "}", "</s>"], "natrual_language": ["Emit", "code", "for", "an", "addsi3", "instruction", "with", "OPERANDS", ".", "COND_P", "indicates", "if", "this", "will", "use", "conditional", "execution", ".", "Return", "the", "length", "of", "the", "instruction", ".", "If", "OUTPUT_P", "is", "false", ",", "do", "n't", "actually", "output", "the", "instruction", ",", "just", "return", "its", "length", "."], "TS_V_token": ["arc", "35", "0", "1", "0", "2", "2", "1", "2", "2", "0xbadc057", "0", "1", "0", "30"], "File": "arc1", "Func": "arc_output_addsi", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33399, "Length": 157}
{"ground_truth": ["<s>", "static", "int", "arc_save_callee_enter", "(", "uint64_t", "gmask", ",", "bool", "save_blink", ",", "bool", "save_fp", ",", "HOST_WIDE_INT", "offset", ")", "{", "int", "start_reg", "=", "ENTER_LEAVE_START_REG", ";", "int", "end_reg", "=", "ENTER_LEAVE_END_REG", ";", "int", "regno", ",", "indx", ",", "off", ",", "nregs", ";", "rtx", "insn", ",", "reg", ",", "mem", ";", "int", "frame_allocated", "=", "0", ";", "for", "(", "regno", "=", "start_reg", ";", "regno", "<=", "end_reg", "&&", "(", "gmask", "&", "(", "1ULL", "<<", "regno", ")", ")", ";", ")", "regno", "++", ";", "end_reg", "=", "regno", "-", "1", ";", "nregs", "=", "end_reg", "-", "start_reg", "+", "1", ";", "nregs", "+=", "save_blink", "?", "1", ":", "0", ";", "nregs", "+=", "save_fp", "?", "1", ":", "0", ";", "if", "(", "offset", ")", "frame_stack_add", "(", "offset", ")", ";", "insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "nregs", "+", "(", "save_fp", "?", "1", ":", "0", ")", "+", "1", ")", ")", ";", "indx", "=", "0", ";", "reg", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "nregs", "*", "UNITS_PER_WORD", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "reg", ")", "=", "1", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", "++", ")", "=", "reg", ";", "off", "=", "nregs", "*", "UNITS_PER_WORD", ";", "if", "(", "save_blink", ")", "{", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ";", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "off", ")", ")", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "insn", ",", "0", ",", "indx", "++", ")", ")", "=", "1", ";", "off", "-=", "UNITS_PER_WORD", ";", "save_blink", "=", "false", ";", "}", "for", "(", "regno", "=", "start_reg", ";", "regno", "<=", "end_reg", ";", "regno", "++", ",", "indx", "++", ",", "off", "-=", "UNITS_PER_WORD", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "off", ")", ")", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", ")", "=", "1", ";", "gmask", "=", "gmask", "&", "~", "(", "1ULL", "<<", "regno", ")", ";", "}", "if", "(", "save_fp", ")", "{", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "off", ")", ")", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", "=", "gen_rtx_SET", "(", "mem", ",", "hard_frame_pointer_rtx", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "insn", ",", "0", ",", "indx", "++", ")", ")", "=", "1", ";", "off", "-=", "UNITS_PER_WORD", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", "=", "gen_rtx_SET", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "insn", ",", "0", ",", "indx", "++", ")", ")", "=", "1", ";", "save_fp", "=", "false", ";", "}", "gcc_assert", "(", "off", "==", "0", ")", ";", "insn", "=", "frame_insn", "(", "insn", ")", ";", "add_reg_note", "(", "insn", ",", "REG_INC", ",", "stack_pointer_rtx", ")", ";", "frame_allocated", "=", "nregs", "*", "UNITS_PER_WORD", ";", "return", "frame_allocated", "-", "offset", ";", "}", "</s>"], "natrual_language": ["ARC", "prologue", ",", "save", "the", "registers", "using", "enter", "instruction", ".", "Leave", "instruction", "can", "also", "save", "$", "blink", "(", "SAVE_BLINK", ")", "and", "$", "fp", "(", "SAVE_FP", ")", "register", "."], "TS_V_token": ["arc", "0", "1ULL", "1", "1", "1", "0", "1", "0", "1", "0", "1", "0", "1", "0", "0", "0", "1", "0", "0", "1", "1ULL", "0", "0", "1", "0", "0", "1", "0"], "File": "arc1", "Func": "arc_save_callee_enter", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33400, "Length": 469}
{"ground_truth": ["<s>", "static", "int", "arc_sched_issue_rate", "(", "void", ")", "{", "switch", "(", "arc_tune", ")", "{", "case", "ARC_TUNE_ARCHS4X", ":", "case", "ARC_TUNE_ARCHS4XD", ":", "return", "3", ";", "default", ":", "break", ";", "}", "return", "1", ";", "}", "</s>"], "natrual_language": ["Implements", "target", "hook", "TARGET_SCHED_ISSUE_RATE", "."], "TS_V_token": ["arc", "3", "1"], "File": "arc1", "Func": "arc_sched_issue_rate", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33401, "Length": 30}
{"ground_truth": ["<s>", "static", "void", "arc_setup_incoming_varargs", "(", "cumulative_args_t", "args_so_far", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_size", ",", "int", "no_rtl", ")", "{", "int", "first_anon_arg", ";", "CUMULATIVE_ARGS", "next_cum", ";", "next_cum", "=", "*", "get_cumulative_args", "(", "args_so_far", ")", ";", "if", "(", "!", "TYPE_NO_NAMED_ARGS_STDARG_P", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ")", "arc_function_arg_advance", "(", "pack_cumulative_args", "(", "&", "next_cum", ")", ",", "arg", ")", ";", "first_anon_arg", "=", "next_cum", ";", "if", "(", "FUNCTION_ARG_REGNO_P", "(", "first_anon_arg", ")", ")", "{", "int", "first_reg_offset", "=", "first_anon_arg", ";", "if", "(", "!", "no_rtl", ")", "{", "rtx", "regblock", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "plus_constant", "(", "Pmode", ",", "arg_pointer_rtx", ",", "FIRST_PARM_OFFSET", "(", "0", ")", ")", ")", ";", "move_block_from_reg", "(", "first_reg_offset", ",", "regblock", ",", "MAX_ARC_PARM_REGS", "-", "first_reg_offset", ")", ";", "}", "*", "pretend_size", "=", "(", "(", "MAX_ARC_PARM_REGS", "-", "first_reg_offset", ")", "*", "UNITS_PER_WORD", ")", ";", "}", "}", "</s>"], "natrual_language": ["Do", "any", "needed", "setup", "for", "a", "variadic", "function", ".", "For", "the", "ARC", ",", "we", "must", "create", "a", "register", "parameter", "block", ",", "and", "then", "copy", "any", "anonymous", "arguments", "in", "registers", "to", "memory", ".", "CUM", "has", "not", "been", "updated", "for", "the", "last", "named", "argument", "which", "has", "type", "TYPE", "and", "mode", "MODE", ",", "and", "we", "rely", "on", "this", "fact", "."], "TS_V_token": ["arc", "0"], "File": "arc1", "Func": "arc_setup_incoming_varargs", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33402, "Length": 126}
{"ground_truth": ["<s>", "void", "split_addsi", "(", "rtx", "*", "operands", ")", "{", "int", "val", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "val", ">", "127", "&&", "val", "<=", "255", "&&", "arc_check_short_reg_p", "(", "operands", "[", "0", "]", ")", ")", "{", "operands", "[", "3", "]", "=", "operands", "[", "2", "]", ";", "operands", "[", "4", "]", "=", "gen_rtx_PLUS", "(", "SImode", ",", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "}", "else", "{", "operands", "[", "3", "]", "=", "operands", "[", "1", "]", ";", "operands", "[", "4", "]", "=", "gen_rtx_PLUS", "(", "SImode", ",", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ")", ";", "}", "}", "</s>"], "natrual_language": ["Operands", "0", "..", "2", "are", "the", "operands", "of", "a", "addsi", "which", "uses", "a", "12", "bit", "constant", "in", "operand", "2", ",", "but", "which", "would", "require", "a", "LIMM", "because", "of", "operand", "mismatch", ".", "operands", "3", "and", "4", "are", "new", "SET_SRCs", "for", "operands", "0", "."], "TS_V_token": ["arc", "2", "127", "255", "0", "3", "2", "4", "0", "1", "3", "1", "4", "0", "2"], "File": "arc1", "Func": "split_addsi", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33403, "Length": 103}
{"ground_truth": ["<s>", "void", "split_subsi", "(", "rtx", "*", "operands", ")", "{", "int", "val", "=", "INTVAL", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "arc_check_short_reg_p", "(", "operands", "[", "0", "]", ")", "&&", "arc_check_short_reg_p", "(", "operands", "[", "2", "]", ")", ")", "{", "if", "(", "val", ">=", "-", "31", "&&", "val", "<=", "127", ")", "{", "operands", "[", "3", "]", "=", "gen_rtx_NEG", "(", "SImode", ",", "operands", "[", "2", "]", ")", ";", "operands", "[", "4", "]", "=", "gen_rtx_PLUS", "(", "SImode", ",", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "return", ";", "}", "else", "if", "(", "val", ">=", "0", "&&", "val", "<", "255", ")", "{", "operands", "[", "3", "]", "=", "operands", "[", "1", "]", ";", "operands", "[", "4", "]", "=", "gen_rtx_MINUS", "(", "SImode", ",", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ")", ";", "return", ";", "}", "}", "operands", "[", "3", "]", "=", "operands", "[", "2", "]", ";", "operands", "[", "4", "]", "=", "gen_rtx_MINUS", "(", "SImode", ",", "operands", "[", "1", "]", ",", "operands", "[", "0", "]", ")", ";", "}", "</s>"], "natrual_language": ["Operands", "0", "..", "2", "are", "the", "operands", "of", "a", "subsi", "which", "uses", "a", "12", "bit", "constant", "in", "operand", "1", ",", "but", "which", "would", "require", "a", "LIMM", "because", "of", "operand", "mismatch", ".", "operands", "3", "and", "4", "are", "new", "SET_SRCs", "for", "operands", "0", "."], "TS_V_token": ["arc", "1", "0", "2", "31", "127", "3", "2", "4", "0", "1", "0", "255", "3", "1", "4", "0", "2", "3", "2", "4", "1", "0"], "File": "arc1", "Func": "split_subsi", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33404, "Length": 165}
{"ground_truth": ["<s>", "static", "void", "workaround_arc_anomaly", "(", "void", ")", "{", "rtx_insn", "*", "insn", ",", "*", "succ0", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "succ0", "=", "next_real_insn", "(", "insn", ")", ";", "if", "(", "arc_hazard", "(", "insn", ",", "succ0", ")", "||", "arc_check_release31a", "(", "insn", ",", "succ0", ")", ")", "emit_insn_before", "(", "gen_nopv", "(", ")", ",", "succ0", ")", ";", "}", "if", "(", "!", "TARGET_ARC700", ")", "return", ";", "if", "(", "arc_tune", "!=", "ARC_TUNE_ARC7XX", ")", "check_store_cacheline_hazard", "(", ")", ";", "}", "</s>"], "natrual_language": ["The", "same", "functionality", "as", "arc_hazard", ".", "It", "is", "called", "in", "machine", "reorg", "before", "any", "other", "optimization", ".", "Hence", ",", "the", "NOP", "size", "is", "taken", "into", "account", "when", "doing", "branch", "shortening", "."], "TS_V_token": ["arc"], "File": "arc1", "Func": "workaround_arc_anomaly", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33405, "Length": 83}
{"ground_truth": ["<s>", "int", "arc_ccfsm_branch_deleted_p", "(", ")", "{", "if", "(", "arc_ccfsm_state", "==", "1", "||", "arc_ccfsm_state", "==", "2", ")", "return", "1", ";", "return", "0", ";", "}", "</s>"], "natrual_language": ["See", "if", "the", "current", "insn", ",", "which", "is", "a", "conditional", "branch", ",", "is", "to", "be", "deleted", "."], "TS_V_token": ["arc", "1", "2", "1", "0"], "File": "arc2", "Func": "arc_ccfsm_branch_deleted_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33406, "Length": 22}
{"ground_truth": ["<s>", "void", "arc_ccfsm_record_branch_deleted", "(", ")", "{", "arc_ccfsm_state", "+=", "2", ";", "current_insn_set_cc_p", "=", "last_insn_set_cc_p", ";", "}", "</s>"], "natrual_language": ["Record", "a", "branch", "is", "n't", "output", "because", "subsequent", "insns", "can", "be", "conditionalized", "."], "TS_V_token": ["arc", "2"], "File": "arc2", "Func": "arc_ccfsm_record_branch_deleted", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33407, "Length": 14}
{"ground_truth": ["<s>", "int", "arc_delay_slots_for_epilogue", "(", ")", "{", "if", "(", "arc_compute_function_type", "(", "current_function_decl", ")", "!=", "ARC_FUNCTION_NORMAL", ")", "return", "0", ";", "if", "(", "!", "current_frame_info", ".", "initialized", ")", "(", "void", ")", "arc_compute_frame_size", "(", "get_frame_size", "(", ")", ")", ";", "if", "(", "current_frame_info", ".", "total_size", "==", "0", ")", "return", "1", ";", "return", "0", ";", "}", "</s>"], "natrual_language": ["Define", "the", "number", "of", "delay", "slots", "needed", "for", "the", "function", "epilogue", ".", "Interrupt", "handlers", "ca", "n't", "have", "any", "epilogue", "delay", "slots", "(", "it", "'s", "always", "needed", "for", "something", "else", ",", "I", "think", ")", ".", "For", "normal", "functions", ",", "we", "have", "to", "worry", "about", "using", "call-saved", "regs", "as", "they", "'ll", "be", "restored", "before", "the", "delay", "slot", "insn", ".", "Functions", "with", "non-empty", "frames", "already", "have", "enough", "choices", "for", "the", "epilogue", "delay", "slot", "so", "for", "now", "we", "only", "consider", "functions", "with", "empty", "frames", "."], "TS_V_token": ["arc", "0", "0", "1", "0"], "File": "arc2", "Func": "arc_delay_slots_for_epilogue", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33408, "Length": 49}
{"ground_truth": ["<s>", "void", "arc_finalize_pic", "(", ")", "{", "}", "</s>"], "natrual_language": ["If", "the", "function", "has", "any", "GOTOFF", "relocations", ",", "then", "the", "GOTBASE", "register", "has", "to", "be", "setup", "in", "the", "prologue", "The", "instruction", "needed", "at", "the", "function", "start", "for", "setting", "up", "the", "GOTBASE", "register", "is", "add", "rdest", ",", "pc", ",", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "The", "rtl", "to", "be", "emitted", "for", "this", "should", "be", ":", "set", "(", "reg", "basereg", ")", "(", "plus", "(", "reg", "pc", ")", "(", "const", "(", "unspec", "(", "symref", "_DYNAMIC", ")", "3", ")", ")", ")", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--"], "TS_V_token": ["arc"], "File": "arc2", "Func": "arc_finalize_pic", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33409, "Length": 6}
{"ground_truth": ["<s>", "void", "arc_init", "(", "void", ")", "{", "char", "*", "tmp", ";", "if", "(", "arc_cpu_string", "==", "0", "||", "!", "strcmp", "(", "arc_cpu_string", ",", "\"base\"", ")", ")", "{", "arc_cpu_string", "=", "\"base\"", ";", "arc_cpu_type", "=", "0", ";", "arc_mangle_cpu", "=", "NULL", ";", "}", "else", "if", "(", "ARC_EXTENSION_CPU", "(", "arc_cpu_string", ")", ")", ";", "else", "{", "error", "(", "\"bad value (%s) for -mcpu switch\"", ",", "arc_cpu_string", ")", ";", "arc_cpu_string", "=", "\"base\"", ";", "arc_cpu_type", "=", "0", ";", "arc_mangle_cpu", "=", "NULL", ";", "}", "arc_text_section", "=", "tmp", "=", "xmalloc", "(", "strlen", "(", "arc_text_string", ")", "+", "sizeof", "(", "ARC_SECTION_FORMAT", ")", "+", "1", ")", ";", "sprintf", "(", "tmp", ",", "ARC_SECTION_FORMAT", ",", "arc_text_string", ")", ";", "arc_data_section", "=", "tmp", "=", "xmalloc", "(", "strlen", "(", "arc_data_string", ")", "+", "sizeof", "(", "ARC_SECTION_FORMAT", ")", "+", "1", ")", ";", "sprintf", "(", "tmp", ",", "ARC_SECTION_FORMAT", ",", "arc_data_string", ")", ";", "arc_rodata_section", "=", "tmp", "=", "xmalloc", "(", "strlen", "(", "arc_rodata_string", ")", "+", "sizeof", "(", "ARC_SECTION_FORMAT", ")", "+", "1", ")", ";", "sprintf", "(", "tmp", ",", "ARC_SECTION_FORMAT", ",", "arc_rodata_string", ")", ";", "arc_init_reg_tables", "(", ")", ";", "memset", "(", "arc_punct_chars", ",", "0", ",", "sizeof", "(", "arc_punct_chars", ")", ")", ";", "arc_punct_chars", "[", "'#'", "]", "=", "1", ";", "arc_punct_chars", "[", "'*'", "]", "=", "1", ";", "arc_punct_chars", "[", "'?'", "]", "=", "1", ";", "arc_punct_chars", "[", "'!'", "]", "=", "1", ";", "arc_punct_chars", "[", "'~'", "]", "=", "1", ";", "}", "</s>"], "natrual_language": ["Called", "by", "OVERRIDE_OPTIONS", "to", "initialize", "various", "things", "."], "TS_V_token": ["arc", "0", "\"base\"", "\"base\"", "0", "\"bad value (%s) for -mcpu switch\"", "\"base\"", "0", "1", "1", "1", "0", "1", "1", "1", "1", "1"], "File": "arc2", "Func": "arc_init", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33410, "Length": 205}
{"ground_truth": ["<s>", "static", "void", "arc_init_reg_tables", "(", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "NUM_MACHINE_MODES", ";", "i", "++", ")", "{", "switch", "(", "GET_MODE_CLASS", "(", "i", ")", ")", "{", "case", "MODE_INT", ":", "case", "MODE_PARTIAL_INT", ":", "case", "MODE_COMPLEX_INT", ":", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "<=", "4", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "S_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "==", "8", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "D_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "==", "16", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "T_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "==", "32", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "O_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "case", "MODE_FLOAT", ":", "case", "MODE_COMPLEX_FLOAT", ":", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "<=", "4", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "SF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "==", "8", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "DF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "==", "16", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "TF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "==", "32", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "OF_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "case", "MODE_CC", ":", "default", ":", "if", "(", "i", "==", "(", "int", ")", "CCmode", "||", "i", "==", "(", "int", ")", "CCZNmode", "||", "i", "==", "(", "int", ")", "CCZNCmode", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "C_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "}", "}", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "{", "if", "(", "i", "<", "60", ")", "arc_regno_reg_class", "[", "i", "]", "=", "GENERAL_REGS", ";", "else", "if", "(", "i", "==", "60", ")", "arc_regno_reg_class", "[", "i", "]", "=", "LPCOUNT_REG", ";", "else", "if", "(", "i", "==", "61", ")", "arc_regno_reg_class", "[", "i", "]", "=", "NO_REGS", ";", "else", "arc_regno_reg_class", "[", "i", "]", "=", "NO_REGS", ";", "}", "}", "</s>"], "natrual_language": ["Initialize", "the", "arc_mode_class", "array", "."], "TS_V_token": ["arc", "0", "4", "1", "8", "1", "16", "1", "32", "1", "0", "4", "1", "8", "1", "16", "1", "32", "1", "0", "1", "0", "0", "60", "60", "61"], "File": "arc2", "Func": "arc_init_reg_tables", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33411, "Length": 357}
{"ground_truth": ["<s>", "static", "int", "arc_address_cost", "(", "rtx", "addr", ")", "{", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "return", "1", ";", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "case", "CONST", ":", "return", "2", ";", "case", "PLUS", ":", "{", "register", "rtx", "plus0", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "register", "rtx", "plus1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "plus0", ")", "!=", "REG", ")", "break", ";", "switch", "(", "GET_CODE", "(", "plus1", ")", ")", "{", "case", "CONST_INT", ":", "return", "SMALL_INT", "(", "plus1", ")", "?", "1", ":", "2", ";", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "return", "2", ";", "default", ":", "break", ";", "}", "break", ";", "}", "default", ":", "break", ";", "}", "return", "4", ";", "}", "</s>"], "natrual_language": ["Provide", "the", "costs", "of", "an", "addressing", "mode", "that", "contains", "ADDR", ".", "If", "ADDR", "is", "not", "a", "valid", "address", ",", "its", "cost", "is", "irrelevant", "."], "TS_V_token": ["arc", "1", "2", "0", "1", "1", "2", "2", "4"], "File": "arc3", "Func": "arc_address_cost", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33412, "Length": 121}
{"ground_truth": ["<s>", "static", "bool", "arc_assemble_integer", "(", "rtx", "x", ",", "unsigned", "int", "size", ",", "int", "aligned_p", ")", "{", "if", "(", "size", "==", "UNITS_PER_WORD", "&&", "aligned_p", "&&", "(", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_FUNCTION_P", "(", "x", ")", ")", "||", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", ")", "{", "fputs", "(", "\"\\t.word\\t%st(\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fputs", "(", "\")\\n\"", ",", "asm_out_file", ")", ";", "return", "true", ";", "}", "return", "default_assemble_integer", "(", "x", ",", "size", ",", "aligned_p", ")", ";", "}", "</s>"], "natrual_language": ["Target", "hook", "to", "assemble", "an", "integer", "object", ".", "The", "ARC", "version", "needs", "to", "emit", "a", "special", "directive", "for", "references", "to", "labels", "and", "function", "symbols", "."], "TS_V_token": ["arc", "\"\\t.word\\t%st(\"", "\")\\n\""], "File": "arc3", "Func": "arc_assemble_integer", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33413, "Length": 83}
{"ground_truth": ["<s>", "void", "arc_ccfsm_at_label", "(", "const", "char", "*", "prefix", ",", "int", "num", ")", "{", "if", "(", "arc_ccfsm_state", "==", "3", "&&", "arc_ccfsm_target_label", "==", "num", "&&", "!", "strcmp", "(", "prefix", ",", "\"L\"", ")", ")", "{", "arc_ccfsm_state", "=", "0", ";", "arc_ccfsm_target_insn", "=", "NULL_RTX", ";", "}", "}", "</s>"], "natrual_language": ["Record", "that", "we", "are", "currently", "outputting", "label", "NUM", "with", "prefix", "PREFIX", ".", "It", "it", "'s", "the", "label", "we", "'re", "looking", "for", ",", "reset", "the", "ccfsm", "machinery", ".", "Called", "from", "(", "*", "targetm.asm_out.internal_label", ")", "."], "TS_V_token": ["arc", "3", "\"L\"", "0"], "File": "arc3", "Func": "arc_ccfsm_at_label", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33414, "Length": 41}
{"ground_truth": ["<s>", "int", "arc_ccfsm_branch_deleted_p", "(", "void", ")", "{", "if", "(", "arc_ccfsm_state", "==", "1", "||", "arc_ccfsm_state", "==", "2", ")", "return", "1", ";", "return", "0", ";", "}", "</s>"], "natrual_language": ["See", "if", "the", "current", "insn", ",", "which", "is", "a", "conditional", "branch", ",", "is", "to", "be", "deleted", "."], "TS_V_token": ["arc", "1", "2", "1", "0"], "File": "arc3", "Func": "arc_ccfsm_branch_deleted_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33415, "Length": 23}
{"ground_truth": ["<s>", "void", "arc_ccfsm_record_branch_deleted", "(", "void", ")", "{", "arc_ccfsm_state", "+=", "2", ";", "current_insn_set_cc_p", "=", "last_insn_set_cc_p", ";", "}", "</s>"], "natrual_language": ["Record", "a", "branch", "is", "n't", "output", "because", "subsequent", "insns", "can", "be", "conditionalized", "."], "TS_V_token": ["arc", "2"], "File": "arc3", "Func": "arc_ccfsm_record_branch_deleted", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33416, "Length": 15}
{"ground_truth": ["<s>", "unsigned", "int", "arc_compute_frame_size", "(", "int", "size", ")", "{", "int", "regno", ";", "unsigned", "int", "total_size", ",", "var_size", ",", "args_size", ",", "pretend_size", ",", "extra_size", ";", "unsigned", "int", "reg_size", ",", "reg_offset", ";", "unsigned", "int", "gmask", ";", "enum", "arc_function_type", "fn_type", ";", "int", "interrupt_p", ";", "var_size", "=", "size", ";", "args_size", "=", "current_function_outgoing_args_size", ";", "pretend_size", "=", "current_function_pretend_args_size", ";", "extra_size", "=", "FIRST_PARM_OFFSET", "(", "0", ")", ";", "total_size", "=", "extra_size", "+", "pretend_size", "+", "args_size", "+", "var_size", ";", "reg_offset", "=", "FIRST_PARM_OFFSET", "(", "0", ")", "+", "current_function_outgoing_args_size", ";", "reg_size", "=", "0", ";", "gmask", "=", "0", ";", "fn_type", "=", "arc_compute_function_type", "(", "current_function_decl", ")", ";", "interrupt_p", "=", "ARC_INTERRUPT_P", "(", "fn_type", ")", ";", "for", "(", "regno", "=", "0", ";", "regno", "<=", "31", ";", "regno", "++", ")", "{", "if", "(", "MUST_SAVE_REGISTER", "(", "regno", ",", "interrupt_p", ")", ")", "{", "reg_size", "+=", "UNITS_PER_WORD", ";", "gmask", "|=", "1", "<<", "regno", ";", "}", "}", "total_size", "+=", "reg_size", ";", "if", "(", "total_size", "==", "extra_size", "&&", "!", "MUST_SAVE_RETURN_ADDR", ")", "total_size", "=", "extra_size", "=", "0", ";", "total_size", "=", "ARC_STACK_ALIGN", "(", "total_size", ")", ";", "current_frame_info", ".", "total_size", "=", "total_size", ";", "current_frame_info", ".", "extra_size", "=", "extra_size", ";", "current_frame_info", ".", "pretend_size", "=", "pretend_size", ";", "current_frame_info", ".", "var_size", "=", "var_size", ";", "current_frame_info", ".", "args_size", "=", "args_size", ";", "current_frame_info", ".", "reg_size", "=", "reg_size", ";", "current_frame_info", ".", "reg_offset", "=", "reg_offset", ";", "current_frame_info", ".", "gmask", "=", "gmask", ";", "current_frame_info", ".", "initialized", "=", "reload_completed", ";", "return", "total_size", ";", "}", "</s>"], "natrual_language": ["Return", "the", "bytes", "needed", "to", "compute", "the", "frame", "pointer", "from", "the", "current", "stack", "pointer", ".", "SIZE", "is", "the", "size", "needed", "for", "local", "variables", "."], "TS_V_token": ["arc", "0", "0", "0", "0", "0", "31", "1", "0"], "File": "arc3", "Func": "arc_compute_frame_size", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33417, "Length": 220}
{"ground_truth": ["<s>", "enum", "arc_function_type", "arc_compute_function_type", "(", "tree", "decl", ")", "{", "tree", "a", ";", "static", "enum", "arc_function_type", "fn_type", "=", "ARC_FUNCTION_UNKNOWN", ";", "static", "tree", "last_fn", "=", "NULL_TREE", ";", "if", "(", "decl", "==", "NULL_TREE", ")", "{", "fn_type", "=", "ARC_FUNCTION_UNKNOWN", ";", "last_fn", "=", "NULL_TREE", ";", "return", "fn_type", ";", "}", "if", "(", "decl", "==", "last_fn", "&&", "fn_type", "!=", "ARC_FUNCTION_UNKNOWN", ")", "return", "fn_type", ";", "fn_type", "=", "ARC_FUNCTION_NORMAL", ";", "for", "(", "a", "=", "DECL_ATTRIBUTES", "(", "current_function_decl", ")", ";", "a", ";", "a", "=", "TREE_CHAIN", "(", "a", ")", ")", "{", "tree", "name", "=", "TREE_PURPOSE", "(", "a", ")", ",", "args", "=", "TREE_VALUE", "(", "a", ")", ";", "if", "(", "name", "==", "get_identifier", "(", "\"__interrupt__\"", ")", "&&", "list_length", "(", "args", ")", "==", "1", "&&", "TREE_CODE", "(", "TREE_VALUE", "(", "args", ")", ")", "==", "STRING_CST", ")", "{", "tree", "value", "=", "TREE_VALUE", "(", "args", ")", ";", "if", "(", "!", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink1\"", ")", ")", "fn_type", "=", "ARC_FUNCTION_ILINK1", ";", "else", "if", "(", "!", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink2\"", ")", ")", "fn_type", "=", "ARC_FUNCTION_ILINK2", ";", "else", "gcc_unreachable", "(", ")", ";", "break", ";", "}", "}", "last_fn", "=", "decl", ";", "return", "fn_type", ";", "}", "</s>"], "natrual_language": ["Type", "of", "function", "DECL", ".", "The", "result", "is", "cached", ".", "To", "reset", "the", "cache", "at", "the", "end", "of", "a", "function", ",", "call", "with", "DECL", "=", "NULL_TREE", "."], "TS_V_token": ["arc", "\"__interrupt__\"", "1", "\"ilink1\"", "\"ilink2\""], "File": "arc3", "Func": "arc_compute_function_type", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33418, "Length": 181}
{"ground_truth": ["<s>", "int", "arc_delay_slots_for_epilogue", "(", "void", ")", "{", "if", "(", "arc_compute_function_type", "(", "current_function_decl", ")", "!=", "ARC_FUNCTION_NORMAL", ")", "return", "0", ";", "if", "(", "!", "current_frame_info", ".", "initialized", ")", "(", "void", ")", "arc_compute_frame_size", "(", "get_frame_size", "(", ")", ")", ";", "if", "(", "current_frame_info", ".", "total_size", "==", "0", ")", "return", "1", ";", "return", "0", ";", "}", "</s>"], "natrual_language": ["Define", "the", "number", "of", "delay", "slots", "needed", "for", "the", "function", "epilogue", ".", "Interrupt", "handlers", "ca", "n't", "have", "any", "epilogue", "delay", "slots", "(", "it", "'s", "always", "needed", "for", "something", "else", ",", "I", "think", ")", ".", "For", "normal", "functions", ",", "we", "have", "to", "worry", "about", "using", "call-saved", "regs", "as", "they", "'ll", "be", "restored", "before", "the", "delay", "slot", "insn", ".", "Functions", "with", "non-empty", "frames", "already", "have", "enough", "choices", "for", "the", "epilogue", "delay", "slot", "so", "for", "now", "we", "only", "consider", "functions", "with", "empty", "frames", "."], "TS_V_token": ["arc", "0", "0", "1", "0"], "File": "arc3", "Func": "arc_delay_slots_for_epilogue", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33419, "Length": 50}
{"ground_truth": ["<s>", "int", "arc_double_limm_p", "(", "rtx", "value", ")", "{", "HOST_WIDE_INT", "low", ",", "high", ";", "gcc_assert", "(", "GET_CODE", "(", "value", ")", "==", "CONST_DOUBLE", ")", ";", "low", "=", "CONST_DOUBLE_LOW", "(", "value", ")", ";", "high", "=", "CONST_DOUBLE_HIGH", "(", "value", ")", ";", "if", "(", "low", "&", "0x80000000", ")", "{", "return", "(", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "low", "<=", "0xffffffff", "&&", "high", "==", "0", ")", "||", "(", "(", "(", "low", "&", "-", "(", "unsigned", "HOST_WIDE_INT", ")", "0x80000000", ")", "==", "-", "(", "unsigned", "HOST_WIDE_INT", ")", "0x80000000", ")", "&&", "high", "==", "-", "1", ")", ")", ";", "}", "else", "{", "return", "(", "unsigned", "HOST_WIDE_INT", ")", "low", "<=", "0x7fffffff", "&&", "high", "==", "0", ";", "}", "}", "</s>"], "natrual_language": ["Return", "1", "if", "VALUE", ",", "a", "const_double", ",", "will", "fit", "in", "a", "limm", "(", "4", "byte", "number", ")", ".", "We", "assume", "the", "value", "can", "be", "either", "signed", "or", "unsigned", "."], "TS_V_token": ["arc", "0x80000000", "0xffffffff", "0", "0x80000000", "0x80000000", "1", "0x7fffffff", "0"], "File": "arc3", "Func": "arc_double_limm_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33420, "Length": 105}
{"ground_truth": ["<s>", "int", "arc_eligible_for_epilogue_delay", "(", "rtx", "trial", ",", "int", "slot", ")", "{", "gcc_assert", "(", "!", "slot", ")", ";", "if", "(", "get_attr_length", "(", "trial", ")", "==", "1", "&&", "current_frame_info", ".", "gmask", "==", "0", "&&", "!", "reg_mentioned_p", "(", "stack_pointer_rtx", ",", "PATTERN", "(", "trial", ")", ")", "&&", "!", "reg_mentioned_p", "(", "frame_pointer_rtx", ",", "PATTERN", "(", "trial", ")", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "TRIAL", "is", "a", "valid", "insn", "for", "the", "epilogue", "delay", "slot", ".", "Any", "single", "length", "instruction", "which", "does", "n't", "reference", "the", "stack", "or", "frame", "pointer", "or", "any", "call-saved", "register", "is", "OK.", "SLOT", "will", "always", "be", "0", "."], "TS_V_token": ["arc", "1", "0", "1", "0"], "File": "arc3", "Func": "arc_eligible_for_epilogue_delay", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33421, "Length": 60}
{"ground_truth": ["<s>", "static", "void", "arc_external_libcall", "(", "rtx", "fun", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_MANGLE_CPU_LIBGCC", ")", "{", "fprintf", "(", "FILE", ",", "\"\\t.rename\\t_%s, _%s%s\\n\"", ",", "XSTR", "(", "SYMREF", ",", "0", ")", ",", "XSTR", "(", "SYMREF", ",", "0", ")", ",", "arc_mangle_suffix", ")", ";", "}", "}", "</s>"], "natrual_language": ["Worker", "function", "for", "TARGET_ASM_EXTERNAL_LIBCALL", "."], "TS_V_token": ["arc", "\"\\t.rename\\t_%s, _%s%s\\n\"", "0", "0"], "File": "arc3", "Func": "arc_external_libcall", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33422, "Length": 39}
{"ground_truth": ["<s>", "static", "void", "arc_file_start", "(", "void", ")", "{", "default_file_start", "(", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.cpu %s\\n\"", ",", "arc_cpu_string", ")", ";", "}", "</s>"], "natrual_language": ["Set", "the", "cpu", "type", "and", "print", "out", "other", "fancy", "things", ",", "at", "the", "top", "of", "the", "file", "."], "TS_V_token": ["arc", "\"\\t.cpu %s\\n\""], "File": "arc3", "Func": "arc_file_start", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33423, "Length": 21}
{"ground_truth": ["<s>", "static", "bool", "arc_handle_option", "(", "size_t", "code", ",", "const", "char", "*", "arg", ",", "int", "value", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "code", ")", "{", "case", "OPT_mcpu_", ":", "return", "strcmp", "(", "arg", ",", "\"base\"", ")", "==", "0", "||", "ARC_EXTENSION_CPU", "(", "arg", ")", ";", "default", ":", "return", "true", ";", "}", "}", "</s>"], "natrual_language": ["Implement", "TARGET_HANDLE_OPTION", "."], "TS_V_token": ["arc", "\"base\"", "0"], "File": "arc3", "Func": "arc_handle_option", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33424, "Length": 47}
{"ground_truth": ["<s>", "void", "arc_init", "(", "void", ")", "{", "char", "*", "tmp", ";", "arc_text_section", "=", "tmp", "=", "xmalloc", "(", "strlen", "(", "arc_text_string", ")", "+", "sizeof", "(", "ARC_SECTION_FORMAT", ")", "+", "1", ")", ";", "sprintf", "(", "tmp", ",", "ARC_SECTION_FORMAT", ",", "arc_text_string", ")", ";", "arc_data_section", "=", "tmp", "=", "xmalloc", "(", "strlen", "(", "arc_data_string", ")", "+", "sizeof", "(", "ARC_SECTION_FORMAT", ")", "+", "1", ")", ";", "sprintf", "(", "tmp", ",", "ARC_SECTION_FORMAT", ",", "arc_data_string", ")", ";", "arc_rodata_section", "=", "tmp", "=", "xmalloc", "(", "strlen", "(", "arc_rodata_string", ")", "+", "sizeof", "(", "ARC_SECTION_FORMAT", ")", "+", "1", ")", ";", "sprintf", "(", "tmp", ",", "ARC_SECTION_FORMAT", ",", "arc_rodata_string", ")", ";", "arc_init_reg_tables", "(", ")", ";", "memset", "(", "arc_punct_chars", ",", "0", ",", "sizeof", "(", "arc_punct_chars", ")", ")", ";", "arc_punct_chars", "[", "'#'", "]", "=", "1", ";", "arc_punct_chars", "[", "'*'", "]", "=", "1", ";", "arc_punct_chars", "[", "'?'", "]", "=", "1", ";", "arc_punct_chars", "[", "'!'", "]", "=", "1", ";", "arc_punct_chars", "[", "'~'", "]", "=", "1", ";", "}", "</s>"], "natrual_language": ["Called", "by", "OVERRIDE_OPTIONS", "to", "initialize", "various", "things", "."], "TS_V_token": ["arc", "1", "1", "1", "0", "1", "1", "1", "1", "1"], "File": "arc3", "Func": "arc_init", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33425, "Length": 146}
{"ground_truth": ["<s>", "void", "arc_initialize_trampoline", "(", "rtx", "tramp", "ATTRIBUTE_UNUSED", ",", "rtx", "fnaddr", "ATTRIBUTE_UNUSED", ",", "rtx", "cxt", "ATTRIBUTE_UNUSED", ")", "{", "}", "</s>"], "natrual_language": ["With", "potentially", "multiple", "shared", "objects", "loaded", ",", "and", "multiple", "stacks", "present", "for", "multiple", "thereds", "where", "trampolines", "might", "reside", ",", "a", "simple", "range", "check", "will", "likely", "not", "suffice", "for", "the", "profiler", "to", "tell", "if", "a", "callee", "is", "a", "trampoline", ".", "We", "a", "speedier", "check", "by", "making", "the", "trampoline", "start", "at", "an", "address", "that", "is", "not", "4-byte", "aligned", ".", "A", "trampoline", "looks", "like", "this", ":", "nop_s", "0x78e0entry", ":", "ld_s", "r12", ",", "[", "pcl,12", "]", "0xd403", "ld", "r11", ",", "[", "pcl,12", "]", "0x170c", "700b", "j_s", "[", "r12", "]", "0x7c00", "nop_s", "0x78e0", "The", "fastest", "trampoline", "to", "execute", "for", "trampolines", "within", "+-8KB", "of", "CTX", "would", "be", ":", "add2", "r11", ",", "pcl", ",", "s12", "j", "[", "limm", "]", "0x20200f80", "limm", "and", "that", "would", "also", "be", "faster", "to", "write", "to", "the", "stack", "by", "computing", "the", "offset", "from", "CTX", "to", "TRAMP", "at", "compile", "time", ".", "However", ",", "it", "would", "really", "be", "better", "to", "get", "rid", "of", "the", "high", "cost", "of", "cache", "invalidation", "when", "generating", "trampolines", ",", "which", "requires", "that", "the", "code", "part", "of", "trampolines", "stays", "constant", ",", "and", "additionally", "either", "-", "making", "sure", "that", "no", "executable", "code", "but", "trampolines", "is", "on", "the", "stack", ",", "no", "icache", "entries", "linger", "for", "the", "area", "of", "the", "stack", "from", "when", "before", "the", "stack", "was", "allocated", ",", "and", "allocating", "trampolines", "in", "trampoline-only", "cache", "lines", "or", "-", "allocate", "trampolines", "fram", "a", "special", "pool", "of", "pre-allocated", "trampolines", "."], "TS_V_token": ["arc"], "File": "arc3", "Func": "arc_initialize_trampoline", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33426, "Length": 17}
{"ground_truth": ["<s>", "static", "void", "arc_init_reg_tables", "(", "void", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "NUM_MACHINE_MODES", ";", "i", "++", ")", "{", "switch", "(", "GET_MODE_CLASS", "(", "i", ")", ")", "{", "case", "MODE_INT", ":", "case", "MODE_PARTIAL_INT", ":", "case", "MODE_COMPLEX_INT", ":", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "<=", "4", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "S_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "==", "8", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "D_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "==", "16", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "T_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "==", "32", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "O_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "case", "MODE_FLOAT", ":", "case", "MODE_COMPLEX_FLOAT", ":", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "<=", "4", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "SF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "==", "8", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "DF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "==", "16", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "TF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "==", "32", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "OF_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "case", "MODE_CC", ":", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "C_MODE", ";", "break", ";", "default", ":", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "}", "}", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "{", "if", "(", "i", "<", "60", ")", "arc_regno_reg_class", "[", "i", "]", "=", "GENERAL_REGS", ";", "else", "if", "(", "i", "==", "60", ")", "arc_regno_reg_class", "[", "i", "]", "=", "LPCOUNT_REG", ";", "else", "if", "(", "i", "==", "61", ")", "arc_regno_reg_class", "[", "i", "]", "=", "NO_REGS", ";", "else", "arc_regno_reg_class", "[", "i", "]", "=", "NO_REGS", ";", "}", "}", "</s>"], "natrual_language": ["Initialize", "the", "arc_mode_class", "array", "."], "TS_V_token": ["arc", "0", "4", "1", "8", "1", "16", "1", "32", "1", "0", "4", "1", "8", "1", "16", "1", "32", "1", "0", "1", "0", "0", "60", "60", "61"], "File": "arc3", "Func": "arc_init_reg_tables", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33427, "Length": 336}
{"ground_truth": ["<s>", "static", "void", "arc_internal_label", "(", "FILE", "*", "stream", ",", "const", "char", "*", "prefix", ",", "unsigned", "long", "labelno", ")", "{", "arc_ccfsm_at_label", "(", "prefix", ",", "labelno", ")", ";", "default_internal_label", "(", "stream", ",", "prefix", ",", "labelno", ")", ";", "}", "</s>"], "natrual_language": ["This", "is", "how", "to", "output", "a", "definition", "of", "an", "internal", "numbered", "label", "where", "PREFIX", "is", "the", "class", "of", "label", "and", "NUM", "is", "the", "number", "within", "the", "class", "."], "TS_V_token": ["arc"], "File": "arc3", "Func": "arc_internal_label", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33428, "Length": 35}
{"ground_truth": ["<s>", "static", "void", "arc_output_function_prologue", "(", "FILE", "*", "file", ",", "HOST_WIDE_INT", "size", ")", "{", "const", "char", "*", "sp_str", "=", "reg_names", "[", "STACK_POINTER_REGNUM", "]", ";", "const", "char", "*", "fp_str", "=", "reg_names", "[", "FRAME_POINTER_REGNUM", "]", ";", "unsigned", "int", "gmask", "=", "current_frame_info", ".", "gmask", ";", "enum", "arc_function_type", "fn_type", "=", "arc_compute_function_type", "(", "current_function_decl", ")", ";", "if", "(", "ARC_INTERRUPT_P", "(", "fn_type", ")", ")", "{", "fprintf", "(", "file", ",", "\"\\t%s interrupt handler\\n\"", ",", "ASM_COMMENT_START", ")", ";", "fprintf", "(", "file", ",", "\"\\tsub %s,%s,16\\n\"", ",", "sp_str", ",", "sp_str", ")", ";", "}", "fprintf", "(", "file", ",", "\"\\t%s BEGIN PROLOGUE %s vars= %d, regs= %d, args= %d, extra= %d\\n\"", ",", "ASM_COMMENT_START", ",", "ASM_COMMENT_START", ",", "current_frame_info", ".", "var_size", ",", "current_frame_info", ".", "reg_size", "/", "4", ",", "current_frame_info", ".", "args_size", ",", "current_frame_info", ".", "extra_size", ")", ";", "size", "=", "ARC_STACK_ALIGN", "(", "size", ")", ";", "size", "=", "(", "!", "current_frame_info", ".", "initialized", "?", "arc_compute_frame_size", "(", "size", ")", ":", "current_frame_info", ".", "total_size", ")", ";", "gcc_assert", "(", "size", "||", "!", "gmask", ")", ";", "if", "(", "current_frame_info", ".", "pretend_size", "!=", "0", ")", "fprintf", "(", "file", ",", "\"\\tsub %s,%s,%d\\n\"", ",", "sp_str", ",", "sp_str", ",", "current_frame_info", ".", "pretend_size", ")", ";", "if", "(", "MUST_SAVE_RETURN_ADDR", ")", "fprintf", "(", "file", ",", "\"\\tst %s,[%s,%d]\\n\"", ",", "reg_names", "[", "RETURN_ADDR_REGNUM", "]", ",", "sp_str", ",", "UNITS_PER_WORD", ")", ";", "if", "(", "frame_pointer_needed", ")", "{", "fprintf", "(", "file", ",", "\"\\tst %s,[%s]\\n\"", ",", "fp_str", ",", "sp_str", ")", ";", "fprintf", "(", "file", ",", "\"\\tmov %s,%s\\n\"", ",", "fp_str", ",", "sp_str", ")", ";", "}", "if", "(", "size", "-", "current_frame_info", ".", "pretend_size", ">", "0", ")", "fprintf", "(", "file", ",", "\"\\tsub %s,%s,\"", "HOST_WIDE_INT_PRINT_DEC", "\"\\n\"", ",", "sp_str", ",", "sp_str", ",", "size", "-", "current_frame_info", ".", "pretend_size", ")", ";", "arc_save_restore", "(", "file", ",", "sp_str", ",", "current_frame_info", ".", "reg_offset", ",", "gmask", "&", "~", "(", "FRAME_POINTER_MASK", "|", "RETURN_ADDR_MASK", ")", ",", "\"st\"", ")", ";", "fprintf", "(", "file", ",", "\"\\t%s END PROLOGUE\\n\"", ",", "ASM_COMMENT_START", ")", ";", "}", "</s>"], "natrual_language": ["Set", "up", "the", "stack", "and", "frame", "pointer", "(", "if", "desired", ")", "for", "the", "function", "."], "TS_V_token": ["arc", "\"\\t%s interrupt handler\\n\"", "\"\\tsub %s,%s,16\\n\"", "\"\\t%s BEGIN PROLOGUE %s vars= %d, regs= %d, args= %d, extra= %d\\n\"", "4", "0", "\"\\tsub %s,%s,%d\\n\"", "\"\\tst %s,[%s,%d]\\n\"", "\"\\tst %s,[%s]\\n\"", "\"\\tmov %s,%s\\n\"", "0", "\"\\tsub %s,%s,\"", "\"\\n\"", "\"st\"", "\"\\t%s END PROLOGUE\\n\""], "File": "arc3", "Func": "arc_output_function_prologue", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33429, "Length": 272}
{"ground_truth": ["<s>", "void", "arc_print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "register", "rtx", "base", ",", "index", "=", "0", ";", "int", "offset", "=", "0", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "fputs", "(", "reg_names", "[", "REGNO", "(", "addr", ")", "]", ",", "file", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "if", "(", "0", "&&", "SYMBOL_REF_FUNCTION_P", "(", "addr", ")", ")", "{", "fprintf", "(", "file", ",", "\"%%st(\"", ")", ";", "output_addr_const", "(", "file", ",", "addr", ")", ";", "fprintf", "(", "file", ",", "\")\"", ")", ";", "}", "else", "output_addr_const", "(", "file", ",", "addr", ")", ";", "break", ";", "case", "PLUS", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "CONST_INT", ")", "offset", "=", "INTVAL", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ",", "base", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "==", "CONST_INT", ")", "offset", "=", "INTVAL", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ",", "base", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "else", "base", "=", "XEXP", "(", "addr", ",", "0", ")", ",", "index", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "base", ")", "==", "REG", ")", ";", "fputs", "(", "reg_names", "[", "REGNO", "(", "base", ")", "]", ",", "file", ")", ";", "if", "(", "index", "==", "0", ")", "{", "if", "(", "offset", "!=", "0", ")", "fprintf", "(", "file", ",", "\",%d\"", ",", "offset", ")", ";", "}", "else", "{", "switch", "(", "GET_CODE", "(", "index", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "file", ",", "\",%s\"", ",", "reg_names", "[", "REGNO", "(", "index", ")", "]", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "fputc", "(", "','", ",", "file", ")", ",", "output_addr_const", "(", "file", ",", "index", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "break", ";", "case", "PRE_INC", ":", "case", "PRE_DEC", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "default", ":", "output_addr_const", "(", "file", ",", "addr", ")", ";", "break", ";", "}", "}", "</s>"], "natrual_language": ["Print", "a", "memory", "address", "as", "an", "operand", "to", "reference", "that", "memory", "location", "."], "TS_V_token": ["arc", "0", "0", "0", "\"%%st(\"", "\")\"", "0", "0", "1", "1", "1", "0", "0", "1", "0", "0", "\",%d\"", "\",%s\""], "File": "arc3", "Func": "arc_print_operand_address", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33430, "Length": 318}
{"ground_truth": ["<s>", "static", "bool", "arc_return_in_memory", "(", "tree", "type", ",", "tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "return", "true", ";", "else", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "return", "(", "size", "==", "-", "1", "||", "size", ">", "8", ")", ";", "}", "}", "</s>"], "natrual_language": ["Worker", "function", "for", "TARGET_RETURN_IN_MEMORY", "."], "TS_V_token": ["arc", "1", "8"], "File": "arc3", "Func": "arc_return_in_memory", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33431, "Length": 46}
{"ground_truth": ["<s>", "static", "bool", "arc_rtx_costs", "(", "rtx", "x", ",", "int", "code", ",", "int", "outer_code", "ATTRIBUTE_UNUSED", ",", "int", "*", "total", ")", "{", "switch", "(", "code", ")", "{", "case", "CONST_INT", ":", "if", "(", "SMALL_INT", "(", "INTVAL", "(", "x", ")", ")", ")", "{", "*", "total", "=", "0", ";", "return", "true", ";", "}", "case", "CONST", ":", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "true", ";", "case", "CONST_DOUBLE", ":", "{", "rtx", "high", ",", "low", ";", "split_double", "(", "x", ",", "&", "high", ",", "&", "low", ")", ";", "*", "total", "=", "COSTS_N_INSNS", "(", "!", "SMALL_INT", "(", "INTVAL", "(", "high", ")", ")", "+", "!", "SMALL_INT", "(", "INTVAL", "(", "low", ")", ")", ")", ";", "return", "true", ";", "}", "case", "ASHIFT", ":", "case", "ASHIFTRT", ":", "case", "LSHIFTRT", ":", "if", "(", "TARGET_SHIFTER", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "!=", "CONST_INT", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "16", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "INTVAL", "(", "XEXP", "(", "(", "x", ")", ",", "1", ")", ")", ")", ";", "return", "false", ";", "default", ":", "return", "false", ";", "}", "}", "</s>"], "natrual_language": ["Compute", "a", "(", "partial", ")", "cost", "for", "rtx", "X", ".", "Return", "true", "if", "the", "complete", "cost", "has", "been", "computed", ",", "and", "false", "if", "subexpressions", "should", "be", "scanned", ".", "In", "either", "case", ",", "*", "TOTAL", "contains", "the", "cost", "result", "."], "TS_V_token": ["arc", "0", "1", "1", "1", "16", "1"], "File": "arc3", "Func": "arc_rtx_costs", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33432, "Length": 188}
{"ground_truth": ["<s>", "void", "arc_save_restore", "(", "FILE", "*", "file", ",", "const", "char", "*", "base_reg", ",", "unsigned", "int", "offset", ",", "unsigned", "int", "gmask", ",", "const", "char", "*", "op", ")", "{", "int", "regno", ";", "if", "(", "gmask", "==", "0", ")", "return", ";", "for", "(", "regno", "=", "0", ";", "regno", "<=", "31", ";", "regno", "++", ")", "{", "if", "(", "(", "gmask", "&", "(", "1L", "<<", "regno", ")", ")", "!=", "0", ")", "{", "fprintf", "(", "file", ",", "\"\\t%s %s,[%s,%d]\\n\"", ",", "op", ",", "reg_names", "[", "regno", "]", ",", "base_reg", ",", "offset", ")", ";", "offset", "+=", "UNITS_PER_WORD", ";", "}", "}", "}", "</s>"], "natrual_language": ["BASE_REG", "is", "the", "base", "register", "to", "use", "for", "addressing", "and", "to", "adjust", ".", "GMASK", "is", "a", "bitmask", "of", "general", "purpose", "registers", "to", "save/restore", ".", "epilogue_p", "0", ":", "prologue", "1", ":", "epilogue", "2", ":", "epilogue", ",", "sibling", "thunk", "If", "*", "FIRST_OFFSET", "is", "non-zero", ",", "add", "it", "first", "to", "BASE_REG", "-", "preferably", "using", "a", "pre-modify", "for", "the", "first", "memory", "access", ".", "*", "FIRST_OFFSET", "is", "then", "zeroed", "."], "TS_V_token": ["arc", "0", "0", "31", "1L", "0", "\"\\t%s %s,[%s,%d]\\n\""], "File": "arc3", "Func": "arc_save_restore", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33433, "Length": 91}
{"ground_truth": ["<s>", "enum", "machine_mode", "arc_select_cc_mode", "(", "enum", "rtx_code", "op", ",", "rtx", "x", "ATTRIBUTE_UNUSED", ",", "rtx", "y", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "op", ")", "{", "case", "EQ", ":", "case", "NE", ":", "return", "CCZNmode", ";", "default", ":", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "AND", ":", "case", "IOR", ":", "case", "XOR", ":", "case", "SIGN_EXTEND", ":", "case", "ZERO_EXTEND", ":", "return", "CCZNmode", ";", "case", "ASHIFT", ":", "case", "ASHIFTRT", ":", "case", "LSHIFTRT", ":", "return", "CCZNCmode", ";", "default", ":", "break", ";", "}", "}", "return", "CCmode", ";", "}", "</s>"], "natrual_language": ["Given", "a", "comparison", "code", "(", "EQ", ",", "NE", ",", "etc", ".", ")", "and", "the", "first", "operand", "of", "a", "COMPARE", ",", "return", "the", "mode", "to", "be", "used", "for", "the", "comparison", "."], "TS_V_token": ["arc"], "File": "arc3", "Func": "arc_select_cc_mode", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33434, "Length": 81}
{"ground_truth": ["<s>", "static", "void", "arc_setup_incoming_varargs", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", "ATTRIBUTE_UNUSED", ",", "int", "*", "pretend_size", ",", "int", "no_rtl", ")", "{", "int", "first_anon_arg", ";", "gcc_assert", "(", "mode", "!=", "BLKmode", ")", ";", "first_anon_arg", "=", "*", "cum", "+", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ")", ";", "if", "(", "first_anon_arg", "<", "MAX_ARC_PARM_REGS", "&&", "!", "no_rtl", ")", "{", "int", "first_reg_offset", "=", "first_anon_arg", ";", "int", "size", "=", "MAX_ARC_PARM_REGS", "-", "first_reg_offset", ";", "int", "align_slop", "=", "size", "&", "1", ";", "rtx", "regblock", ";", "regblock", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "plus_constant", "(", "arg_pointer_rtx", ",", "FIRST_PARM_OFFSET", "(", "0", ")", "+", "align_slop", "*", "UNITS_PER_WORD", ")", ")", ";", "set_mem_alias_set", "(", "regblock", ",", "get_varargs_alias_set", "(", ")", ")", ";", "set_mem_align", "(", "regblock", ",", "BITS_PER_WORD", ")", ";", "move_block_from_reg", "(", "first_reg_offset", ",", "regblock", ",", "MAX_ARC_PARM_REGS", "-", "first_reg_offset", ")", ";", "*", "pretend_size", "=", "(", "(", "MAX_ARC_PARM_REGS", "-", "first_reg_offset", "+", "align_slop", ")", "*", "UNITS_PER_WORD", ")", ";", "}", "}", "</s>"], "natrual_language": ["Do", "any", "needed", "setup", "for", "a", "variadic", "function", ".", "For", "the", "ARC", ",", "we", "must", "create", "a", "register", "parameter", "block", ",", "and", "then", "copy", "any", "anonymous", "arguments", "in", "registers", "to", "memory", ".", "CUM", "has", "not", "been", "updated", "for", "the", "last", "named", "argument", "which", "has", "type", "TYPE", "and", "mode", "MODE", ",", "and", "we", "rely", "on", "this", "fact", "."], "TS_V_token": ["arc", "1", "1", "0"], "File": "arc3", "Func": "arc_setup_incoming_varargs", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33435, "Length": 151}
{"ground_truth": ["<s>", "int", "call_address_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", ")", "{", "return", "(", "symbolic_operand", "(", "op", ",", "mode", ")", "||", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "LEGITIMATE_CONSTANT_P", "(", "op", ")", ")", "||", "(", "GET_CODE", "(", "op", ")", "==", "REG", ")", ")", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "OP", "is", "a", "valid", "call", "operand", "."], "TS_V_token": ["arc"], "File": "arc3", "Func": "call_address_operand", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33436, "Length": 45}
{"ground_truth": ["<s>", "int", "call_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "0", ";", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "return", "call_address_operand", "(", "op", ",", "mode", ")", ";", "}", "</s>"], "natrual_language": ["Call", "insn", "on", "SPARC", "can", "take", "a", "PC-relative", "constant", "address", ",", "or", "any", "regular", "memory", "address", "."], "TS_V_token": ["arc", "0", "0"], "File": "arc3", "Func": "call_operand", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33437, "Length": 41}
{"ground_truth": ["<s>", "int", "const_sint32_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "(", "INTVAL", "(", "op", ")", ">=", "(", "-", "0x7fffffff", "-", "1", ")", "&&", "INTVAL", "(", "op", ")", "<=", "0x7fffffff", ")", ")", ";", "}", "</s>"], "natrual_language": ["Accept", "integer", "operands", "in", "the", "range", "-0x80000000", "..", "0x7fffffff", ".", "We", "have", "to", "check", "the", "range", "carefully", "since", "this", "predicate", "is", "used", "in", "DImode", "contexts", "."], "TS_V_token": ["arc", "0x7fffffff", "1", "0x7fffffff"], "File": "arc3", "Func": "const_sint32_operand", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33438, "Length": 44}
{"ground_truth": ["<s>", "int", "const_uint32_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "(", "INTVAL", "(", "op", ")", ">=", "0", "&&", "INTVAL", "(", "op", ")", "<=", "0xffffffffL", ")", ")", ";", "return", "(", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "op", ")", ">=", "0", ")", "||", "(", "GET_CODE", "(", "op", ")", "==", "CONST_DOUBLE", "&&", "CONST_DOUBLE_HIGH", "(", "op", ")", "==", "0", ")", ")", ";", "}", "</s>"], "natrual_language": ["Accept", "integer", "operands", "in", "the", "range", "0", "..", "0xffffffff", ".", "We", "have", "to", "check", "the", "range", "carefully", "since", "this", "predicate", "is", "used", "in", "DImode", "contexts", ".", "Also", ",", "we", "need", "some", "extra", "crud", "to", "make", "it", "work", "when", "hosted", "on", "64-bit", "machines", "."], "TS_V_token": ["arc", "0", "0xffffffffL", "0", "0"], "File": "arc3", "Func": "const_uint32_operand", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33439, "Length": 74}
{"ground_truth": ["<s>", "rtx", "gen_compare_reg", "(", "enum", "rtx_code", "code", ",", "rtx", "x", ",", "rtx", "y", ")", "{", "enum", "machine_mode", "mode", "=", "SELECT_CC_MODE", "(", "code", ",", "x", ",", "y", ")", ";", "rtx", "cc_reg", ";", "cc_reg", "=", "gen_rtx_REG", "(", "mode", ",", "61", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "cc_reg", ",", "gen_rtx_COMPARE", "(", "mode", ",", "x", ",", "y", ")", ")", ")", ";", "return", "cc_reg", ";", "}", "</s>"], "natrual_language": ["Emit", "the", "compare", "insn", "and", "return", "the", "CC", "reg", "for", "the", "comparison", "in", "CMP", "."], "TS_V_token": ["arc", "61"], "File": "arc3", "Func": "gen_compare_reg", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33440, "Length": 62}
{"ground_truth": ["<s>", "static", "int", "get_arc_condition_code", "(", "rtx", "comparison", ")", "{", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "EQ", ":", "return", "2", ";", "case", "NE", ":", "return", "3", ";", "case", "GT", ":", "return", "10", ";", "case", "LE", ":", "return", "11", ";", "case", "GE", ":", "return", "12", ";", "case", "LT", ":", "return", "13", ";", "case", "GTU", ":", "return", "14", ";", "case", "LEU", ":", "return", "15", ";", "case", "LTU", ":", "return", "6", ";", "case", "GEU", ":", "return", "7", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "(", "42", ")", ";", "}", "</s>"], "natrual_language": ["Returns", "the", "index", "of", "the", "ARC", "condition", "code", "string", "in", "`", "arc_condition_codes", "'", ".", "COMPARISON", "should", "be", "an", "rtx", "like", "`", "(", "eq", "(", "...", ")", "(", "...", ")", ")", "'", "."], "TS_V_token": ["arc", "2", "3", "10", "11", "12", "13", "14", "15", "6", "7", "42"], "File": "arc3", "Func": "get_arc_condition_code", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33441, "Length": 89}
{"ground_truth": ["<s>", "int", "load_update_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", "||", "GET_MODE", "(", "op", ")", "!=", "mode", ")", "return", "0", ";", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "PLUS", "||", "GET_MODE", "(", "op", ")", "!=", "Pmode", "||", "!", "register_operand", "(", "XEXP", "(", "op", ",", "0", ")", ",", "Pmode", ")", "||", "!", "nonmemory_operand", "(", "XEXP", "(", "op", ",", "1", ")", ",", "Pmode", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "OP", "is", "valid", "load", "with", "update", "operand", "."], "TS_V_token": ["arc", "0", "0", "0", "1", "0", "1"], "File": "arc3", "Func": "load_update_operand", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33442, "Length": 88}
{"ground_truth": ["<s>", "int", "long_immediate_loadstore_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "0", ";", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "case", "CONST", ":", "return", "1", ";", "case", "CONST_INT", ":", "return", "1", ";", "case", "CONST_DOUBLE", ":", "return", "1", ";", "case", "REG", ":", "return", "0", ";", "case", "PLUS", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "op", ",", "1", ")", ")", "==", "CONST_INT", "&&", "!", "SMALL_INT", "(", "INTVAL", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", ")", "return", "1", ";", "return", "0", ";", "default", ":", "break", ";", "}", "return", "0", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "OP", "is", "a", "MEM", "that", "when", "used", "as", "a", "load", "or", "store", "address", "will", "require", "an", "8", "byte", "insn", ".", "Load", "and", "store", "instructions", "do", "n't", "allow", "the", "same", "possibilities", "but", "they", "'re", "similar", "enough", "that", "this", "one", "function", "will", "do", ".", "This", "is", "currently", "only", "used", "when", "calculating", "length", "attributes", "."], "TS_V_token": ["arc", "0", "0", "1", "1", "1", "0", "1", "1", "1", "0", "0"], "File": "arc3", "Func": "long_immediate_loadstore_operand", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33443, "Length": 117}
{"ground_truth": ["<s>", "int", "long_immediate_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "case", "CONST", ":", "return", "1", ";", "case", "CONST_INT", ":", "return", "!", "SMALL_INT", "(", "INTVAL", "(", "op", ")", ")", ";", "case", "CONST_DOUBLE", ":", "return", "1", ";", "default", ":", "break", ";", "}", "return", "0", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "OP", "will", "require", "a", "long", "immediate", "(", "limm", ")", "value", ".", "This", "is", "currently", "only", "used", "when", "calculating", "length", "attributes", "."], "TS_V_token": ["arc", "1", "1", "0"], "File": "arc3", "Func": "long_immediate_operand", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33444, "Length": 60}
{"ground_truth": ["<s>", "int", "move_dest_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", ")", "{", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "REG", ":", "return", "register_operand", "(", "op", ",", "mode", ")", ";", "case", "SUBREG", ":", "if", "(", "GET_CODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "MEM", ")", "return", "address_operand", "(", "XEXP", "(", "SUBREG_REG", "(", "op", ")", ",", "0", ")", ",", "mode", ")", ";", "else", "return", "register_operand", "(", "op", ",", "mode", ")", ";", "case", "MEM", ":", "return", "address_operand", "(", "XEXP", "(", "op", ",", "0", ")", ",", "mode", ")", ";", "default", ":", "return", "0", ";", "}", "}", "</s>"], "natrual_language": ["Return", "true", "if", "OP", "is", "an", "acceptable", "argument", "for", "a", "move", "destination", "."], "TS_V_token": ["arc", "0", "0", "0"], "File": "arc3", "Func": "move_dest_operand", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33445, "Length": 93}
{"ground_truth": ["<s>", "int", "move_double_src_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", ")", "{", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "REG", ":", "return", "register_operand", "(", "op", ",", "mode", ")", ";", "case", "SUBREG", ":", "if", "(", "GET_CODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "MEM", ")", "return", "move_double_src_operand", "(", "SUBREG_REG", "(", "op", ")", ",", "mode", ")", ";", "else", "return", "register_operand", "(", "op", ",", "mode", ")", ";", "case", "MEM", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "PRE_DEC", "||", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "PRE_INC", ")", "return", "0", ";", "return", "address_operand", "(", "XEXP", "(", "op", ",", "0", ")", ",", "mode", ")", ";", "case", "CONST_INT", ":", "case", "CONST_DOUBLE", ":", "return", "1", ";", "default", ":", "return", "0", ";", "}", "}", "</s>"], "natrual_language": ["Return", "true", "if", "OP", "is", "an", "acceptable", "argument", "for", "a", "double", "word", "move", "source", "."], "TS_V_token": ["arc", "0", "0", "0", "0", "1", "0"], "File": "arc3", "Func": "move_double_src_operand", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33446, "Length": 126}
{"ground_truth": ["<s>", "int", "move_src_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", ")", "{", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "case", "CONST", ":", "return", "1", ";", "case", "CONST_INT", ":", "return", "(", "LARGE_INT", "(", "INTVAL", "(", "op", ")", ")", ")", ";", "case", "CONST_DOUBLE", ":", "if", "(", "mode", "==", "SImode", ")", "return", "arc_double_limm_p", "(", "op", ")", ";", "if", "(", "mode", "==", "SFmode", ")", "return", "GET_MODE", "(", "op", ")", "==", "SFmode", ";", "return", "0", ";", "case", "REG", ":", "return", "register_operand", "(", "op", ",", "mode", ")", ";", "case", "SUBREG", ":", "if", "(", "GET_CODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "MEM", ")", "return", "address_operand", "(", "XEXP", "(", "SUBREG_REG", "(", "op", ")", ",", "0", ")", ",", "mode", ")", ";", "else", "return", "register_operand", "(", "op", ",", "mode", ")", ";", "case", "MEM", ":", "return", "address_operand", "(", "XEXP", "(", "op", ",", "0", ")", ",", "mode", ")", ";", "default", ":", "return", "0", ";", "}", "}", "</s>"], "natrual_language": ["Return", "true", "if", "OP", "is", "an", "acceptable", "argument", "for", "a", "single", "word", "move", "source", "."], "TS_V_token": ["arc", "1", "0", "0", "0", "0"], "File": "arc3", "Func": "move_src_operand", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33447, "Length": 151}
{"ground_truth": ["<s>", "int", "nonvol_nonimm_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "MEM", "&&", "MEM_VOLATILE_P", "(", "op", ")", ")", "return", "0", ";", "return", "nonimmediate_operand", "(", "op", ",", "mode", ")", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "OP", "is", "a", "non-volatile", "non-immediate", "operand", ".", "Volatile", "memory", "refs", "require", "a", "special", "``", "cache-bypass", "''", "instruction", "and", "only", "the", "standard", "movXX", "patterns", "are", "set", "up", "to", "handle", "them", "."], "TS_V_token": ["arc", "0"], "File": "arc3", "Func": "nonvol_nonimm_operand", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33448, "Length": 37}
{"ground_truth": ["<s>", "const", "char", "*", "output_shift", "(", "rtx", "*", "operands", ")", "{", "rtx", "shift", "=", "operands", "[", "3", "]", ";", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "shift", ")", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "shift", ")", ";", "const", "char", "*", "shift_one", ";", "gcc_assert", "(", "mode", "==", "SImode", ")", ";", "switch", "(", "code", ")", "{", "case", "ASHIFT", ":", "shift_one", "=", "\"asl %0,%0\"", ";", "break", ";", "case", "ASHIFTRT", ":", "shift_one", "=", "\"asr %0,%0\"", ";", "break", ";", "case", "LSHIFTRT", ":", "shift_one", "=", "\"lsr %0,%0\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "!=", "CONST_INT", ")", "{", "if", "(", "optimize", ")", "{", "output_asm_insn", "(", "\"sub.f 0,%2,0\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"mov lp_count,%2\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"bz 2f\"", ",", "operands", ")", ";", "}", "else", "output_asm_insn", "(", "\"mov %4,%2\"", ",", "operands", ")", ";", "goto", "shiftloop", ";", "}", "else", "{", "int", "n", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "n", "<", "0", ")", "n", "=", "0", ";", "else", "if", "(", "n", ">", "GET_MODE_BITSIZE", "(", "mode", ")", ")", "n", "=", "GET_MODE_BITSIZE", "(", "mode", ")", ";", "if", "(", "n", "<=", "8", ")", "{", "while", "(", "--", "n", ">=", "0", ")", "output_asm_insn", "(", "shift_one", ",", "operands", ")", ";", "}", "else", "if", "(", "n", "==", "BITS_PER_WORD", "-", "1", ")", "{", "switch", "(", "code", ")", "{", "case", "ASHIFT", ":", "output_asm_insn", "(", "\"and %0,%0,1\\n\\tror %0,%0\"", ",", "operands", ")", ";", "break", ";", "case", "ASHIFTRT", ":", "output_asm_insn", "(", "\"asl.f 0,%0\\n\\tsbc %0,0,0\"", ",", "operands", ")", ";", "break", ";", "case", "LSHIFTRT", ":", "output_asm_insn", "(", "\"asl.f 0,%0\\n\\tadc %0,0,0\"", ",", "operands", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}", "else", "{", "char", "buf", "[", "100", "]", ";", "if", "(", "optimize", ")", "output_asm_insn", "(", "\"mov lp_count,%c2\"", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "\"mov %4,%c2\"", ",", "operands", ")", ";", "shiftloop", ":", "if", "(", "optimize", ")", "{", "if", "(", "flag_pic", ")", "sprintf", "(", "buf", ",", "\"lr %%4,[status]\\n\\tadd %%4,%%4,6\\t%s single insn loop start\"", ",", "ASM_COMMENT_START", ")", ";", "else", "sprintf", "(", "buf", ",", "\"mov %%4,%%%%st(1f)\\t%s (single insn loop start) >> 2\"", ",", "ASM_COMMENT_START", ")", ";", "output_asm_insn", "(", "buf", ",", "operands", ")", ";", "output_asm_insn", "(", "\"sr %4,[lp_start]\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"add %4,%4,1\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"sr %4,[lp_end]\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"nop\\n\\tnop\"", ",", "operands", ")", ";", "if", "(", "flag_pic", ")", "fprintf", "(", "asm_out_file", ",", "\"\\t%s single insn loop\\n\"", ",", "ASM_COMMENT_START", ")", ";", "else", "fprintf", "(", "asm_out_file", ",", "\"1:\\t%s single insn loop\\n\"", ",", "ASM_COMMENT_START", ")", ";", "output_asm_insn", "(", "shift_one", ",", "operands", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"2:\\t%s end single insn loop\\n\"", ",", "ASM_COMMENT_START", ")", ";", "}", "else", "{", "fprintf", "(", "asm_out_file", ",", "\"1:\\t%s begin shift loop\\n\"", ",", "ASM_COMMENT_START", ")", ";", "output_asm_insn", "(", "\"sub.f %4,%4,1\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"nop\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"bn.nd 2f\"", ",", "operands", ")", ";", "output_asm_insn", "(", "shift_one", ",", "operands", ")", ";", "output_asm_insn", "(", "\"b.nd 1b\"", ",", "operands", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"2:\\t%s end shift loop\\n\"", ",", "ASM_COMMENT_START", ")", ";", "}", "}", "}", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["FIXME", ":", "This", "probably", "can", "be", "done", "using", "a", "define_split", "in", "arc.md", ".", "Alternately", ",", "generate", "rtx", "rather", "than", "output", "instructions", "."], "TS_V_token": ["arc", "3", "\"asl %0,%0\"", "\"asr %0,%0\"", "\"lsr %0,%0\"", "2", "\"sub.f 0,%2,0\"", "\"mov lp_count,%2\"", "\"bz 2f\"", "\"mov %4,%2\"", "2", "0", "0", "8", "0", "1", "\"and %0,%0,1\\n\\tror %0,%0\"", "\"asl.f 0,%0\\n\\tsbc %0,0,0\"", "\"asl.f 0,%0\\n\\tadc %0,0,0\"", "100", "\"mov lp_count,%c2\"", "\"mov %4,%c2\"", "\"lr %%4,[status]\\n\\tadd %%4,%%4,6\\t%s single insn loop start\"", "\"mov %%4,%%%%st(1f)\\t%s (single insn loop start) >> 2\"", "\"sr %4,[lp_start]\"", "\"add %4,%4,1\"", "\"sr %4,[lp_end]\"", "\"nop\\n\\tnop\"", "\"\\t%s single insn loop\\n\"", "\"1:\\t%s single insn loop\\n\"", "\"2:\\t%s end single insn loop\\n\"", "\"1:\\t%s begin shift loop\\n\"", "\"sub.f %4,%4,1\"", "\"nop\"", "\"bn.nd 2f\"", "\"b.nd 1b\"", "\"2:\\t%s end shift loop\\n\"", "\"\""], "File": "arc3", "Func": "output_shift", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33449, "Length": 452}
{"ground_truth": ["<s>", "int", "proper_comparison_operator", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "enum", "rtx_code", "code", ";", "if", "(", "!", "COMPARISON_P", "(", "op", ")", ")", "return", "0", ";", "code", "=", "GET_CODE", "(", "op", ")", ";", "if", "(", "GET_MODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "CCZNmode", ")", "return", "(", "code", "==", "EQ", "||", "code", "==", "NE", ")", ";", "if", "(", "GET_MODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "CCZNCmode", ")", "return", "(", "code", "==", "EQ", "||", "code", "==", "NE", "||", "code", "==", "LTU", "||", "code", "==", "GEU", "||", "code", "==", "GTU", "||", "code", "==", "LEU", ")", ";", "return", "1", ";", "}", "</s>"], "natrual_language": ["Return", "1", "if", "OP", "is", "a", "comparison", "operator", "valid", "for", "the", "mode", "of", "CC", ".", "This", "allows", "the", "use", "of", "MATCH_OPERATOR", "to", "recognize", "all", "the", "branch", "insns", ".", "Some", "insns", "only", "set", "a", "few", "bits", "in", "the", "condition", "code", ".", "So", "only", "allow", "those", "comparisons", "that", "use", "the", "bits", "that", "are", "valid", "."], "TS_V_token": ["arc", "0", "0", "0", "1"], "File": "arc3", "Func": "proper_comparison_operator", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33450, "Length": 104}
{"ground_truth": ["<s>", "static", "void", "record_cc_ref", "(", "rtx", "insn", ")", "{", "last_insn_set_cc_p", "=", "current_insn_set_cc_p", ";", "switch", "(", "get_attr_cond", "(", "insn", ")", ")", "{", "case", "COND_SET", ":", "case", "COND_SET_ZN", ":", "case", "COND_SET_ZNC", ":", "if", "(", "get_attr_length", "(", "insn", ")", "==", "1", ")", "current_insn_set_cc_p", "=", "1", ";", "else", "current_insn_set_cc_p", "=", "0", ";", "break", ";", "default", ":", "current_insn_set_cc_p", "=", "0", ";", "break", ";", "}", "}", "</s>"], "natrual_language": ["Update", "compare/branch", "separation", "marker", "."], "TS_V_token": ["arc", "1", "1", "0", "0"], "File": "arc3", "Func": "record_cc_ref", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33451, "Length": 59}
{"ground_truth": ["<s>", "int", "shift_operator", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "ASHIFTRT", ":", "case", "LSHIFTRT", ":", "case", "ASHIFT", ":", "return", "1", ";", "default", ":", "return", "0", ";", "}", "}", "</s>"], "natrual_language": ["Return", "1", "if", "OP", "is", "a", "shift", "operator", "."], "TS_V_token": ["arc", "1", "0"], "File": "arc3", "Func": "shift_operator", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33452, "Length": 39}
{"ground_truth": ["<s>", "int", "short_immediate_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "!=", "CONST_INT", ")", "return", "0", ";", "return", "SMALL_INT", "(", "INTVAL", "(", "op", ")", ")", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "OP", "is", "a", "short", "immediate", "(", "shimm", ")", "value", "."], "TS_V_token": ["arc", "0"], "File": "arc3", "Func": "short_immediate_operand", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33453, "Length": 34}
{"ground_truth": ["<s>", "int", "store_update_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", "||", "GET_MODE", "(", "op", ")", "!=", "mode", ")", "return", "0", ";", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "PLUS", "||", "GET_MODE", "(", "op", ")", "!=", "Pmode", "||", "!", "register_operand", "(", "XEXP", "(", "op", ",", "0", ")", ",", "Pmode", ")", "||", "!", "(", "GET_CODE", "(", "XEXP", "(", "op", ",", "1", ")", ")", "==", "CONST_INT", "&&", "SMALL_INT", "(", "INTVAL", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "OP", "is", "valid", "store", "with", "update", "operand", "."], "TS_V_token": ["arc", "0", "0", "0", "1", "1", "0", "1"], "File": "arc3", "Func": "store_update_operand", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33454, "Length": 103}
{"ground_truth": ["<s>", "int", "symbolic_memory_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "SUBREG", ")", "op", "=", "SUBREG_REG", "(", "op", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "0", ";", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "return", "(", "GET_CODE", "(", "op", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "op", ")", "==", "CONST", "||", "GET_CODE", "(", "op", ")", "==", "LABEL_REF", ")", ";", "}", "</s>"], "natrual_language": ["Returns", "1", "if", "OP", "is", "a", "memory", "reference", "involving", "a", "symbolic", "constant", "that", "is", "not", "in", "the", "constant", "pool", "."], "TS_V_token": ["arc", "0", "0"], "File": "arc3", "Func": "symbolic_memory_operand", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33455, "Length": 74}
{"ground_truth": ["<s>", "int", "symbolic_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "case", "CONST", ":", "return", "1", ";", "default", ":", "return", "0", ";", "}", "}", "</s>"], "natrual_language": ["Return", "1", "if", "X", "contains", "a", "symbolic", "expression", ".", "We", "know", "these", "expressions", "will", "have", "one", "of", "a", "few", "well", "defined", "forms", ",", "so", "we", "need", "only", "check", "those", "forms", "."], "TS_V_token": ["arc", "1", "0"], "File": "arc3", "Func": "symbolic_operand", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33456, "Length": 39}
{"ground_truth": ["<s>", "static", "int", "arc600_corereg_hazard", "(", "rtx_insn", "*", "pred", ",", "rtx_insn", "*", "succ", ")", "{", "if", "(", "!", "TARGET_ARC600", ")", "return", "0", ";", "if", "(", "recog_memoized", "(", "succ", ")", "==", "CODE_FOR_doloop_end_i", "&&", "LABEL_P", "(", "prev_nonnote_insn", "(", "succ", ")", ")", ")", "return", "0", ";", "if", "(", "recog_memoized", "(", "succ", ")", "==", "CODE_FOR_doloop_begin_i", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "pred", ")", ")", "==", "SEQUENCE", ")", "pred", "=", "as_a", "<", "rtx_sequence", "*", ">", "(", "PATTERN", "(", "pred", ")", ")", "->", "insn", "(", "1", ")", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "succ", ")", ")", "==", "SEQUENCE", ")", "succ", "=", "as_a", "<", "rtx_sequence", "*", ">", "(", "PATTERN", "(", "succ", ")", ")", "->", "insn", "(", "0", ")", ";", "if", "(", "recog_memoized", "(", "pred", ")", "==", "CODE_FOR_mulsi_600", "||", "recog_memoized", "(", "pred", ")", "==", "CODE_FOR_umul_600", "||", "recog_memoized", "(", "pred", ")", "==", "CODE_FOR_mac_600", "||", "recog_memoized", "(", "pred", ")", "==", "CODE_FOR_mul64_600", "||", "recog_memoized", "(", "pred", ")", "==", "CODE_FOR_mac64_600", "||", "recog_memoized", "(", "pred", ")", "==", "CODE_FOR_umul64_600", "||", "recog_memoized", "(", "pred", ")", "==", "CODE_FOR_umac64_600", ")", "return", "0", ";", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "PATTERN", "(", "pred", ")", ",", "NONCONST", ")", "{", "const_rtx", "x", "=", "*", "iter", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "SET", ":", "case", "POST_INC", ":", "case", "POST_DEC", ":", "case", "PRE_INC", ":", "case", "PRE_DEC", ":", "break", ";", "default", ":", "continue", ";", "}", "rtx", "dest", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "REG_P", "(", "dest", ")", "&&", "REGNO", "(", "dest", ")", ">=", "32", "&&", "REGNO", "(", "dest", ")", "<", "61", "&&", "(", "refers_to_regno_p", "(", "REGNO", "(", "dest", ")", ",", "REGNO", "(", "dest", ")", "+", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "dest", ")", ")", "+", "3", ")", "/", "4U", ",", "PATTERN", "(", "succ", ")", ",", "0", ")", ")", ")", "return", "4", ";", "}", "return", "0", ";", "}", "</s>"], "natrual_language": ["Return", "length", "adjustment", "for", "INSN", ".", "For", "ARC600", ":", "A", "write", "to", "a", "core", "reg", "greater", "or", "equal", "to", "32", "must", "not", "be", "immediately", "followed", "by", "a", "use", ".", "Anticipate", "the", "length", "requirement", "to", "insert", "a", "nop", "between", "PRED", "and", "SUCC", "to", "prevent", "a", "hazard", "."], "TS_V_token": ["arc", "0", "0", "0", "1", "0", "0", "0", "32", "61", "3", "4U", "0", "4", "0"], "File": "arc4", "Func": "arc600_corereg_hazard", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33457, "Length": 299}
{"ground_truth": ["<s>", "int", "arc_address_cost", "(", "rtx", "addr", ",", "machine_mode", ",", "addr_space_t", ",", "bool", "speed", ")", "{", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "return", "speed", "||", "satisfies_constraint_Rcq", "(", "addr", ")", "?", "0", ":", "1", ";", "case", "PRE_INC", ":", "case", "PRE_DEC", ":", "case", "POST_INC", ":", "case", "POST_DEC", ":", "case", "PRE_MODIFY", ":", "case", "POST_MODIFY", ":", "return", "!", "speed", ";", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "case", "CONST", ":", "return", "COSTS_N_INSNS", "(", "1", ")", ";", "case", "PLUS", ":", "{", "register", "rtx", "plus0", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "register", "rtx", "plus1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "plus0", ")", "!=", "REG", "&&", "(", "GET_CODE", "(", "plus0", ")", "!=", "MULT", "||", "!", "CONST_INT_P", "(", "XEXP", "(", "plus0", ",", "1", ")", ")", "||", "(", "INTVAL", "(", "XEXP", "(", "plus0", ",", "1", ")", ")", "!=", "2", "&&", "INTVAL", "(", "XEXP", "(", "plus0", ",", "1", ")", ")", "!=", "4", ")", ")", ")", "break", ";", "switch", "(", "GET_CODE", "(", "plus1", ")", ")", "{", "case", "CONST_INT", ":", "return", "(", "!", "RTX_OK_FOR_OFFSET_P", "(", "SImode", ",", "plus1", ")", "?", "COSTS_N_INSNS", "(", "1", ")", ":", "speed", "?", "0", ":", "(", "satisfies_constraint_Rcq", "(", "plus0", ")", "&&", "satisfies_constraint_O", "(", "plus1", ")", ")", "?", "0", ":", "1", ")", ";", "case", "REG", ":", "return", "(", "speed", "<", "1", "?", "0", ":", "(", "satisfies_constraint_Rcq", "(", "plus0", ")", "&&", "satisfies_constraint_Rcq", "(", "plus1", ")", ")", "?", "0", ":", "1", ")", ";", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "return", "COSTS_N_INSNS", "(", "1", ")", ";", "default", ":", "break", ";", "}", "break", ";", "}", "default", ":", "break", ";", "}", "return", "4", ";", "}", "</s>"], "natrual_language": ["Provide", "the", "costs", "of", "an", "addressing", "mode", "that", "contains", "ADDR", ".", "If", "ADDR", "is", "not", "a", "valid", "address", ",", "its", "cost", "is", "irrelevant", "."], "TS_V_token": ["arc", "0", "1", "1", "0", "1", "1", "1", "2", "1", "4", "1", "0", "0", "1", "1", "0", "0", "1", "1", "4"], "File": "arc4", "Func": "arc_address_cost", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33458, "Length": 264}
{"ground_truth": ["<s>", "int", "arc_adjust_insn_length", "(", "rtx_insn", "*", "insn", ",", "int", "len", ",", "bool", ")", "{", "if", "(", "!", "INSN_P", "(", "insn", ")", ")", "return", "len", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SEQUENCE", ")", "return", "len", ";", "if", "(", "recog_memoized", "(", "insn", ")", "==", "CODE_FOR_doloop_end_i", ")", "{", "rtx_insn", "*", "prev", "=", "prev_nonnote_insn", "(", "insn", ")", ";", "return", "(", "(", "LABEL_P", "(", "prev", ")", "||", "(", "TARGET_ARC600", "&&", "(", "JUMP_P", "(", "prev", ")", "||", "CALL_P", "(", "prev", ")", "||", "(", "NONJUMP_INSN_P", "(", "prev", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "prev", ")", ")", "==", "SEQUENCE", ")", ")", ")", ")", "?", "len", "+", "4", ":", "len", ")", ";", "}", "if", "(", "TARGET_PAD_RETURN", "&&", "JUMP_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ADDR_VEC", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ADDR_DIFF_VEC", "&&", "get_attr_type", "(", "insn", ")", "==", "TYPE_RETURN", ")", "{", "rtx_insn", "*", "prev", "=", "prev_active_insn", "(", "insn", ")", ";", "if", "(", "!", "prev", "||", "!", "(", "prev", "=", "prev_active_insn", "(", "prev", ")", ")", "||", "(", "(", "NONJUMP_INSN_P", "(", "prev", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "prev", ")", ")", "==", "SEQUENCE", ")", "?", "CALL_ATTR", "(", "as_a", "<", "rtx_sequence", "*", ">", "(", "PATTERN", "(", "prev", ")", ")", "->", "insn", "(", "0", ")", ",", "NON_SIBCALL", ")", ":", "CALL_ATTR", "(", "prev", ",", "NON_SIBCALL", ")", ")", ")", "return", "len", "+", "4", ";", "}", "if", "(", "TARGET_ARC600", ")", "{", "rtx_insn", "*", "succ", "=", "next_real_insn", "(", "insn", ")", ";", "if", "(", "succ", "&&", "INSN_P", "(", "succ", ")", ")", "len", "+=", "arc600_corereg_hazard", "(", "insn", ",", "succ", ")", ";", "}", "extract_constrain_insn_cached", "(", "insn", ")", ";", "return", "len", ";", "}", "</s>"], "natrual_language": ["Return", "length", "adjustment", "for", "INSN", "."], "TS_V_token": ["arc", "4", "0", "4"], "File": "arc4", "Func": "arc_adjust_insn_length", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33459, "Length": 265}
{"ground_truth": ["<s>", "static", "int", "arc_arg_partial_bytes", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "bytes", "=", "(", "mode", "==", "BLKmode", "?", "int_size_in_bytes", "(", "type", ")", ":", "(", "int", ")", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "int", "words", "=", "(", "bytes", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "int", "arg_num", "=", "*", "cum", ";", "int", "ret", ";", "arg_num", "=", "ROUND_ADVANCE_CUM", "(", "arg_num", ",", "mode", ",", "type", ")", ";", "ret", "=", "GPR_REST_ARG_REGS", "(", "arg_num", ")", ";", "ret", "=", "(", "ret", ">=", "words", "?", "0", ":", "ret", "*", "UNITS_PER_WORD", ")", ";", "return", "ret", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_ARG_PARTIAL_BYTES", "."], "TS_V_token": ["arc", "1", "0"], "File": "arc4", "Func": "arc_arg_partial_bytes", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33460, "Length": 107}
{"ground_truth": ["<s>", "void", "arc_asm_output_aligned_decl_local", "(", "FILE", "*", "stream", ",", "tree", "decl", ",", "const", "char", "*", "name", ",", "unsigned", "HOST_WIDE_INT", "size", ",", "unsigned", "HOST_WIDE_INT", "align", ",", "unsigned", "HOST_WIDE_INT", "globalize_p", ")", "{", "int", "in_small_data", "=", "arc_in_small_data_p", "(", "decl", ")", ";", "if", "(", "in_small_data", ")", "switch_to_section", "(", "get_named_section", "(", "NULL", ",", "\".sbss\"", ",", "0", ")", ")", ";", "else", "switch_to_section", "(", "bss_section", ")", ";", "if", "(", "globalize_p", ")", "(", "*", "targetm", ".", "asm_out", ".", "globalize_label", ")", "(", "stream", ",", "name", ")", ";", "ASM_OUTPUT_ALIGN", "(", "stream", ",", "floor_log2", "(", "(", "align", ")", "/", "BITS_PER_UNIT", ")", ")", ";", "ASM_OUTPUT_TYPE_DIRECTIVE", "(", "stream", ",", "name", ",", "\"object\"", ")", ";", "ASM_OUTPUT_SIZE_DIRECTIVE", "(", "stream", ",", "name", ",", "size", ")", ";", "ASM_OUTPUT_LABEL", "(", "stream", ",", "name", ")", ";", "if", "(", "size", "!=", "0", ")", "ASM_OUTPUT_SKIP", "(", "stream", ",", "size", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "ASM_OUTPUT_ALIGNED_DECL_LOCAL", "."], "TS_V_token": ["arc", "\".sbss\"", "0", "\"object\"", "0"], "File": "arc4", "Func": "arc_asm_output_aligned_decl_local", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33461, "Length": 129}
{"ground_truth": ["<s>", "int", "arc_attr_type", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "NONJUMP_INSN_P", "(", "insn", ")", "?", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", ")", ":", "JUMP_P", "(", "insn", ")", "?", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "ADDR_VEC", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "ADDR_DIFF_VEC", ")", ":", "!", "CALL_P", "(", "insn", ")", ")", "return", "-", "1", ";", "return", "get_attr_type", "(", "insn", ")", ";", "}", "</s>"], "natrual_language": ["Return", "the", "integer", "value", "of", "the", "``", "type", "''", "attribute", "for", "INSN", ",", "or", "-1", "if", "INSN", "ca", "n't", "have", "attributes", "."], "TS_V_token": ["arc", "1"], "File": "arc4", "Func": "arc_attr_type", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33462, "Length": 81}
{"ground_truth": ["<s>", "static", "bool", "arc_can_eliminate", "(", "const", "int", "from", "ATTRIBUTE_UNUSED", ",", "const", "int", "to", ")", "{", "return", "to", "==", "FRAME_POINTER_REGNUM", "||", "!", "arc_frame_pointer_required", "(", ")", ";", "}", "</s>"], "natrual_language": ["Given", "FROM", "and", "TO", "register", "numbers", ",", "say", "whether", "this", "elimination", "is", "allowed", ".", "Frame", "pointer", "elimination", "is", "automatically", "handled", ".", "All", "eliminations", "are", "permissible", ".", "If", "we", "need", "a", "frame", "pointer", ",", "we", "must", "eliminate", "ARG_POINTER_REGNUM", "into", "FRAME_POINTER_REGNUM", "and", "not", "into", "STACK_POINTER_REGNUM", "."], "TS_V_token": ["arc"], "File": "arc4", "Func": "arc_can_eliminate", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33463, "Length": 25}
{"ground_truth": ["<s>", "static", "bool", "arc_can_follow_jump", "(", "const", "rtx_insn", "*", "follower", ",", "const", "rtx_insn", "*", "followee", ")", "{", "union", "{", "const", "rtx_insn", "*", "c", ";", "rtx_insn", "*", "r", ";", "}", "u", ";", "u", ".", "c", "=", "follower", ";", "if", "(", "CROSSING_JUMP_P", "(", "followee", ")", ")", "switch", "(", "get_attr_type", "(", "u", ".", "r", ")", ")", "{", "case", "TYPE_BRCC", ":", "case", "TYPE_BRCC_NO_DELAY_SLOT", ":", "return", "false", ";", "default", ":", "return", "true", ";", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["Without", "this", ",", "gcc.dg/tree-prof/bb-reorg.c", "fails", "to", "assemble", "when", "compiling", "with", "-O2", "-freorder-blocks-and-partition", "-fprofile-use", "-D_PROFILE_USE", ";", "delay", "branch", "scheduling", "then", "follows", "a", "crossing", "jump", "to", "redirect", "two", "breqs", "."], "TS_V_token": ["arc"], "File": "arc4", "Func": "arc_can_follow_jump", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33464, "Length": 71}
{"ground_truth": ["<s>", "static", "bool", "arc_can_use_doloop_p", "(", "const", "widest_int", "&", "iterations", ",", "const", "widest_int", "&", ",", "unsigned", "int", "loop_depth", ",", "bool", "entered_at_top", ")", "{", "if", "(", "loop_depth", ">", "1", ")", "return", "false", ";", "if", "(", "TARGET_ARC700", "&&", "!", "entered_at_top", "&&", "wi", "::", "gtu_p", "(", "iterations", ",", "0", ")", "&&", "wi", "::", "leu_p", "(", "iterations", ",", "flag_pic", "?", "6", ":", "3", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_CAN_USE_DOLOOP_P", "."], "TS_V_token": ["arc", "1", "0", "6", "3"], "File": "arc4", "Func": "arc_can_use_doloop_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33465, "Length": 66}
{"ground_truth": ["<s>", "static", "void", "arc_ccfsm_post_advance", "(", "rtx_insn", "*", "insn", ",", "struct", "arc_ccfsm", "*", "state", ")", "{", "enum", "attr_type", "type", ";", "if", "(", "LABEL_P", "(", "insn", ")", ")", "arc_ccfsm_at_label", "(", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "insn", ")", ",", "state", ")", ";", "else", "if", "(", "JUMP_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ADDR_VEC", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ADDR_DIFF_VEC", "&&", "(", "(", "type", "=", "get_attr_type", "(", "insn", ")", ")", "==", "TYPE_BRANCH", "||", "(", "type", "==", "TYPE_UNCOND_BRANCH", "&&", "ARC_CCFSM_BRANCH_DELETED_P", "(", "state", ")", ")", ")", ")", "{", "if", "(", "ARC_CCFSM_BRANCH_DELETED_P", "(", "state", ")", ")", "ARC_CCFSM_RECORD_BRANCH_DELETED", "(", "state", ")", ";", "else", "{", "rtx", "src", "=", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ";", "arc_ccfsm_record_condition", "(", "XEXP", "(", "src", ",", "0", ")", ",", "XEXP", "(", "src", ",", "1", ")", "==", "pc_rtx", ",", "insn", ",", "state", ")", ";", "}", "}", "else", "if", "(", "arc_ccfsm_current", ".", "state", "==", "5", ")", "arc_ccfsm_current", ".", "state", "=", "0", ";", "}", "</s>"], "natrual_language": ["Update", "*", "STATE", "as", "we", "would", "when", "we", "emit", "INSN", "."], "TS_V_token": ["arc", "\"L\"", "0", "1", "5", "0"], "File": "arc4", "Func": "arc_ccfsm_post_advance", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33466, "Length": 156}
{"ground_truth": ["<s>", "unsigned", "int", "arc_compute_frame_size", "(", "int", "size", ")", "{", "int", "regno", ";", "unsigned", "int", "total_size", ",", "var_size", ",", "args_size", ",", "pretend_size", ",", "extra_size", ";", "unsigned", "int", "reg_size", ",", "reg_offset", ";", "unsigned", "int", "gmask", ";", "enum", "arc_function_type", "fn_type", ";", "int", "interrupt_p", ";", "struct", "arc_frame_info", "*", "frame_info", "=", "&", "cfun", "->", "machine", "->", "frame_info", ";", "size", "=", "ARC_STACK_ALIGN", "(", "size", ")", ";", "var_size", "=", "size", ";", "args_size", "=", "crtl", "->", "outgoing_args_size", ";", "reg_size", "=", "0", ";", "gmask", "=", "0", ";", "fn_type", "=", "arc_compute_function_type", "(", "cfun", ")", ";", "interrupt_p", "=", "ARC_INTERRUPT_P", "(", "fn_type", ")", ";", "for", "(", "regno", "=", "0", ";", "regno", "<=", "31", ";", "regno", "++", ")", "{", "if", "(", "MUST_SAVE_REGISTER", "(", "regno", ",", "interrupt_p", ")", ")", "{", "reg_size", "+=", "UNITS_PER_WORD", ";", "gmask", "|=", "1", "<<", "regno", ";", "}", "}", "frame_info", "->", "save_return_addr", "=", "(", "!", "crtl", "->", "is_leaf", "||", "df_regs_ever_live_p", "(", "RETURN_ADDR_REGNUM", ")", ")", ";", "if", "(", "optimize_size", "&&", "!", "TARGET_NO_MILLICODE_THUNK_SET", ")", "{", "if", "(", "arc_compute_millicode_save_restore_regs", "(", "gmask", ",", "frame_info", ")", ")", "frame_info", "->", "save_return_addr", "=", "true", ";", "}", "extra_size", "=", "0", ";", "if", "(", "MUST_SAVE_RETURN_ADDR", ")", "extra_size", "=", "4", ";", "if", "(", "frame_pointer_needed", ")", "extra_size", "+=", "4", ";", "pretend_size", "=", "crtl", "->", "args", ".", "pretend_args_size", ";", "{", "unsigned", "int", "extra_plus_reg_size", ";", "unsigned", "int", "extra_plus_reg_size_aligned", ";", "extra_plus_reg_size", "=", "extra_size", "+", "reg_size", ";", "extra_plus_reg_size_aligned", "=", "ARC_STACK_ALIGN", "(", "extra_plus_reg_size", ")", ";", "reg_size", "=", "extra_plus_reg_size_aligned", "-", "extra_size", ";", "}", "total_size", "=", "var_size", "+", "args_size", "+", "extra_size", "+", "pretend_size", "+", "reg_size", ";", "total_size", "=", "ARC_STACK_ALIGN", "(", "total_size", ")", ";", "reg_offset", "=", "(", "total_size", "-", "(", "pretend_size", "+", "reg_size", "+", "extra_size", ")", "+", "(", "frame_pointer_needed", "?", "4", ":", "0", ")", ")", ";", "frame_info", "->", "total_size", "=", "total_size", ";", "frame_info", "->", "extra_size", "=", "extra_size", ";", "frame_info", "->", "pretend_size", "=", "pretend_size", ";", "frame_info", "->", "var_size", "=", "var_size", ";", "frame_info", "->", "args_size", "=", "args_size", ";", "frame_info", "->", "reg_size", "=", "reg_size", ";", "frame_info", "->", "reg_offset", "=", "reg_offset", ";", "frame_info", "->", "gmask", "=", "gmask", ";", "frame_info", "->", "initialized", "=", "reload_completed", ";", "return", "total_size", ";", "}", "</s>"], "natrual_language": ["Return", "the", "bytes", "needed", "to", "compute", "the", "frame", "pointer", "from", "the", "current", "stack", "pointer", ".", "SIZE", "is", "the", "size", "needed", "for", "local", "variables", "."], "TS_V_token": ["arc", "0", "0", "0", "31", "1", "0", "4", "4", "4", "0"], "File": "arc4", "Func": "arc_compute_frame_size", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33467, "Length": 323}
{"ground_truth": ["<s>", "enum", "arc_function_type", "arc_compute_function_type", "(", "struct", "function", "*", "fun", ")", "{", "tree", "decl", "=", "fun", "->", "decl", ";", "tree", "a", ";", "enum", "arc_function_type", "fn_type", "=", "fun", "->", "machine", "->", "fn_type", ";", "if", "(", "fn_type", "!=", "ARC_FUNCTION_UNKNOWN", ")", "return", "fn_type", ";", "fn_type", "=", "ARC_FUNCTION_NORMAL", ";", "for", "(", "a", "=", "DECL_ATTRIBUTES", "(", "decl", ")", ";", "a", ";", "a", "=", "TREE_CHAIN", "(", "a", ")", ")", "{", "tree", "name", "=", "TREE_PURPOSE", "(", "a", ")", ",", "args", "=", "TREE_VALUE", "(", "a", ")", ";", "if", "(", "name", "==", "get_identifier", "(", "\"interrupt\"", ")", "&&", "list_length", "(", "args", ")", "==", "1", "&&", "TREE_CODE", "(", "TREE_VALUE", "(", "args", ")", ")", "==", "STRING_CST", ")", "{", "tree", "value", "=", "TREE_VALUE", "(", "args", ")", ";", "if", "(", "!", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink1\"", ")", ")", "fn_type", "=", "ARC_FUNCTION_ILINK1", ";", "else", "if", "(", "!", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink2\"", ")", ")", "fn_type", "=", "ARC_FUNCTION_ILINK2", ";", "else", "gcc_unreachable", "(", ")", ";", "break", ";", "}", "}", "return", "fun", "->", "machine", "->", "fn_type", "=", "fn_type", ";", "}", "</s>"], "natrual_language": ["Type", "of", "function", "DECL", ".", "The", "result", "is", "cached", ".", "To", "reset", "the", "cache", "at", "the", "end", "of", "a", "function", ",", "call", "with", "DECL", "=", "NULL_TREE", "."], "TS_V_token": ["arc", "\"interrupt\"", "1", "\"ilink1\"", "\"ilink2\""], "File": "arc4", "Func": "arc_compute_function_type", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33468, "Length": 166}
{"ground_truth": ["<s>", "static", "int", "arc_compute_millicode_save_restore_regs", "(", "unsigned", "int", "gmask", ",", "struct", "arc_frame_info", "*", "frame", ")", "{", "int", "regno", ";", "int", "start_reg", "=", "13", ",", "end_reg", "=", "25", ";", "for", "(", "regno", "=", "start_reg", ";", "regno", "<=", "end_reg", "&&", "(", "gmask", "&", "(", "1L", "<<", "regno", ")", ")", ";", ")", "regno", "++", ";", "end_reg", "=", "regno", "-", "1", ";", "if", "(", "regno", "-", "start_reg", ">=", "3", "-", "(", "crtl", "->", "is_leaf", "==", "0", ")", ")", "{", "frame", "->", "millicode_start_reg", "=", "13", ";", "frame", "->", "millicode_end_reg", "=", "regno", "-", "1", ";", "return", "1", ";", "}", "return", "0", ";", "}", "</s>"], "natrual_language": ["Return", "non-zero", "if", "there", "are", "registers", "to", "be", "saved", "or", "loaded", "using", "millicode", "thunks", ".", "We", "can", "only", "use", "consecutive", "sequences", "starting", "with", "r13", ",", "and", "not", "going", "beyond", "r25", ".", "GMASK", "is", "a", "bitmask", "of", "registers", "to", "save", ".", "This", "function", "sets", "FRAME-", ">", "millicod_start_reg", "..", "FRAME-", ">", "millicode_end_reg", "to", "the", "range", "of", "registers", "to", "be", "saved", "/", "restored", "with", "a", "millicode", "call", "."], "TS_V_token": ["arc", "13", "25", "1L", "1", "3", "0", "13", "1", "1", "0"], "File": "arc4", "Func": "arc_compute_millicode_save_restore_regs", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33469, "Length": 95}
{"ground_truth": ["<s>", "int", "arc_decl_pretend_args", "(", "tree", "decl", ")", "{", "gcc_assert", "(", "decl", "==", "current_function_decl", ")", ";", "return", "crtl", "->", "args", ".", "pretend_args_size", ";", "}", "</s>"], "natrual_language": ["Return", "the", "size", "of", "the", "pretend", "args", "for", "DECL", "."], "TS_V_token": ["arc"], "File": "arc4", "Func": "arc_decl_pretend_args", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33470, "Length": 22}
{"ground_truth": ["<s>", "static", "void", "arc_encode_section_info", "(", "tree", "decl", ",", "rtx", "rtl", ",", "int", "first", ")", "{", "default_encode_section_info", "(", "decl", ",", "rtl", ",", "first", ")", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "{", "rtx", "symbol", "=", "XEXP", "(", "rtl", ",", "0", ")", ";", "int", "flags", "=", "SYMBOL_REF_FLAGS", "(", "symbol", ")", ";", "tree", "attr", "=", "(", "TREE_TYPE", "(", "decl", ")", "!=", "error_mark_node", "?", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "decl", ")", ")", ":", "NULL_TREE", ")", ";", "tree", "long_call_attr", "=", "lookup_attribute", "(", "\"long_call\"", ",", "attr", ")", ";", "tree", "medium_call_attr", "=", "lookup_attribute", "(", "\"medium_call\"", ",", "attr", ")", ";", "tree", "short_call_attr", "=", "lookup_attribute", "(", "\"short_call\"", ",", "attr", ")", ";", "if", "(", "long_call_attr", "!=", "NULL_TREE", ")", "flags", "|=", "SYMBOL_FLAG_LONG_CALL", ";", "else", "if", "(", "medium_call_attr", "!=", "NULL_TREE", ")", "flags", "|=", "SYMBOL_FLAG_MEDIUM_CALL", ";", "else", "if", "(", "short_call_attr", "!=", "NULL_TREE", ")", "flags", "|=", "SYMBOL_FLAG_SHORT_CALL", ";", "SYMBOL_REF_FLAGS", "(", "symbol", ")", "=", "flags", ";", "}", "}", "</s>"], "natrual_language": ["Implement", "TARGET_ENCODE_SECTION_INFO", "hook", "."], "TS_V_token": ["arc", "0", "\"long_call\"", "\"medium_call\"", "\"short_call\""], "File": "arc4", "Func": "arc_encode_section_info", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33471, "Length": 144}
{"ground_truth": ["<s>", "bool", "arc_epilogue_uses", "(", "int", "regno", ")", "{", "if", "(", "reload_completed", ")", "{", "if", "(", "ARC_INTERRUPT_P", "(", "cfun", "->", "machine", "->", "fn_type", ")", ")", "{", "if", "(", "!", "fixed_regs", "[", "regno", "]", ")", "return", "true", ";", "return", "regno", "==", "arc_return_address_regs", "[", "cfun", "->", "machine", "->", "fn_type", "]", ";", "}", "else", "return", "regno", "==", "RETURN_ADDR_REGNUM", ";", "}", "else", "return", "regno", "==", "arc_return_address_regs", "[", "arc_compute_function_type", "(", "cfun", ")", "]", ";", "}", "</s>"], "natrual_language": ["Implement", "EPILOGUE__USES", ".", "Return", "true", "if", "REGNO", "should", "be", "added", "to", "the", "deemed", "uses", "of", "the", "epilogue", ".", "We", "use", "the", "return", "address", "arc_return_address_regs", "[", "arc_compute_function_type", "(", "cfun", ")", "]", ".", "But", "also", ",", "we", "have", "to", "make", "sure", "all", "the", "register", "restore", "instructions", "are", "known", "to", "be", "live", "in", "interrupt", "functions", ",", "plus", "the", "blink", "register", "if", "it", "is", "clobbered", "by", "the", "isr", "."], "TS_V_token": ["arc"], "File": "arc4", "Func": "arc_epilogue_uses", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33472, "Length": 68}
{"ground_truth": ["<s>", "bool", "arc_expand_movmem", "(", "rtx", "*", "operands", ")", "{", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "rtx", "dst_addr", ",", "src_addr", ";", "HOST_WIDE_INT", "size", ";", "int", "align", "=", "INTVAL", "(", "operands", "[", "3", "]", ")", ";", "unsigned", "n_pieces", ";", "int", "piece", "=", "align", ";", "rtx", "store", "[", "2", "]", ";", "rtx", "tmpx", "[", "2", "]", ";", "int", "i", ";", "if", "(", "!", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", ")", "return", "false", ";", "size", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "align", ">=", "4", ")", "n_pieces", "=", "(", "size", "+", "2", ")", "/", "4U", "+", "(", "size", "&", "1", ")", ";", "else", "if", "(", "align", "==", "2", ")", "n_pieces", "=", "(", "size", "+", "1", ")", "/", "2U", ";", "else", "n_pieces", "=", "size", ";", "if", "(", "n_pieces", ">=", "(", "unsigned", "int", ")", "(", "optimize_size", "?", "3", ":", "15", ")", ")", "return", "false", ";", "if", "(", "piece", ">", "4", ")", "piece", "=", "4", ";", "dst_addr", "=", "force_offsettable", "(", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ",", "size", ",", "0", ")", ";", "src_addr", "=", "force_offsettable", "(", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ",", "size", ",", "0", ")", ";", "store", "[", "0", "]", "=", "store", "[", "1", "]", "=", "NULL_RTX", ";", "tmpx", "[", "0", "]", "=", "tmpx", "[", "1", "]", "=", "NULL_RTX", ";", "for", "(", "i", "=", "0", ";", "size", ">", "0", ";", "i", "^=", "1", ",", "size", "-=", "piece", ")", "{", "rtx", "tmp", ";", "machine_mode", "mode", ";", "if", "(", "piece", ">", "size", ")", "piece", "=", "size", "&", "-", "size", ";", "mode", "=", "smallest_mode_for_size", "(", "piece", "*", "BITS_PER_UNIT", ",", "MODE_INT", ")", ";", "if", "(", "0", "&&", "tmpx", "[", "i", "]", "&&", "GET_MODE", "(", "tmpx", "[", "i", "]", ")", "==", "mode", ")", "tmp", "=", "tmpx", "[", "i", "]", ";", "else", "tmpx", "[", "i", "]", "=", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "dst_addr", "=", "force_offsettable", "(", "dst_addr", ",", "piece", ",", "1", ")", ";", "src_addr", "=", "force_offsettable", "(", "src_addr", ",", "piece", ",", "1", ")", ";", "if", "(", "store", "[", "i", "]", ")", "emit_insn", "(", "store", "[", "i", "]", ")", ";", "emit_move_insn", "(", "tmp", ",", "change_address", "(", "src", ",", "mode", ",", "src_addr", ")", ")", ";", "store", "[", "i", "]", "=", "gen_move_insn", "(", "change_address", "(", "dst", ",", "mode", ",", "dst_addr", ")", ",", "tmp", ")", ";", "dst_addr", "=", "plus_constant", "(", "Pmode", ",", "dst_addr", ",", "piece", ")", ";", "src_addr", "=", "plus_constant", "(", "Pmode", ",", "src_addr", ",", "piece", ")", ";", "}", "if", "(", "store", "[", "i", "]", ")", "emit_insn", "(", "store", "[", "i", "]", ")", ";", "if", "(", "store", "[", "i", "^", "1", "]", ")", "emit_insn", "(", "store", "[", "i", "^", "1", "]", ")", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Like", "move_by_pieces", ",", "but", "take", "account", "of", "load", "latency", ",", "and", "actual", "offset", "ranges", ".", "Return", "true", "on", "success", "."], "TS_V_token": ["arc", "0", "1", "3", "2", "2", "2", "2", "4", "2", "4U", "1", "2", "1", "2U", "3", "15", "4", "4", "0", "0", "0", "1", "0", "0", "0", "1", "0", "1", "0", "0", "1", "0", "1", "1", "1", "1"], "File": "arc4", "Func": "arc_expand_movmem", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33473, "Length": 444}
{"ground_truth": ["<s>", "void", "arc_expand_prologue", "(", "void", ")", "{", "int", "size", "=", "get_frame_size", "(", ")", ";", "unsigned", "int", "gmask", "=", "cfun", "->", "machine", "->", "frame_info", ".", "gmask", ";", "unsigned", "int", "frame_size_to_allocate", ";", "int", "first_offset", "=", "0", ";", "size", "=", "ARC_STACK_ALIGN", "(", "size", ")", ";", "size", "=", "(", "!", "cfun", "->", "machine", "->", "frame_info", ".", "initialized", "?", "arc_compute_frame_size", "(", "size", ")", ":", "cfun", "->", "machine", "->", "frame_info", ".", "total_size", ")", ";", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "size", ";", "frame_size_to_allocate", "=", "size", ";", "gcc_assert", "(", "!", "(", "size", "==", "0", "&&", "gmask", ")", ")", ";", "if", "(", "cfun", "->", "machine", "->", "frame_info", ".", "pretend_size", "!=", "0", ")", "{", "gcc_assert", "(", "cfun", "->", "machine", "->", "frame_info", ".", "pretend_size", "<=", "32", ")", ";", "frame_stack_add", "(", "-", "(", "HOST_WIDE_INT", ")", "cfun", "->", "machine", "->", "frame_info", ".", "pretend_size", ")", ";", "frame_size_to_allocate", "-=", "cfun", "->", "machine", "->", "frame_info", ".", "pretend_size", ";", "}", "if", "(", "MUST_SAVE_RETURN_ADDR", ")", "{", "rtx", "ra", "=", "gen_rtx_REG", "(", "SImode", ",", "RETURN_ADDR_REGNUM", ")", ";", "rtx", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "gen_rtx_PRE_DEC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ")", ";", "frame_move_inc", "(", "mem", ",", "ra", ",", "stack_pointer_rtx", ",", "0", ")", ";", "frame_size_to_allocate", "-=", "UNITS_PER_WORD", ";", "}", "if", "(", "cfun", "->", "machine", "->", "frame_info", ".", "reg_size", ")", "{", "first_offset", "=", "-", "cfun", "->", "machine", "->", "frame_info", ".", "reg_size", ";", "arc_save_restore", "(", "stack_pointer_rtx", ",", "gmask", ",", "0", ",", "&", "first_offset", ")", ";", "frame_size_to_allocate", "-=", "cfun", "->", "machine", "->", "frame_info", ".", "reg_size", ";", "}", "if", "(", "frame_pointer_needed", ")", "{", "rtx", "addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "UNITS_PER_WORD", "+", "first_offset", ")", ")", ";", "rtx", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "gen_rtx_PRE_MODIFY", "(", "Pmode", ",", "stack_pointer_rtx", ",", "addr", ")", ")", ";", "frame_move_inc", "(", "mem", ",", "frame_pointer_rtx", ",", "stack_pointer_rtx", ",", "0", ")", ";", "frame_size_to_allocate", "-=", "UNITS_PER_WORD", ";", "first_offset", "=", "0", ";", "frame_move", "(", "frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ";", "}", "frame_size_to_allocate", "-=", "first_offset", ";", "if", "(", "frame_size_to_allocate", ">", "0", ")", "frame_stack_add", "(", "(", "HOST_WIDE_INT", ")", "0", "-", "frame_size_to_allocate", ")", ";", "if", "(", "crtl", "->", "uses_pic_offset_table", ")", "arc_finalize_pic", "(", ")", ";", "}", "</s>"], "natrual_language": ["Set", "up", "the", "stack", "and", "frame", "pointer", "(", "if", "desired", ")", "for", "the", "function", "."], "TS_V_token": ["arc", "0", "0", "0", "32", "0", "0", "0", "0", "0", "0"], "File": "arc4", "Func": "arc_expand_prologue", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33474, "Length": 332}
{"ground_truth": ["<s>", "static", "void", "arc_finalize_pic", "(", "void", ")", "{", "rtx", "pat", ";", "rtx", "baseptr_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "PIC_OFFSET_TABLE_REGNUM", ")", ";", "if", "(", "crtl", "->", "uses_pic_offset_table", "==", "0", ")", "return", ";", "gcc_assert", "(", "flag_pic", "!=", "0", ")", ";", "pat", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"_DYNAMIC\"", ")", ";", "pat", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "pat", ")", ",", "ARC_UNSPEC_GOT", ")", ";", "pat", "=", "gen_rtx_CONST", "(", "Pmode", ",", "pat", ")", ";", "pat", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "baseptr_rtx", ",", "pat", ")", ";", "emit_insn", "(", "pat", ")", ";", "}", "</s>"], "natrual_language": ["If", "the", "function", "has", "any", "GOTOFF", "relocations", ",", "then", "the", "GOTBASE", "register", "has", "to", "be", "setup", "in", "the", "prologue", "The", "instruction", "needed", "at", "the", "function", "start", "for", "setting", "up", "the", "GOTBASE", "register", "is", "add", "rdest", ",", "pc", ",", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "The", "rtl", "to", "be", "emitted", "for", "this", "should", "be", ":", "set", "(", "reg", "basereg", ")", "(", "plus", "(", "reg", "pc", ")", "(", "const", "(", "unspec", "(", "symref", "_DYNAMIC", ")", "3", ")", ")", ")", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--"], "TS_V_token": ["arc", "0", "0", "\"_DYNAMIC\"", "1"], "File": "arc4", "Func": "arc_finalize_pic", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33475, "Length": 88}
{"ground_truth": ["<s>", "void", "arc_final_prescan_insn", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "opvec", "ATTRIBUTE_UNUSED", ",", "int", "noperands", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_DUMPISIZE", ")", "fprintf", "(", "asm_out_file", ",", "\"\\n; at %04x\\n\"", ",", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", ")", ";", "if", "(", "PREV_INSN", "(", "insn", ")", "&&", "PREV_INSN", "(", "NEXT_INSN", "(", "insn", ")", ")", "==", "insn", "&&", "arc_hazard", "(", "prev_real_insn", "(", "insn", ")", ",", "insn", ")", ")", "{", "current_output_insn", "=", "emit_insn_before", "(", "gen_nop", "(", ")", ",", "NEXT_INSN", "(", "PREV_INSN", "(", "insn", ")", ")", ")", ";", "final_scan_insn", "(", "current_output_insn", ",", "asm_out_file", ",", "optimize", ",", "1", ",", "NULL", ")", ";", "current_output_insn", "=", "insn", ";", "}", "extract_constrain_insn_cached", "(", "insn", ")", ";", "if", "(", "!", "cfun", "->", "machine", "->", "prescan_initialized", ")", "{", "memset", "(", "&", "arc_ccfsm_current", ",", "0", ",", "sizeof", "arc_ccfsm_current", ")", ";", "cfun", "->", "machine", "->", "prescan_initialized", "=", "1", ";", "}", "arc_ccfsm_advance", "(", "insn", ",", "&", "arc_ccfsm_current", ")", ";", "cfun", "->", "machine", "->", "size_reason", "=", "0", ";", "}", "</s>"], "natrual_language": ["The", "state", "of", "the", "fsm", "controlling", "condition", "codes", "are", ":", "0", ":", "normal", ",", "do", "nothing", "special", "1", ":", "do", "n't", "output", "this", "insn", "2", ":", "do", "n't", "output", "this", "insn", "3", ":", "make", "insns", "conditional", "4", ":", "make", "insns", "conditional", "State", "transitions", "(", "state-", ">", "state", "by", "whom", ",", "under", "what", "condition", ")", ":", "0", "-", ">", "1", "final_prescan_insn", ",", "if", "insn", "is", "conditional", "branch", "0", "-", ">", "2", "final_prescan_insn", ",", "if", "the", "`", "target", "'", "is", "an", "unconditional", "branch", "1", "-", ">", "3", "branch", "patterns", ",", "after", "having", "not", "output", "the", "conditional", "branch", "2", "-", ">", "4", "branch", "patterns", ",", "after", "having", "not", "output", "the", "conditional", "branch", "3", "-", ">", "0", "(", "*", "targetm.asm_out.internal_label", ")", ",", "if", "the", "`", "target", "'", "label", "is", "reached", "(", "the", "target", "label", "has", "CODE_LABEL_NUMBER", "equal", "to", "arc_ccfsm_target_label", ")", ".", "4", "-", ">", "0", "final_prescan_insn", ",", "if", "`", "target", "'", "unconditional", "branch", "is", "reached", "If", "the", "jump", "clobbers", "the", "conditions", "then", "we", "use", "states", "2", "and", "4", ".", "A", "similar", "thing", "can", "be", "done", "with", "conditional", "return", "insns", ".", "We", "also", "handle", "separating", "branches", "from", "sets", "of", "the", "condition", "code", ".", "This", "is", "done", "here", "because", "knowledge", "of", "the", "ccfsm", "state", "is", "required", ",", "we", "may", "not", "be", "outputting", "the", "branch", "."], "TS_V_token": ["arc", "\"\\n; at %04x\\n\"", "1", "0", "1", "0"], "File": "arc4", "Func": "arc_final_prescan_insn", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33476, "Length": 151}
{"ground_truth": ["<s>", "static", "rtx", "arc_function_arg", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "arg_num", "=", "*", "cum", ";", "rtx", "ret", ";", "const", "char", "*", "debstr", "ATTRIBUTE_UNUSED", ";", "arg_num", "=", "ROUND_ADVANCE_CUM", "(", "arg_num", ",", "mode", ",", "type", ")", ";", "if", "(", "mode", "==", "VOIDmode", ")", "{", "ret", "=", "const0_rtx", ";", "debstr", "=", "\"<0>\"", ";", "}", "else", "if", "(", "GPR_REST_ARG_REGS", "(", "arg_num", ")", ">", "0", ")", "{", "ret", "=", "gen_rtx_REG", "(", "mode", ",", "arg_num", ")", ";", "debstr", "=", "reg_names", "[", "arg_num", "]", ";", "}", "else", "{", "ret", "=", "NULL_RTX", ";", "debstr", "=", "\"memory\"", ";", "}", "return", "ret", ";", "}", "</s>"], "natrual_language": ["On", "the", "ARC", "the", "first", "MAX_ARC_PARM_REGS", "args", "are", "normally", "in", "registers", "and", "the", "rest", "are", "pushed", "."], "TS_V_token": ["arc", "\"<0>\"", "0", "\"memory\""], "File": "arc4", "Func": "arc_function_arg", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33477, "Length": 113}
{"ground_truth": ["<s>", "static", "void", "arc_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "bytes", "=", "(", "mode", "==", "BLKmode", "?", "int_size_in_bytes", "(", "type", ")", ":", "(", "int", ")", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "int", "words", "=", "(", "bytes", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "int", "i", ";", "if", "(", "words", ")", "*", "cum", "=", "ROUND_ADVANCE_CUM", "(", "*", "cum", ",", "mode", ",", "type", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "words", ";", "i", "++", ")", "*", "cum", "=", "ARC_NEXT_ARG_REG", "(", "*", "cum", ")", ";", "}", "</s>"], "natrual_language": ["For", "the", "ARC", ":", "the", "cum", "set", "here", "is", "passed", "on", "to", "function_arg", "where", "we", "look", "at", "its", "value", "and", "say", "which", "reg", "to", "use", ".", "Strategy", ":", "advance", "the", "regnumber", "here", "till", "we", "run", "out", "of", "arg", "regs", ",", "then", "set", "*", "cum", "to", "last", "reg", ".", "In", "function_arg", ",", "since", "*", "cum", ">", "last", "arg", "reg", "we", "would", "return", "0", "and", "thus", "the", "arg", "will", "end", "up", "on", "the", "stack", ".", "For", "straddling", "args", "of", "course", "function_arg_partial_nregs", "will", "come", "into", "play", "."], "TS_V_token": ["arc", "1", "0"], "File": "arc4", "Func": "arc_function_arg_advance", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33478, "Length": 105}
{"ground_truth": ["<s>", "static", "bool", "arc_function_ok_for_sibcall", "(", "tree", "decl", "ATTRIBUTE_UNUSED", ",", "tree", "exp", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "ARC_INTERRUPT_P", "(", "arc_compute_function_type", "(", "cfun", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "it", "is", "ok", "to", "make", "a", "tail-call", "to", "DECL", "."], "TS_V_token": ["arc"], "File": "arc4", "Func": "arc_function_ok_for_sibcall", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33479, "Length": 30}
{"ground_truth": ["<s>", "int", "arc_get_unalign", "(", "void", ")", "{", "return", "cfun", "->", "machine", "->", "unalign", ";", "}", "</s>"], "natrual_language": ["Accessor", "functions", "for", "cfun-", ">", "machine-", ">", "unalign", "."], "TS_V_token": ["arc"], "File": "arc4", "Func": "arc_get_unalign", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33480, "Length": 14}
{"ground_truth": ["<s>", "static", "tree", "arc_handle_interrupt_attribute", "(", "tree", "*", ",", "tree", "name", ",", "tree", "args", ",", "int", ",", "bool", "*", "no_add_attrs", ")", "{", "gcc_assert", "(", "args", ")", ";", "tree", "value", "=", "TREE_VALUE", "(", "args", ")", ";", "if", "(", "TREE_CODE", "(", "value", ")", "!=", "STRING_CST", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"argument of %qE attribute is not a string constant\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink1\"", ")", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink2\"", ")", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"argument of %qE attribute is not \\\"ilink1\\\" or \\\"ilink2\\\"\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>"], "natrual_language": ["Handle", "an", "``", "interrupt", "''", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "."], "TS_V_token": ["arc", "\"argument of %qE attribute is not a string constant\"", "\"ilink1\"", "\"ilink2\"", "\"argument of %qE attribute is not \\\"ilink1\\\" or \\\"ilink2\\\"\""], "File": "arc4", "Func": "arc_handle_interrupt_attribute", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33481, "Length": 101}
{"ground_truth": ["<s>", "int", "arc_hazard", "(", "rtx_insn", "*", "pred", ",", "rtx_insn", "*", "succ", ")", "{", "if", "(", "!", "TARGET_ARC600", ")", "return", "0", ";", "if", "(", "!", "pred", "||", "!", "INSN_P", "(", "pred", ")", "||", "!", "succ", "||", "!", "INSN_P", "(", "succ", ")", ")", "return", "0", ";", "if", "(", "recog_memoized", "(", "succ", ")", "==", "CODE_FOR_doloop_end_i", "&&", "(", "JUMP_P", "(", "pred", ")", "||", "CALL_P", "(", "pred", ")", "||", "GET_CODE", "(", "PATTERN", "(", "pred", ")", ")", "==", "SEQUENCE", ")", ")", "return", "4", ";", "return", "arc600_corereg_hazard", "(", "pred", ",", "succ", ")", ";", "}", "</s>"], "natrual_language": ["For", "ARC600", ":", "A", "write", "to", "a", "core", "reg", "greater", "or", "equal", "to", "32", "must", "not", "be", "immediately", "followed", "by", "a", "use", ".", "Anticipate", "the", "length", "requirement", "to", "insert", "a", "nop", "between", "PRED", "and", "SUCC", "to", "prevent", "a", "hazard", "."], "TS_V_token": ["arc", "0", "0", "4"], "File": "arc4", "Func": "arc_hazard", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33482, "Length": 86}
{"ground_truth": ["<s>", "void", "arc_init", "(", "void", ")", "{", "enum", "attr_tune", "tune_dflt", "=", "TUNE_NONE", ";", "if", "(", "TARGET_A5", ")", "{", "arc_cpu_string", "=", "\"A5\"", ";", "}", "else", "if", "(", "TARGET_ARC600", ")", "{", "arc_cpu_string", "=", "\"ARC600\"", ";", "tune_dflt", "=", "TUNE_ARC600", ";", "}", "else", "if", "(", "TARGET_ARC601", ")", "{", "arc_cpu_string", "=", "\"ARC601\"", ";", "tune_dflt", "=", "TUNE_ARC600", ";", "}", "else", "if", "(", "TARGET_ARC700", ")", "{", "arc_cpu_string", "=", "\"ARC700\"", ";", "tune_dflt", "=", "TUNE_ARC700_4_2_STD", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "arc_tune", "==", "TUNE_NONE", ")", "arc_tune", "=", "tune_dflt", ";", "if", "(", "arc_multcost", "<", "0", ")", "switch", "(", "arc_tune", ")", "{", "case", "TUNE_ARC700_4_2_STD", ":", "arc_multcost", "=", "COSTS_N_INSNS", "(", "4", ")", ";", "if", "(", "TARGET_NOMPY_SET", ")", "arc_multcost", "=", "COSTS_N_INSNS", "(", "30", ")", ";", "break", ";", "case", "TUNE_ARC700_4_2_XMAC", ":", "arc_multcost", "=", "COSTS_N_INSNS", "(", "3", ")", ";", "if", "(", "TARGET_NOMPY_SET", ")", "arc_multcost", "=", "COSTS_N_INSNS", "(", "30", ")", ";", "break", ";", "case", "TUNE_ARC600", ":", "if", "(", "TARGET_MUL64_SET", ")", "{", "arc_multcost", "=", "COSTS_N_INSNS", "(", "4", ")", ";", "break", ";", "}", "default", ":", "arc_multcost", "=", "COSTS_N_INSNS", "(", "30", ")", ";", "break", ";", "}", "if", "(", "TARGET_MUL64_SET", "&&", "TARGET_ARC700", ")", "error", "(", "\"-mmul64 not supported for ARC700\"", ")", ";", "if", "(", "TARGET_NOMPY_SET", "&&", "!", "TARGET_ARC700", ")", "error", "(", "\"-mno-mpy supported only for ARC700\"", ")", ";", "if", "(", "TARGET_MULMAC_32BY16_SET", "&&", "!", "(", "TARGET_ARC600", "||", "TARGET_ARC601", ")", ")", "error", "(", "\"-mmul32x16 supported only for ARC600 or ARC601\"", ")", ";", "if", "(", "!", "TARGET_DPFP", "&&", "TARGET_DPFP_DISABLE_LRSR", ")", "error", "(", "\"-mno-dpfp-lrsr supported only with -mdpfp\"", ")", ";", "if", "(", "(", "TARGET_DPFP_FAST_SET", "&&", "TARGET_DPFP_COMPACT_SET", ")", "||", "(", "TARGET_SPFP_FAST_SET", "&&", "TARGET_SPFP_COMPACT_SET", ")", ")", "error", "(", "\"FPX fast and compact options cannot be specified together\"", ")", ";", "if", "(", "TARGET_SPFP_FAST_SET", "&&", "(", "TARGET_ARC600", "||", "TARGET_ARC601", ")", ")", "error", "(", "\"-mspfp_fast not available on ARC600 or ARC601\"", ")", ";", "if", "(", "(", "TARGET_DPFP", "||", "TARGET_SPFP", ")", "&&", "!", "(", "TARGET_ARC600", "||", "TARGET_ARC601", "||", "TARGET_ARC700", ")", ")", "error", "(", "\"FPX extensions not available on pre-ARC600 cores\"", ")", ";", "if", "(", "flag_pic", "&&", "!", "TARGET_ARC700", ")", "{", "warning", "(", "DK_WARNING", ",", "\"PIC is not supported for %s. Generating non-PIC code only..\"", ",", "arc_cpu_string", ")", ";", "flag_pic", "=", "0", ";", "}", "arc_init_reg_tables", "(", ")", ";", "memset", "(", "arc_punct_chars", ",", "0", ",", "sizeof", "(", "arc_punct_chars", ")", ")", ";", "arc_punct_chars", "[", "'#'", "]", "=", "1", ";", "arc_punct_chars", "[", "'*'", "]", "=", "1", ";", "arc_punct_chars", "[", "'?'", "]", "=", "1", ";", "arc_punct_chars", "[", "'!'", "]", "=", "1", ";", "arc_punct_chars", "[", "'^'", "]", "=", "1", ";", "arc_punct_chars", "[", "'&'", "]", "=", "1", ";", "if", "(", "optimize", ">", "1", "&&", "!", "TARGET_NO_COND_EXEC", ")", "{", "opt_pass", "*", "pass_arc_ifcvt_4", "=", "make_pass_arc_ifcvt", "(", "g", ")", ";", "struct", "register_pass_info", "arc_ifcvt4_info", "=", "{", "pass_arc_ifcvt_4", ",", "\"dbr\"", ",", "1", ",", "PASS_POS_INSERT_AFTER", "}", ";", "struct", "register_pass_info", "arc_ifcvt5_info", "=", "{", "pass_arc_ifcvt_4", "->", "clone", "(", ")", ",", "\"shorten\"", ",", "1", ",", "PASS_POS_INSERT_BEFORE", "}", ";", "register_pass", "(", "&", "arc_ifcvt4_info", ")", ";", "register_pass", "(", "&", "arc_ifcvt5_info", ")", ";", "}", "if", "(", "flag_delayed_branch", ")", "{", "opt_pass", "*", "pass_arc_predicate_delay_insns", "=", "make_pass_arc_predicate_delay_insns", "(", "g", ")", ";", "struct", "register_pass_info", "arc_predicate_delay_info", "=", "{", "pass_arc_predicate_delay_insns", ",", "\"dbr\"", ",", "1", ",", "PASS_POS_INSERT_AFTER", "}", ";", "register_pass", "(", "&", "arc_predicate_delay_info", ")", ";", "}", "}", "</s>"], "natrual_language": ["Called", "by", "OVERRIDE_OPTIONS", "to", "initialize", "various", "things", "."], "TS_V_token": ["arc", "\"A5\"", "\"ARC600\"", "\"ARC601\"", "\"ARC700\"", "0", "4", "30", "3", "30", "4", "30", "\"-mmul64 not supported for ARC700\"", "\"-mno-mpy supported only for ARC700\"", "\"-mmul32x16 supported only for ARC600 or ARC601\"", "\"-mno-dpfp-lrsr supported only with -mdpfp\"", "\"FPX fast and compact options cannot be specified together\"", "\"-mspfp_fast not available on ARC600 or ARC601\"", "\"FPX extensions not available on pre-ARC600 cores\"", "\"PIC is not supported for %s. Generating non-PIC code only..\"", "0", "0", "1", "1", "1", "1", "1", "1", "1", "\"dbr\"", "1", "\"shorten\"", "1", "\"dbr\"", "1"], "File": "arc4", "Func": "arc_init", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33483, "Length": 456}
{"ground_truth": ["<s>", "static", "void", "arc_initialize_trampoline", "(", "rtx", "tramp", ",", "tree", "fndecl", ",", "rtx", "cxt", ")", "{", "rtx", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "emit_store_direct", "(", "tramp", ",", "0", ",", "TARGET_BIG_ENDIAN", "?", "0x78e0d403", ":", "0xd40378e0", ")", ";", "emit_store_direct", "(", "tramp", ",", "4", ",", "TARGET_BIG_ENDIAN", "?", "0x170c700b", ":", "0x700b170c", ")", ";", "emit_store_direct", "(", "tramp", ",", "8", ",", "TARGET_BIG_ENDIAN", "?", "0x7c0078e0", ":", "0x78e07c00", ")", ";", "emit_move_insn", "(", "adjust_address", "(", "tramp", ",", "SImode", ",", "12", ")", ",", "fnaddr", ")", ";", "emit_move_insn", "(", "adjust_address", "(", "tramp", ",", "SImode", ",", "16", ")", ",", "cxt", ")", ";", "emit_insn", "(", "gen_flush_icache", "(", "adjust_address", "(", "tramp", ",", "SImode", ",", "0", ")", ")", ")", ";", "}", "</s>"], "natrual_language": ["With", "potentially", "multiple", "shared", "objects", "loaded", ",", "and", "multiple", "stacks", "present", "for", "multiple", "thereds", "where", "trampolines", "might", "reside", ",", "a", "simple", "range", "check", "will", "likely", "not", "suffice", "for", "the", "profiler", "to", "tell", "if", "a", "callee", "is", "a", "trampoline", ".", "We", "a", "speedier", "check", "by", "making", "the", "trampoline", "start", "at", "an", "address", "that", "is", "not", "4-byte", "aligned", ".", "A", "trampoline", "looks", "like", "this", ":", "nop_s", "0x78e0entry", ":", "ld_s", "r12", ",", "[", "pcl,12", "]", "0xd403", "ld", "r11", ",", "[", "pcl,12", "]", "0x170c", "700b", "j_s", "[", "r12", "]", "0x7c00", "nop_s", "0x78e0", "The", "fastest", "trampoline", "to", "execute", "for", "trampolines", "within", "+-8KB", "of", "CTX", "would", "be", ":", "add2", "r11", ",", "pcl", ",", "s12", "j", "[", "limm", "]", "0x20200f80", "limm", "and", "that", "would", "also", "be", "faster", "to", "write", "to", "the", "stack", "by", "computing", "the", "offset", "from", "CTX", "to", "TRAMP", "at", "compile", "time", ".", "However", ",", "it", "would", "really", "be", "better", "to", "get", "rid", "of", "the", "high", "cost", "of", "cache", "invalidation", "when", "generating", "trampolines", ",", "which", "requires", "that", "the", "code", "part", "of", "trampolines", "stays", "constant", ",", "and", "additionally", "either", "-", "making", "sure", "that", "no", "executable", "code", "but", "trampolines", "is", "on", "the", "stack", ",", "no", "icache", "entries", "linger", "for", "the", "area", "of", "the", "stack", "from", "when", "before", "the", "stack", "was", "allocated", ",", "and", "allocating", "trampolines", "in", "trampoline-only", "cache", "lines", "or", "-", "allocate", "trampolines", "fram", "a", "special", "pool", "of", "pre-allocated", "trampolines", "."], "TS_V_token": ["arc", "0", "0", "0x78e0d403", "0xd40378e0", "4", "0x170c700b", "0x700b170c", "8", "0x7c0078e0", "0x78e07c00", "12", "16", "0"], "File": "arc4", "Func": "arc_initialize_trampoline", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33484, "Length": 110}
{"ground_truth": ["<s>", "int", "arc_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "if", "(", "!", "cfun", "->", "machine", "->", "frame_info", ".", "initialized", ")", "arc_compute_frame_size", "(", "get_frame_size", "(", ")", ")", ";", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "FRAME_POINTER_REGNUM", ")", "{", "return", "(", "cfun", "->", "machine", "->", "frame_info", ".", "extra_size", "+", "cfun", "->", "machine", "->", "frame_info", ".", "reg_size", ")", ";", "}", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "{", "return", "(", "cfun", "->", "machine", "->", "frame_info", ".", "total_size", "-", "cfun", "->", "machine", "->", "frame_info", ".", "pretend_size", ")", ";", "}", "if", "(", "(", "from", "==", "FRAME_POINTER_REGNUM", ")", "&&", "(", "to", "==", "STACK_POINTER_REGNUM", ")", ")", "{", "return", "(", "cfun", "->", "machine", "->", "frame_info", ".", "total_size", "-", "(", "cfun", "->", "machine", "->", "frame_info", ".", "pretend_size", "+", "cfun", "->", "machine", "->", "frame_info", ".", "extra_size", "+", "cfun", "->", "machine", "->", "frame_info", ".", "reg_size", ")", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>"], "natrual_language": ["Define", "the", "offset", "between", "two", "registers", ",", "one", "to", "be", "eliminated", ",", "and", "the", "other", "its", "replacement", ",", "at", "the", "start", "of", "a", "routine", "."], "TS_V_token": ["arc"], "File": "arc4", "Func": "arc_initial_elimination_offset", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33485, "Length": 148}
{"ground_truth": ["<s>", "static", "struct", "machine_function", "*", "arc_init_machine_status", "(", "void", ")", "{", "struct", "machine_function", "*", "machine", ";", "machine", "=", "ggc_cleared_alloc", "<", "machine_function", ">", "(", ")", ";", "machine", "->", "fn_type", "=", "ARC_FUNCTION_UNKNOWN", ";", "machine", "->", "force_short_suffix", "=", "-", "1", ";", "return", "machine", ";", "}", "</s>"], "natrual_language": ["The", "usual", ";", "we", "set", "up", "our", "machine_function", "data", "."], "TS_V_token": ["arc", "1"], "File": "arc4", "Func": "arc_init_machine_status", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33486, "Length": 40}
{"ground_truth": ["<s>", "static", "void", "arc_init_reg_tables", "(", "void", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "NUM_MACHINE_MODES", ";", "i", "++", ")", "{", "machine_mode", "m", "=", "(", "machine_mode", ")", "i", ";", "switch", "(", "GET_MODE_CLASS", "(", "m", ")", ")", "{", "case", "MODE_INT", ":", "case", "MODE_PARTIAL_INT", ":", "case", "MODE_COMPLEX_INT", ":", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "<=", "4", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "S_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "8", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "D_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "16", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "T_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "32", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "O_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "case", "MODE_FLOAT", ":", "case", "MODE_COMPLEX_FLOAT", ":", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "<=", "4", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "SF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "8", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "DF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "16", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "TF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "32", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "OF_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "case", "MODE_VECTOR_INT", ":", "arc_mode_class", "[", "i", "]", "=", "(", "1", "<<", "(", "int", ")", "V_MODE", ")", ";", "break", ";", "case", "MODE_CC", ":", "default", ":", "if", "(", "i", "==", "(", "int", ")", "CCmode", "||", "i", "==", "(", "int", ")", "CC_ZNmode", "||", "i", "==", "(", "int", ")", "CC_Zmode", "||", "i", "==", "(", "int", ")", "CC_Cmode", "||", "i", "==", "CC_FP_GTmode", "||", "i", "==", "CC_FP_GEmode", "||", "i", "==", "CC_FP_ORDmode", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "C_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "}", "}", "}", "</s>"], "natrual_language": ["Initialize", "the", "arc_mode_class", "array", "."], "TS_V_token": ["arc", "0", "4", "1", "8", "1", "16", "1", "32", "1", "0", "4", "1", "8", "1", "16", "1", "32", "1", "0", "1", "1", "0"], "File": "arc4", "Func": "arc_init_reg_tables", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33487, "Length": 340}
{"ground_truth": ["<s>", "static", "bool", "arc_in_small_data_p", "(", "const_tree", "decl", ")", "{", "HOST_WIDE_INT", "size", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "STRING_CST", "||", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "return", "false", ";", "if", "(", "TARGET_NO_SDATA_SET", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "DECL_SECTION_NAME", "(", "decl", ")", "!=", "0", ")", "{", "const", "char", "*", "name", ";", "name", "=", "DECL_SECTION_NAME", "(", "decl", ")", ";", "if", "(", "strcmp", "(", "name", ",", "\".sdata\"", ")", "!=", "0", "&&", "strcmp", "(", "name", ",", "\".sbss\"", ")", "!=", "0", ")", "return", "false", ";", "if", "(", "!", "DECL_EXTERNAL", "(", "decl", ")", ")", "return", "true", ";", "}", "else", "if", "(", "1", ")", "{", "if", "(", "TREE_CODE", "(", "decl", ")", "!=", "VAR_DECL", ")", "return", "false", ";", "if", "(", "TREE_READONLY", "(", "decl", ")", "&&", "!", "TREE_SIDE_EFFECTS", "(", "decl", ")", "&&", "(", "!", "DECL_INITIAL", "(", "decl", ")", "||", "TREE_CONSTANT", "(", "DECL_INITIAL", "(", "decl", ")", ")", ")", ")", "return", "false", ";", "if", "(", "default_binds_local_p_1", "(", "decl", ",", "1", ")", "||", "arc_decl_anon_ns_mem_p", "(", "decl", ")", ")", "return", "false", ";", "if", "(", "TREE_THIS_VOLATILE", "(", "decl", ")", ")", "return", "false", ";", "}", "if", "(", "DECL_WEAK", "(", "decl", ")", ")", "return", "false", ";", "size", "=", "int_size_in_bytes", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "return", "(", "size", ">", "0", "&&", "size", "<=", "4", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_IN_SMALL_DATA_P", ".", "Return", "true", "if", "it", "would", "be", "safe", "to", "access", "DECL", "using", "%", "gp_rel", "(", "...", ")", "(", "$", "gp", ")", "."], "TS_V_token": ["arc", "0", "\".sdata\"", "0", "\".sbss\"", "0", "1", "1", "0", "4"], "File": "arc4", "Func": "arc_in_small_data_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33488, "Length": 211}
{"ground_truth": ["<s>", "int", "arc_label_align", "(", "rtx", "label", ")", "{", "int", "loop_align", "=", "LOOP_ALIGN", "(", "LABEL", ")", ";", "if", "(", "loop_align", ">", "align_labels_log", ")", "{", "rtx_insn", "*", "prev", "=", "prev_nonnote_insn", "(", "label", ")", ";", "if", "(", "prev", "&&", "NONJUMP_INSN_P", "(", "prev", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "prev", ")", ")", "==", "PARALLEL", "&&", "recog_memoized", "(", "prev", ")", "==", "CODE_FOR_doloop_begin_i", ")", "return", "loop_align", ";", "}", "if", "(", "align_labels_log", "<", "1", ")", "{", "rtx_insn", "*", "next", "=", "next_nonnote_nondebug_insn", "(", "label", ")", ";", "if", "(", "INSN_P", "(", "next", ")", "&&", "recog_memoized", "(", "next", ")", ">=", "0", ")", "return", "1", ";", "}", "return", "align_labels_log", ";", "}", "</s>"], "natrual_language": ["Oddly", "enough", ",", "sometimes", "we", "get", "a", "zero", "overhead", "loop", "that", "branch", "shortening", "does", "n't", "think", "is", "a", "loop", "-", "observed", "with", "compile/pr24883.c", "-O3", "-fomit-frame-pointer", "-funroll-loops", ".", "Make", "sure", "to", "include", "the", "alignment", "visible", "for", "branch", "shortening", "(", "we", "actually", "align", "the", "loop", "insn", "before", "it", ",", "but", "that", "is", "equivalent", "since", "the", "loop", "insn", "is", "4", "byte", "long", ".", ")"], "TS_V_token": ["arc", "1", "0", "1"], "File": "arc4", "Func": "arc_label_align", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33489, "Length": 99}
{"ground_truth": ["<s>", "bool", "arc_legitimate_constant_p", "(", "machine_mode", ",", "rtx", "x", ")", "{", "if", "(", "!", "flag_pic", ")", "return", "true", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST", ":", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "!=", "CONST_INT", ")", "return", "false", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", ")", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "case", "ARC_UNSPEC_PLT", ":", "case", "ARC_UNSPEC_GOTOFF", ":", "case", "ARC_UNSPEC_GOT", ":", "case", "UNSPEC_PROF", ":", "return", "true", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "arc_raw_symbolic_reference_mentioned_p", "(", "x", ",", "false", ")", ")", "return", "false", ";", "break", ";", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "return", "false", ";", "default", ":", "break", ";", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["Determine", "if", "a", "given", "RTX", "is", "a", "valid", "constant", ".", "We", "already", "know", "this", "satisfies", "CONSTANT_P", "."], "TS_V_token": ["arc", "0", "1", "0", "1"], "File": "arc4", "Func": "arc_legitimate_constant_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33490, "Length": 147}
{"ground_truth": ["<s>", "bool", "arc_legitimate_pc_offset_p", "(", "rtx", "addr", ")", "{", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "CONST", ")", "return", "false", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "!=", "CONST_INT", ")", "return", "false", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "}", "return", "(", "GET_CODE", "(", "addr", ")", "==", "UNSPEC", "&&", "XVECLEN", "(", "addr", ",", "0", ")", "==", "1", "&&", "XINT", "(", "addr", ",", "1", ")", "==", "ARC_UNSPEC_GOT", "&&", "GET_CODE", "(", "XVECEXP", "(", "addr", ",", "0", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "ADDR", "is", "an", "address", "that", "needs", "to", "be", "expressed", "as", "an", "explicit", "sum", "of", "pcl", "+", "offset", "."], "TS_V_token": ["arc", "0", "1", "0", "0", "1", "1", "0", "0"], "File": "arc4", "Func": "arc_legitimate_pc_offset_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33491, "Length": 108}
{"ground_truth": ["<s>", "bool", "arc_legitimate_pic_addr_p", "(", "rtx", "addr", ")", "{", "if", "(", "GET_CODE", "(", "addr", ")", "==", "LABEL_REF", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "CONST", ")", "return", "false", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "!=", "CONST_INT", ")", "return", "false", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "UNSPEC", "||", "XVECLEN", "(", "addr", ",", "0", ")", "!=", "1", ")", "return", "false", ";", "if", "(", "XINT", "(", "addr", ",", "1", ")", "!=", "ARC_UNSPEC_GOT", "&&", "XINT", "(", "addr", ",", "1", ")", "!=", "ARC_UNSPEC_GOTOFF", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "XVECEXP", "(", "addr", ",", "0", ",", "0", ")", ")", "!=", "SYMBOL_REF", "&&", "GET_CODE", "(", "XVECEXP", "(", "addr", ",", "0", ",", "0", ")", ")", "!=", "LABEL_REF", ")", "return", "false", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "ADDR", "is", "a", "valid", "pic", "address", ".", "A", "valid", "pic", "address", "on", "arc", "should", "look", "like", "const", "(", "unspec", "(", "SYMBOL_REF/LABEL", ")", "(", "ARC_UNSPEC_GOTOFF/ARC_UNSPEC_GOT", ")", ")"], "TS_V_token": ["arc", "0", "1", "0", "0", "1", "1", "1", "0", "0", "0", "0"], "File": "arc4", "Func": "arc_legitimate_pic_addr_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33492, "Length": 158}
{"ground_truth": ["<s>", "bool", "arc_legitimate_pic_operand_p", "(", "rtx", "x", ")", "{", "return", "!", "arc_raw_symbolic_reference_mentioned_p", "(", "x", ",", "true", ")", ";", "}", "</s>"], "natrual_language": ["Nonzero", "if", "the", "constant", "value", "X", "is", "a", "legitimate", "general", "operand", "when", "generating", "PIC", "code", ".", "It", "is", "given", "that", "flag_pic", "is", "on", "and", "that", "X", "satisfies", "CONSTANT_P", "or", "is", "a", "CONST_DOUBLE", "."], "TS_V_token": ["arc"], "File": "arc4", "Func": "arc_legitimate_pic_operand_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33493, "Length": 17}
{"ground_truth": ["<s>", "static", "rtx", "arc_legitimize_address_0", "(", "rtx", "x", ",", "rtx", "oldx", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ")", "{", "rtx", "addr", ",", "inner", ";", "if", "(", "flag_pic", "&&", "SYMBOLIC_CONST", "(", "x", ")", ")", "(", "x", ")", "=", "arc_legitimize_pic_address", "(", "x", ",", "0", ")", ";", "addr", "=", "x", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "CONST", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "&&", "(", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "SYMBOL_REF", "&&", "!", "SYMBOL_REF_FUNCTION_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", "||", "(", "REG_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "&&", "(", "INTVAL", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "&", "252", ")", ")", ")", ")", "{", "HOST_WIDE_INT", "offs", ",", "upper", ";", "int", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "offs", "=", "INTVAL", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ";", "upper", "=", "(", "offs", "+", "256", "*", "size", ")", "&", "~", "511", "*", "size", ";", "inner", "=", "plus_constant", "(", "Pmode", ",", "XEXP", "(", "addr", ",", "0", ")", ",", "upper", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "inner", "=", "gen_rtx_CONST", "(", "Pmode", ",", "inner", ")", ";", "addr", "=", "plus_constant", "(", "Pmode", ",", "force_reg", "(", "Pmode", ",", "inner", ")", ",", "offs", "-", "upper", ")", ";", "x", "=", "addr", ";", "}", "else", "if", "(", "GET_CODE", "(", "addr", ")", "==", "SYMBOL_REF", "&&", "!", "SYMBOL_REF_FUNCTION_P", "(", "addr", ")", ")", "x", "=", "force_reg", "(", "Pmode", ",", "x", ")", ";", "if", "(", "memory_address_p", "(", "(", "machine_mode", ")", "mode", ",", "x", ")", ")", "return", "x", ";", "return", "NULL_RTX", ";", "}", "</s>"], "natrual_language": ["This", "is", "like", "the", "hook", ",", "but", "returns", "NULL", "when", "it", "ca", "n't", "/", "wo", "n't", "generate", "a", "legitimate", "address", "."], "TS_V_token": ["arc", "0", "0", "1", "0", "0", "0", "1", "252", "1", "256", "511", "0"], "File": "arc4", "Func": "arc_legitimize_address_0", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33494, "Length": 276}
{"ground_truth": ["<s>", "static", "bool", "arc_lra_p", "(", "void", ")", "{", "return", "!", "TARGET_NO_LRA", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "we", "use", "LRA", "instead", "of", "reload", "pass", "."], "TS_V_token": ["arc"], "File": "arc4", "Func": "arc_lra_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33495, "Length": 12}
{"ground_truth": ["<s>", "static", "bool", "arc_mode_dependent_address_p", "(", "const_rtx", "addr", ",", "addr_space_t", ")", "{", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "&&", "(", "GET_CODE", "(", "XEXP", "(", "(", "addr", ")", ",", "0", ")", ")", "==", "MULT", "||", "(", "CONST_INT_P", "(", "XEXP", "(", "(", "addr", ")", ",", "1", ")", ")", "&&", "!", "SMALL_INT", "(", "INTVAL", "(", "XEXP", "(", "(", "addr", ")", ",", "1", ")", ")", ")", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Return", "true", "iff", "ADDR", "(", "a", "legitimate", "address", "expression", ")", "has", "an", "effect", "that", "depends", "on", "the", "machine", "mode", "it", "is", "used", "for", "."], "TS_V_token": ["arc", "0", "1", "1"], "File": "arc4", "Func": "arc_mode_dependent_address_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33496, "Length": 72}
{"ground_truth": ["<s>", "static", "rtx_insn", "*", "arc_next_active_insn", "(", "rtx_insn", "*", "insn", ",", "struct", "arc_ccfsm", "*", "statep", ")", "{", "rtx", "pat", ";", "do", "{", "if", "(", "statep", ")", "arc_ccfsm_post_advance", "(", "insn", ",", "statep", ")", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "if", "(", "!", "insn", "||", "BARRIER_P", "(", "insn", ")", ")", "return", "NULL", ";", "if", "(", "statep", ")", "arc_ccfsm_advance", "(", "insn", ",", "statep", ")", ";", "}", "while", "(", "NOTE_P", "(", "insn", ")", "||", "(", "cfun", "->", "machine", "->", "arc_reorg_started", "&&", "LABEL_P", "(", "insn", ")", "&&", "!", "label_to_alignment", "(", "insn", ")", ")", "||", "(", "NONJUMP_INSN_P", "(", "insn", ")", "&&", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", ")", ")", ")", ";", "if", "(", "!", "LABEL_P", "(", "insn", ")", ")", "{", "gcc_assert", "(", "INSN_P", "(", "insn", ")", ")", ";", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "ADDR_VEC", "||", "GET_CODE", "(", "pat", ")", "==", "ADDR_DIFF_VEC", ")", "return", "NULL", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SEQUENCE", ")", "return", "as_a", "<", "rtx_insn", "*", ">", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ")", ";", "}", "return", "insn", ";", "}", "</s>"], "natrual_language": ["Like", "next_active_insn", ",", "but", "return", "NULL", "if", "we", "find", "an", "ADDR_", "(", "DIFF_", ")", "VEC", ",", "and", "look", "inside", "SEQUENCEs", "."], "TS_V_token": ["arc", "0", "0"], "File": "arc4", "Func": "arc_next_active_insn", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33497, "Length": 193}
{"ground_truth": ["<s>", "int", "arc_output_addsi", "(", "rtx", "*", "operands", ",", "bool", "cond_p", ",", "bool", "output_p", ")", "{", "char", "format", "[", "32", "]", ";", "int", "match", "=", "operands_match_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "int", "match2", "=", "operands_match_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ")", ";", "int", "intval", "=", "(", "REG_P", "(", "operands", "[", "2", "]", ")", "?", "1", ":", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", "?", "INTVAL", "(", "operands", "[", "2", "]", ")", ":", "0xbadc057", ")", ";", "int", "neg_intval", "=", "-", "intval", ";", "int", "short_0", "=", "satisfies_constraint_Rcq", "(", "operands", "[", "0", "]", ")", ";", "int", "short_p", "=", "(", "!", "cond_p", "&&", "short_0", "&&", "satisfies_constraint_Rcq", "(", "operands", "[", "1", "]", ")", ")", ";", "int", "ret", "=", "0", ";", "if", "(", "output_p", ")", "\\", "output_asm_insn", "(", "FORMAT", ",", "operands", ")", ";", "\\", "return", "ret", ";", "\\", "}", "</s>"], "natrual_language": ["Emit", "code", "for", "an", "addsi3", "instruction", "with", "OPERANDS", ".", "COND_P", "indicates", "if", "this", "will", "use", "conditional", "execution", ".", "Return", "the", "length", "of", "the", "instruction", ".", "If", "OUTPUT_P", "is", "false", ",", "do", "n't", "actually", "output", "the", "instruction", ",", "just", "return", "its", "length", "."], "TS_V_token": ["arc", "32", "0", "1", "0", "2", "2", "1", "2", "2", "0xbadc057", "0", "1", "0"], "File": "arc4", "Func": "arc_output_addsi", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33498, "Length": 143}
{"ground_truth": ["<s>", "int", "arc_output_commutative_cond_exec", "(", "rtx", "*", "operands", ",", "bool", "output_p", ")", "{", "enum", "rtx_code", "commutative_op", "=", "GET_CODE", "(", "operands", "[", "3", "]", ")", ";", "const", "char", "*", "pat", "=", "NULL", ";", "gcc_assert", "(", "!", "CONSTANT_P", "(", "operands", "[", "1", "]", ")", ")", ";", "switch", "(", "commutative_op", ")", "{", "case", "AND", ":", "if", "(", "satisfies_constraint_C1p", "(", "operands", "[", "2", "]", ")", ")", "pat", "=", "\"bmsk%? %0,%1,%Z2\"", ";", "else", "if", "(", "satisfies_constraint_Ccp", "(", "operands", "[", "2", "]", ")", ")", "pat", "=", "\"bclr%? %0,%1,%M2\"", ";", "else", "if", "(", "satisfies_constraint_CnL", "(", "operands", "[", "2", "]", ")", ")", "pat", "=", "\"bic%? %0,%1,%n2-1\"", ";", "break", ";", "case", "IOR", ":", "if", "(", "satisfies_constraint_C0p", "(", "operands", "[", "2", "]", ")", ")", "pat", "=", "\"bset%? %0,%1,%z2\"", ";", "break", ";", "case", "XOR", ":", "if", "(", "satisfies_constraint_C0p", "(", "operands", "[", "2", "]", ")", ")", "pat", "=", "\"bxor%? %0,%1,%z2\"", ";", "break", ";", "case", "PLUS", ":", "return", "arc_output_addsi", "(", "operands", ",", "true", ",", "output_p", ")", ";", "default", ":", "break", ";", "}", "if", "(", "output_p", ")", "output_asm_insn", "(", "pat", "?", "pat", ":", "\"%O3.%d5 %0,%1,%2\"", ",", "operands", ")", ";", "if", "(", "pat", "||", "REG_P", "(", "operands", "[", "2", "]", ")", "||", "satisfies_constraint_L", "(", "operands", "[", "2", "]", ")", ")", "return", "4", ";", "return", "8", ";", "}", "</s>"], "natrual_language": ["Emit", "code", "for", "an", "commutative_cond_exec", "instruction", "with", "OPERANDS", ".", "Return", "the", "length", "of", "the", "instruction", ".", "If", "OUTPUT_P", "is", "false", ",", "do", "n't", "actually", "output", "the", "instruction", ",", "just", "return", "its", "length", "."], "TS_V_token": ["arc", "3", "1", "2", "\"bmsk%? %0,%1,%Z2\"", "2", "\"bclr%? %0,%1,%M2\"", "2", "\"bic%? %0,%1,%n2-1\"", "2", "\"bset%? %0,%1,%z2\"", "2", "\"bxor%? %0,%1,%z2\"", "\"%O3.%d5 %0,%1,%2\"", "2", "2", "4", "8"], "File": "arc4", "Func": "arc_output_commutative_cond_exec", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33499, "Length": 194}
{"ground_truth": ["<s>", "const", "char", "*", "arc_output_libcall", "(", "const", "char", "*", "fname", ")", "{", "unsigned", "len", "=", "strlen", "(", "fname", ")", ";", "static", "char", "buf", "[", "64", "]", ";", "gcc_assert", "(", "len", "<", "sizeof", "buf", "-", "35", ")", ";", "if", "(", "TARGET_LONG_CALLS_SET", "||", "(", "TARGET_MEDIUM_CALLS", "&&", "arc_ccfsm_cond_exec_p", "(", ")", ")", ")", "{", "if", "(", "flag_pic", ")", "sprintf", "(", "buf", ",", "\"add r12,pcl,@%s-(.&-4)\\n\\tjl%%!%%* [r12]\"", ",", "fname", ")", ";", "else", "sprintf", "(", "buf", ",", "\"jl%%! @%s\"", ",", "fname", ")", ";", "}", "else", "sprintf", "(", "buf", ",", "\"bl%%!%%* @%s\"", ",", "fname", ")", ";", "return", "buf", ";", "}", "</s>"], "natrual_language": ["Output", "a", "library", "call", "to", "a", "function", "called", "FNAME", "that", "has", "been", "arranged", "to", "be", "local", "to", "any", "dso", "."], "TS_V_token": ["arc", "64", "35", "\"add r12,pcl,@%s-(.&-4)\\n\\tjl%%!%%* [r12]\"", "\"jl%%! @%s\"", "\"bl%%!%%* @%s\""], "File": "arc4", "Func": "arc_output_libcall", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33500, "Length": 87}
{"ground_truth": ["<s>", "static", "void", "arc_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", "thunk", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "int", "mi_delta", "=", "delta", ";", "const", "char", "*", "const", "mi_op", "=", "mi_delta", "<", "0", "?", "\"sub\"", ":", "\"add\"", ";", "int", "shift", "=", "0", ";", "int", "this_regno", "=", "aggregate_value_p", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "function", ")", ")", ",", "function", ")", "?", "1", ":", "0", ";", "rtx", "fnaddr", ";", "if", "(", "mi_delta", "<", "0", ")", "mi_delta", "=", "-", "mi_delta", ";", "while", "(", "mi_delta", "!=", "0", ")", "{", "if", "(", "(", "mi_delta", "&", "(", "3", "<<", "shift", ")", ")", "==", "0", ")", "shift", "+=", "2", ";", "else", "{", "asm_fprintf", "(", "file", ",", "\"\\t%s\\t%s, %s, %d\\n\"", ",", "mi_op", ",", "reg_names", "[", "this_regno", "]", ",", "reg_names", "[", "this_regno", "]", ",", "mi_delta", "&", "(", "0xff", "<<", "shift", ")", ")", ";", "mi_delta", "&=", "~", "(", "0xff", "<<", "shift", ")", ";", "shift", "+=", "8", ";", "}", "}", "if", "(", "vcall_offset", "!=", "0", ")", "{", "asm_fprintf", "(", "file", ",", "\"\\tld\\t%s, [%s]\\n\"", ",", "ARC_TEMP_SCRATCH_REG", ",", "reg_names", "[", "this_regno", "]", ")", ";", "asm_fprintf", "(", "file", ",", "\"\\tadd\\t%s, %s, \"", "HOST_WIDE_INT_PRINT_DEC", "\"\\n\"", ",", "ARC_TEMP_SCRATCH_REG", ",", "ARC_TEMP_SCRATCH_REG", ",", "vcall_offset", ")", ";", "asm_fprintf", "(", "file", ",", "\"\\tld\\t%s, [%s]\\n\"", ",", "ARC_TEMP_SCRATCH_REG", ",", "ARC_TEMP_SCRATCH_REG", ")", ";", "asm_fprintf", "(", "file", ",", "\"\\tadd\\t%s, %s, %s\\n\"", ",", "reg_names", "[", "this_regno", "]", ",", "reg_names", "[", "this_regno", "]", ",", "ARC_TEMP_SCRATCH_REG", ")", ";", "}", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ";", "if", "(", "arc_is_longcall_p", "(", "fnaddr", ")", ")", "fputs", "(", "\"\\tj\\t\"", ",", "file", ")", ";", "else", "fputs", "(", "\"\\tb\\t\"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "XSTR", "(", "fnaddr", ",", "0", ")", ")", ";", "fputc", "(", "'\\n'", ",", "file", ")", ";", "}", "</s>"], "natrual_language": ["Output", "code", "to", "add", "DELTA", "to", "the", "first", "argument", ",", "and", "then", "jump", "to", "FUNCTION", ".", "Used", "for", "C++", "multiple", "inheritance", "."], "TS_V_token": ["arc", "0", "\"sub\"", "\"add\"", "0", "1", "0", "0", "0", "3", "0", "2", "\"\\t%s\\t%s, %s, %d\\n\"", "0xff", "0xff", "8", "0", "\"\\tld\\t%s, [%s]\\n\"", "\"\\tadd\\t%s, %s, \"", "\"\\n\"", "\"\\tld\\t%s, [%s]\\n\"", "\"\\tadd\\t%s, %s, %s\\n\"", "0", "\"\\tj\\t\"", "\"\\tb\\t\"", "0"], "File": "arc4", "Func": "arc_output_mi_thunk", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33501, "Length": 270}
{"ground_truth": ["<s>", "static", "void", "arc_override_options", "(", "void", ")", "{", "if", "(", "arc_cpu", "==", "PROCESSOR_NONE", ")", "arc_cpu", "=", "PROCESSOR_ARC700", ";", "if", "(", "arc_size_opt_level", "==", "3", ")", "optimize_size", "=", "1", ";", "if", "(", "flag_pic", ")", "target_flags", "|=", "MASK_NO_SDATA_SET", ";", "if", "(", "flag_no_common", "==", "255", ")", "flag_no_common", "=", "!", "TARGET_NO_SDATA_SET", ";", "\\", "if", "(", "TARGET_MIXED_CODE", ")", "TARGET_Q_CLASS", "=", "1", ";", "if", "(", "!", "TARGET_Q_CLASS", ")", "TARGET_COMPACT_CASESI", "=", "0", ";", "if", "(", "TARGET_COMPACT_CASESI", ")", "TARGET_CASE_VECTOR_PC_RELATIVE", "=", "1", ";", "arc_init", "(", ")", ";", "}", "</s>"], "natrual_language": ["Check", "ARC", "options", ",", "generate", "derived", "target", "attributes", "."], "TS_V_token": ["arc", "3", "1", "255", "1", "0", "1"], "File": "arc4", "Func": "arc_override_options", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33502, "Length": 77}
{"ground_truth": ["<s>", "void", "arc_pad_return", "(", "void", ")", "{", "rtx_insn", "*", "insn", "=", "current_output_insn", ";", "rtx_insn", "*", "prev", "=", "prev_active_insn", "(", "insn", ")", ";", "int", "want_long", ";", "if", "(", "!", "prev", ")", "{", "fputs", "(", "\"\\tnop_s\\n\"", ",", "asm_out_file", ")", ";", "cfun", "->", "machine", "->", "unalign", "^=", "2", ";", "want_long", "=", "1", ";", "}", "else", "if", "(", "GET_CODE", "(", "PATTERN", "(", "prev", ")", ")", "==", "SEQUENCE", ")", "return", ";", "else", "{", "want_long", "=", "(", "get_attr_length", "(", "prev", ")", "==", "2", ")", ";", "prev", "=", "prev_active_insn", "(", "prev", ")", ";", "}", "if", "(", "!", "prev", "||", "(", "(", "NONJUMP_INSN_P", "(", "prev", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "prev", ")", ")", "==", "SEQUENCE", ")", "?", "CALL_ATTR", "(", "as_a", "<", "rtx_sequence", "*", ">", "(", "PATTERN", "(", "prev", ")", ")", "->", "insn", "(", "0", ")", ",", "NON_SIBCALL", ")", ":", "CALL_ATTR", "(", "prev", ",", "NON_SIBCALL", ")", ")", ")", "{", "if", "(", "want_long", ")", "cfun", "->", "machine", "->", "size_reason", "=", "\"call/return and return/return must be 6 bytes apart to avoid mispredict\"", ";", "else", "if", "(", "TARGET_UNALIGN_BRANCH", "&&", "cfun", "->", "machine", "->", "unalign", ")", "{", "cfun", "->", "machine", "->", "size_reason", "=", "\"Long unaligned jump avoids non-delay slot penalty\"", ";", "want_long", "=", "1", ";", "}", "if", "(", "final_sequence", "&&", "!", "INSN_ANNULLED_BRANCH_P", "(", "insn", ")", "&&", "(", "get_attr_cond", "(", "insn", ")", "!=", "COND_USE", "||", "!", "reg_set_p", "(", "gen_rtx_REG", "(", "CCmode", ",", "CC_REG", ")", ",", "XVECEXP", "(", "final_sequence", ",", "0", ",", "1", ")", ")", ")", ")", "{", "prev", "=", "as_a", "<", "rtx_insn", "*", ">", "(", "XVECEXP", "(", "final_sequence", ",", "0", ",", "1", ")", ")", ";", "gcc_assert", "(", "!", "prev_real_insn", "(", "insn", ")", "||", "!", "arc_hazard", "(", "prev_real_insn", "(", "insn", ")", ",", "prev", ")", ")", ";", "cfun", "->", "machine", "->", "force_short_suffix", "=", "!", "want_long", ";", "rtx", "save_pred", "=", "current_insn_predicate", ";", "final_scan_insn", "(", "prev", ",", "asm_out_file", ",", "optimize", ",", "1", ",", "NULL", ")", ";", "cfun", "->", "machine", "->", "force_short_suffix", "=", "-", "1", ";", "prev", "->", "set_deleted", "(", ")", ";", "current_output_insn", "=", "insn", ";", "current_insn_predicate", "=", "save_pred", ";", "}", "else", "if", "(", "want_long", ")", "fputs", "(", "\"\\tnop\\n\"", ",", "asm_out_file", ")", ";", "else", "{", "fputs", "(", "\"\\tnop_s\\n\"", ",", "asm_out_file", ")", ";", "cfun", "->", "machine", "->", "unalign", "^=", "2", ";", "}", "}", "return", ";", "}", "</s>"], "natrual_language": ["We", "are", "about", "to", "output", "a", "return", "insn", ".", "Add", "padding", "if", "necessary", "to", "avoid", "a", "mispredict", ".", "A", "return", "could", "happen", "immediately", "after", "the", "function", "start", ",", "but", "after", "a", "call", "we", "know", "that", "there", "will", "be", "at", "least", "a", "blink", "restore", "."], "TS_V_token": ["arc", "\"\\tnop_s\\n\"", "2", "1", "2", "0", "\"call/return and return/return must be 6 bytes apart to avoid mispredict\"", "\"Long unaligned jump avoids non-delay slot penalty\"", "1", "0", "1", "0", "1", "1", "1", "\"\\tnop\\n\"", "\"\\tnop_s\\n\"", "2"], "File": "arc4", "Func": "arc_pad_return", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33503, "Length": 340}
{"ground_truth": ["<s>", "static", "bool", "arc_pass_by_reference", "(", "cumulative_args_t", "ca_v", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "type", "!=", "0", "&&", "(", "TREE_CODE", "(", "TYPE_SIZE", "(", "type", ")", ")", "!=", "INTEGER_CST", "||", "TREE_ADDRESSABLE", "(", "type", ")", ")", ")", ";", "}", "</s>"], "natrual_language": ["For", "ARC", ",", "All", "aggregates", "and", "arguments", "greater", "than", "8", "bytes", "are", "passed", "by", "reference", "."], "TS_V_token": ["arc", "0"], "File": "arc4", "Func": "arc_pass_by_reference", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33504, "Length": 45}
{"ground_truth": ["<s>", "void", "arc_print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "register", "rtx", "base", ",", "index", "=", "0", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "fputs", "(", "reg_names", "[", "REGNO", "(", "addr", ")", "]", ",", "file", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "output_addr_const", "(", "file", ",", "addr", ")", ";", "if", "(", "SYMBOL_REF_SMALL_P", "(", "addr", ")", ")", "fprintf", "(", "file", ",", "\"@sda\"", ")", ";", "break", ";", "case", "PLUS", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "MULT", ")", "index", "=", "XEXP", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ",", "base", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "if", "(", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", "index", "=", "XEXP", "(", "addr", ",", "0", ")", ",", "base", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "base", "=", "XEXP", "(", "addr", ",", "0", ")", ",", "index", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "gcc_assert", "(", "OBJECT_P", "(", "base", ")", ")", ";", "arc_print_operand_address", "(", "file", ",", "base", ")", ";", "if", "(", "CONSTANT_P", "(", "base", ")", "&&", "CONST_INT_P", "(", "index", ")", ")", "fputc", "(", "'+'", ",", "file", ")", ";", "else", "fputc", "(", "','", ",", "file", ")", ";", "gcc_assert", "(", "OBJECT_P", "(", "index", ")", ")", ";", "arc_print_operand_address", "(", "file", ",", "index", ")", ";", "break", ";", "case", "CONST", ":", "{", "rtx", "c", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "c", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "c", ",", "1", ")", ")", "==", "CONST_INT", ")", ";", "output_address", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ";", "break", ";", "}", "case", "PRE_INC", ":", "case", "PRE_DEC", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "default", ":", "if", "(", "flag_pic", ")", "arc_output_pic_addr_const", "(", "file", ",", "addr", ",", "0", ")", ";", "else", "output_addr_const", "(", "file", ",", "addr", ")", ";", "break", ";", "}", "}", "</s>"], "natrual_language": ["Print", "a", "memory", "address", "as", "an", "operand", "to", "reference", "that", "memory", "location", "."], "TS_V_token": ["arc", "0", "\"@sda\"", "0", "0", "0", "1", "0", "0", "1", "0", "1", "0", "0", "1", "0", "0"], "File": "arc4", "Func": "arc_print_operand_address", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33505, "Length": 316}
{"ground_truth": ["<s>", "static", "rtx", "arc_process_double_reg_moves", "(", "rtx", "*", "operands", ")", "{", "rtx", "dest", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "rtx", "val", ";", "enum", "usesDxState", "{", "none", ",", "srcDx", ",", "destDx", ",", "maxDx", "}", ";", "enum", "usesDxState", "state", "=", "none", ";", "if", "(", "refers_to_regno_p", "(", "40", ",", "44", ",", "src", ",", "0", ")", ")", "state", "=", "srcDx", ";", "if", "(", "refers_to_regno_p", "(", "40", ",", "44", ",", "dest", ",", "0", ")", ")", "{", "gcc_assert", "(", "state", "==", "none", ")", ";", "state", "=", "destDx", ";", "}", "if", "(", "state", "==", "none", ")", "return", "NULL_RTX", ";", "start_sequence", "(", ")", ";", "if", "(", "state", "==", "srcDx", ")", "{", "if", "(", "TARGET_DPFP_DISABLE_LRSR", ")", "{", "rtx", "set", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "src", ")", ";", "rtx", "use1", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "const1_rtx", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "set", ",", "use1", ")", ")", ")", ";", "}", "else", "{", "rtx", "destHigh", "=", "simplify_gen_subreg", "(", "SImode", ",", "dest", ",", "DFmode", ",", "4", ")", ";", "rtx", "destLow", "=", "simplify_gen_subreg", "(", "SImode", ",", "dest", ",", "DFmode", ",", "0", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "destHigh", ",", "gen_rtx_UNSPEC_VOLATILE", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "src", ")", ",", "VUNSPEC_LR_HIGH", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "destLow", ",", "gen_rtx_UNSPEC_VOLATILE", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "src", ")", ",", "VUNSPEC_LR", ")", ")", ")", ";", "}", "}", "else", "if", "(", "state", "==", "destDx", ")", "{", "rtx", "srcHigh", "=", "simplify_gen_subreg", "(", "SImode", ",", "src", ",", "DFmode", ",", "4", ")", ";", "rtx", "srcLow", "=", "simplify_gen_subreg", "(", "SImode", ",", "src", ",", "DFmode", ",", "0", ")", ";", "emit_insn", "(", "gen_rtx_UNSPEC_VOLATILE", "(", "Pmode", ",", "gen_rtvec", "(", "3", ",", "dest", ",", "srcHigh", ",", "srcLow", ")", ",", "VUNSPEC_DEXCL_NORES", ")", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "val", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "return", "val", ";", "}", "</s>"], "natrual_language": ["Handle", "DOUBLE_REGS", "uses", ".", "Operand", "0", ":", "destination", "register", "Operand", "1", ":", "source", "register"], "TS_V_token": ["arc", "0", "1", "40", "44", "0", "40", "44", "0", "2", "4", "0", "1", "1", "4", "0", "3"], "File": "arc4", "Func": "arc_process_double_reg_moves", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33506, "Length": 311}
{"ground_truth": ["<s>", "bool", "arc_profile_call", "(", "rtx", "callee", ")", "{", "rtx", "from", "=", "XEXP", "(", "DECL_RTL", "(", "current_function_decl", ")", ",", "0", ")", ";", "if", "(", "TARGET_UCB_MCOUNT", ")", "return", "false", ";", "if", "(", "CONSTANT_P", "(", "callee", ")", ")", "{", "rtx", "count_ptr", "=", "gen_rtx_CONST", "(", "Pmode", ",", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "3", ",", "from", ",", "callee", ",", "CONST0_RTX", "(", "Pmode", ")", ")", ",", "UNSPEC_PROF", ")", ")", ";", "rtx", "counter", "=", "gen_rtx_MEM", "(", "SImode", ",", "count_ptr", ")", ";", "emit_move_insn", "(", "counter", ",", "force_reg", "(", "SImode", ",", "plus_constant", "(", "SImode", ",", "counter", ",", "1", ")", ")", ")", ";", "return", "false", ";", "}", "else", "{", "rtx", "count_list_ptr", "=", "gen_rtx_CONST", "(", "Pmode", ",", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "3", ",", "from", ",", "CONST0_RTX", "(", "Pmode", ")", ",", "CONST0_RTX", "(", "Pmode", ")", ")", ",", "UNSPEC_PROF", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "8", ")", ",", "count_list_ptr", ")", ";", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "9", ")", ",", "callee", ")", ";", "return", "true", ";", "}", "}", "</s>"], "natrual_language": ["Emit", "profiling", "code", "for", "calling", "CALLEE", ".", "Return", "true", "if", "a", "special", "call", "pattern", "needs", "to", "be", "generated", "."], "TS_V_token": ["arc", "0", "3", "1", "3", "8", "9"], "File": "arc4", "Func": "arc_profile_call", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33507, "Length": 160}
{"ground_truth": ["<s>", "bool", "arc_raw_symbolic_reference_mentioned_p", "(", "rtx", "op", ",", "bool", "skip_local", ")", "{", "register", "const", "char", "*", "fmt", ";", "register", "int", "i", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "UNSPEC", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "SYMBOL_REF", ")", "{", "tree", "decl", "=", "SYMBOL_REF_DECL", "(", "op", ")", ";", "return", "!", "skip_local", "||", "!", "decl", "||", "!", "default_binds_local_p", "(", "decl", ")", ";", "}", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "op", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "op", ")", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "register", "int", "j", ";", "for", "(", "j", "=", "XVECLEN", "(", "op", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "if", "(", "arc_raw_symbolic_reference_mentioned_p", "(", "XVECEXP", "(", "op", ",", "i", ",", "j", ")", ",", "skip_local", ")", ")", "return", "true", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'e'", "&&", "arc_raw_symbolic_reference_mentioned_p", "(", "XEXP", "(", "op", ",", "i", ")", ",", "skip_local", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "OP", "contains", "a", "SYMBOL_REF", "that", "is", "not", "wrapped", "in", "an", "unspec", ".", "If", "SKIP_LOCAL", "is", "true", ",", "skip", "symbols", "that", "bind", "locally", ".", "This", "is", "used", "further", "down", "in", "this", "file", ",", "and", ",", "without", "SKIP_LOCAL", ",", "in", "the", "addsi3", "/", "subsi3", "expanders", "when", "generating", "PIC", "code", "."], "TS_V_token": ["arc", "1", "0", "1", "0"], "File": "arc4", "Func": "arc_raw_symbolic_reference_mentioned_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33508, "Length": 180}
{"ground_truth": ["<s>", "int", "arc_register_move_cost", "(", "machine_mode", ",", "enum", "reg_class", "from_class", ",", "enum", "reg_class", "to_class", ")", "{", "if", "(", "TARGET_ARC600", ")", "{", "if", "(", "to_class", "==", "MPY_WRITABLE_CORE_REGS", ")", "return", "3", ";", "else", "if", "(", "to_class", "==", "LPCOUNT_REG", ")", "return", "6", ";", "else", "if", "(", "to_class", "==", "WRITABLE_CORE_REGS", ")", "return", "6", ";", "}", "if", "(", "TARGET_ARC700", "&&", "(", "from_class", "==", "LPCOUNT_REG", "||", "from_class", "==", "ALL_CORE_REGS", "||", "from_class", "==", "WRITABLE_CORE_REGS", ")", ")", "return", "8", ";", "if", "(", "TARGET_ARC700", "&&", "TARGET_DPFP", "&&", "from_class", "==", "DOUBLE_REGS", "&&", "to_class", "==", "DOUBLE_REGS", ")", "return", "100", ";", "return", "2", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_REGISTER_MOVE_COST", "."], "TS_V_token": ["arc", "3", "6", "6", "8", "100", "2"], "File": "arc4", "Func": "arc_register_move_cost", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33509, "Length": 91}
{"ground_truth": ["<s>", "static", "bool", "arc_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "||", "TREE_ADDRESSABLE", "(", "type", ")", ")", "return", "true", ";", "else", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "return", "(", "size", "==", "-", "1", "||", "size", ">", "8", ")", ";", "}", "}", "</s>"], "natrual_language": ["Worker", "function", "for", "TARGET_RETURN_IN_MEMORY", "."], "TS_V_token": ["arc", "1", "8"], "File": "arc4", "Func": "arc_return_in_memory", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33510, "Length": 51}
{"ground_truth": ["<s>", "int", "arc_return_slot_offset", "(", ")", "{", "struct", "arc_frame_info", "*", "afi", "=", "&", "cfun", "->", "machine", "->", "frame_info", ";", "return", "(", "afi", "->", "save_return_addr", "?", "afi", "->", "total_size", "-", "afi", "->", "pretend_size", "-", "afi", "->", "extra_size", ":", "-", "1", ")", ";", "}", "</s>"], "natrual_language": ["Return", "the", "offset", "relative", "to", "the", "stack", "pointer", "where", "the", "return", "address", "is", "stored", ",", "or", "-1", "if", "it", "is", "not", "stored", "."], "TS_V_token": ["arc", "1"], "File": "arc4", "Func": "arc_return_slot_offset", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33511, "Length": 40}
{"ground_truth": ["<s>", "rtx", "arc_rewrite_small_data", "(", "rtx", "op", ")", "{", "op", "=", "copy_insn", "(", "op", ")", ";", "subrtx_ptr_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX_PTR", "(", "iter", ",", "array", ",", "&", "op", ",", "ALL", ")", "{", "rtx", "*", "loc", "=", "*", "iter", ";", "if", "(", "arc_rewrite_small_data_p", "(", "*", "loc", ")", ")", "{", "gcc_assert", "(", "SDATA_BASE_REGNUM", "==", "PIC_OFFSET_TABLE_REGNUM", ")", ";", "*", "loc", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "pic_offset_table_rtx", ",", "*", "loc", ")", ";", "if", "(", "loc", "!=", "&", "op", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "MEM", "&&", "&", "XEXP", "(", "op", ",", "0", ")", "==", "loc", ")", ";", "else", "if", "(", "GET_CODE", "(", "op", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "0", ")", ")", "==", "MULT", ")", "*", "loc", "=", "force_reg", "(", "Pmode", ",", "*", "loc", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "iter", ".", "skip_subrtxes", "(", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "*", "loc", ")", "==", "PLUS", "&&", "rtx_equal_p", "(", "XEXP", "(", "*", "loc", ",", "0", ")", ",", "pic_offset_table_rtx", ")", ")", "iter", ".", "skip_subrtxes", "(", ")", ";", "}", "return", "op", ";", "}", "</s>"], "natrual_language": ["If", "possible", ",", "rewrite", "OP", "so", "that", "it", "refers", "to", "small", "data", "using", "explicit", "relocations", "."], "TS_V_token": ["arc", "0", "0", "0", "0", "0"], "File": "arc4", "Func": "arc_rewrite_small_data", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33512, "Length": 193}
{"ground_truth": ["<s>", "static", "bool", "arc_rewrite_small_data_p", "(", "const_rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "}", "return", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_SMALL_P", "(", "x", ")", ")", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "X", "is", "a", "small", "data", "address", "that", "can", "be", "rewritten", "as", "a", "gp+symref", "."], "TS_V_token": ["arc", "0", "1", "0"], "File": "arc4", "Func": "arc_rewrite_small_data_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33513, "Length": 76}
{"ground_truth": ["<s>", "static", "reg_class_t", "arc_secondary_reload", "(", "bool", "in_p", ",", "rtx", "x", ",", "reg_class_t", "cl", ",", "machine_mode", ",", "secondary_reload_info", "*", ")", "{", "if", "(", "cl", "==", "DOUBLE_REGS", ")", "return", "GENERAL_REGS", ";", "if", "(", "(", "cl", "==", "LPCOUNT_REG", "||", "cl", "==", "WRITABLE_CORE_REGS", ")", "&&", "in_p", "&&", "MEM_P", "(", "x", ")", ")", "return", "GENERAL_REGS", ";", "return", "NO_REGS", ";", "}", "</s>"], "natrual_language": ["For", "ARC", "base", "register", "+", "offset", "addressing", ",", "the", "validity", "of", "the", "address", "is", "mode-dependent", "for", "most", "of", "the", "offset", "range", ",", "as", "the", "offset", "can", "be", "scaled", "by", "the", "access", "size", ".", "We", "do", "n't", "expose", "these", "as", "mode-dependent", "addresses", "in", "the", "mode_dependent_address_p", "target", "hook", ",", "because", "that", "would", "disable", "lots", "of", "optimizations", ",", "and", "most", "uses", "of", "these", "addresses", "are", "for", "32", "or", "64", "bit", "accesses", "anyways", ",", "which", "are", "fine", ".", "However", ",", "that", "leaves", "some", "addresses", "for", "8", "/", "16", "bit", "values", "not", "properly", "reloaded", "by", "the", "generic", "code", ",", "which", "is", "why", "we", "have", "to", "schedule", "secondary", "reloads", "for", "these", "."], "TS_V_token": ["arc"], "File": "arc4", "Func": "arc_secondary_reload", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33514, "Length": 54}
{"ground_truth": ["<s>", "machine_mode", "arc_select_cc_mode", "(", "enum", "rtx_code", "op", ",", "rtx", "x", ",", "rtx", "y", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "rtx", "x1", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "&&", "y", "==", "const0_rtx", "&&", "(", "op", "==", "EQ", "||", "op", "==", "NE", "||", "(", "(", "op", "==", "LT", "||", "op", "==", "GE", ")", "&&", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", "<=", "4", ")", ")", ")", "return", "CC_ZNmode", ";", "if", "(", "mode", "==", "SImode", "&&", "GET_CODE", "(", "y", ")", "==", "NEG", "&&", "(", "op", "==", "EQ", "||", "op", "==", "NE", ")", ")", "return", "CC_ZNmode", ";", "if", "(", "mode", "==", "SImode", "&&", "(", "op", "==", "EQ", "||", "op", "==", "NE", ")", "&&", "CONST_INT_P", "(", "y", ")", "&&", "(", "(", "INTVAL", "(", "y", ")", "-", "1", ")", "&", "INTVAL", "(", "y", ")", ")", "==", "0", "&&", "INTVAL", "(", "y", ")", ")", "return", "CC_Zmode", ";", "if", "(", "mode", "==", "SImode", "&&", "(", "op", "==", "EQ", "||", "op", "==", "NE", ")", "&&", "CONST_INT_P", "(", "y", ")", "&&", "GET_CODE", "(", "x", ")", "==", "AND", "&&", "CONST_INT_P", "(", "(", "x1", "=", "XEXP", "(", "x", ",", "1", ")", ")", ")", "&&", "(", "(", "INTVAL", "(", "x1", ")", "+", "1", ")", "&", "INTVAL", "(", "x1", ")", ")", "==", "0", "&&", "(", "~", "INTVAL", "(", "x1", ")", "|", "INTVAL", "(", "y", ")", ")", "<", "0", "&&", "(", "~", "INTVAL", "(", "x1", ")", "|", "INTVAL", "(", "y", ")", ")", ">", "-", "0x800", ")", "return", "CC_Zmode", ";", "if", "(", "GET_MODE", "(", "x", ")", "==", "SImode", "&&", "(", "op", "==", "LTU", "||", "op", "==", "GEU", ")", "&&", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "(", "rtx_equal_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "y", ")", "||", "rtx_equal_p", "(", "XEXP", "(", "x", ",", "1", ")", ",", "y", ")", ")", ")", "return", "CC_Cmode", ";", "if", "(", "TARGET_ARGONAUT_SET", "&&", "(", "(", "mode", "==", "SFmode", "&&", "TARGET_SPFP", ")", "||", "(", "mode", "==", "DFmode", "&&", "TARGET_DPFP", ")", ")", ")", "switch", "(", "op", ")", "{", "case", "EQ", ":", "case", "NE", ":", "case", "UNEQ", ":", "case", "LTGT", ":", "case", "ORDERED", ":", "case", "UNORDERED", ":", "return", "CC_FPXmode", ";", "case", "LT", ":", "case", "UNGE", ":", "case", "GT", ":", "case", "UNLE", ":", "return", "CC_FP_GTmode", ";", "case", "LE", ":", "case", "UNGT", ":", "case", "GE", ":", "case", "UNLT", ":", "return", "CC_FP_GEmode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "&&", "TARGET_OPTFPE", ")", "switch", "(", "op", ")", "{", "case", "EQ", ":", "case", "NE", ":", "return", "CC_Zmode", ";", "case", "LT", ":", "case", "UNGE", ":", "case", "GT", ":", "case", "UNLE", ":", "return", "CC_FP_GTmode", ";", "case", "LE", ":", "case", "UNGT", ":", "case", "GE", ":", "case", "UNLT", ":", "return", "CC_FP_GEmode", ";", "case", "UNEQ", ":", "case", "LTGT", ":", "return", "CC_FP_UNEQmode", ";", "case", "ORDERED", ":", "case", "UNORDERED", ":", "return", "CC_FP_ORDmode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "CCmode", ";", "}", "</s>"], "natrual_language": ["Given", "a", "comparison", "code", "(", "EQ", ",", "NE", ",", "etc", ".", ")", "and", "the", "first", "operand", "of", "a", "COMPARE", ",", "return", "the", "mode", "to", "be", "used", "for", "the", "comparison", "."], "TS_V_token": ["arc", "4", "1", "0", "1", "1", "0", "0", "0x800", "0", "1"], "File": "arc4", "Func": "arc_select_cc_mode", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33515, "Length": 465}
{"ground_truth": ["<s>", "static", "void", "arc_setup_incoming_varargs", "(", "cumulative_args_t", "args_so_far", ",", "machine_mode", "mode", ",", "tree", "type", ",", "int", "*", "pretend_size", ",", "int", "no_rtl", ")", "{", "int", "first_anon_arg", ";", "CUMULATIVE_ARGS", "next_cum", ";", "next_cum", "=", "*", "get_cumulative_args", "(", "args_so_far", ")", ";", "arc_function_arg_advance", "(", "pack_cumulative_args", "(", "&", "next_cum", ")", ",", "mode", ",", "type", ",", "1", ")", ";", "first_anon_arg", "=", "next_cum", ";", "if", "(", "first_anon_arg", "<", "MAX_ARC_PARM_REGS", ")", "{", "int", "first_reg_offset", "=", "first_anon_arg", ";", "if", "(", "!", "no_rtl", ")", "{", "rtx", "regblock", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "plus_constant", "(", "Pmode", ",", "arg_pointer_rtx", ",", "FIRST_PARM_OFFSET", "(", "0", ")", ")", ")", ";", "move_block_from_reg", "(", "first_reg_offset", ",", "regblock", ",", "MAX_ARC_PARM_REGS", "-", "first_reg_offset", ")", ";", "}", "*", "pretend_size", "=", "(", "(", "MAX_ARC_PARM_REGS", "-", "first_reg_offset", ")", "*", "UNITS_PER_WORD", ")", ";", "}", "}", "</s>"], "natrual_language": ["Do", "any", "needed", "setup", "for", "a", "variadic", "function", ".", "For", "the", "ARC", ",", "we", "must", "create", "a", "register", "parameter", "block", ",", "and", "then", "copy", "any", "anonymous", "arguments", "in", "registers", "to", "memory", ".", "CUM", "has", "not", "been", "updated", "for", "the", "last", "named", "argument", "which", "has", "type", "TYPE", "and", "mode", "MODE", ",", "and", "we", "rely", "on", "this", "fact", "."], "TS_V_token": ["arc", "1", "0"], "File": "arc4", "Func": "arc_setup_incoming_varargs", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33516, "Length": 119}
{"ground_truth": ["<s>", "void", "arc_set_default_type_attributes", "(", "tree", "type", "ATTRIBUTE_UNUSED", ")", "{", "gcc_unreachable", "(", ")", ";", "}", "</s>"], "natrual_language": ["Set", "the", "default", "attributes", "for", "TYPE", "."], "TS_V_token": ["arc"], "File": "arc4", "Func": "arc_set_default_type_attributes", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33517, "Length": 13}
{"ground_truth": ["<s>", "static", "rtx", "arc_trampoline_adjust_address", "(", "rtx", "addr", ")", "{", "return", "plus_constant", "(", "Pmode", ",", "addr", ",", "2", ")", ";", "}", "</s>"], "natrual_language": ["Allow", "the", "profiler", "to", "easily", "distinguish", "trampolines", "from", "normal", "functions", "."], "TS_V_token": ["arc", "2"], "File": "arc4", "Func": "arc_trampoline_adjust_address", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33518, "Length": 19}
{"ground_truth": ["<s>", "default_promote_function_mode_always_promote", "arc_use_by_pieces_infrastructure_p", "static", "int", "arc_sched_adjust_priority", "(", "rtx_insn", "*", "insn", ",", "int", "priority", ")", "{", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", "&&", "GET_MODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "DFmode", "&&", "GET_CODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "REG", ")", "{", "return", "priority", "+", "20", ";", "}", "return", "priority", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_USE_BY_PIECES_INFRASTRUCTURE_P", "."], "TS_V_token": ["arc", "20"], "File": "arc4", "Func": "arc_use_by_pieces_infrastructure_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33519, "Length": 57}
{"ground_truth": ["<s>", "static", "bool", "arc_vector_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "if", "(", "!", "TARGET_SIMD_SET", ")", "return", "false", ";", "if", "(", "(", "mode", "==", "V4SImode", ")", "||", "(", "mode", "==", "V8HImode", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Implements", "target", "hook", "vector_mode_supported_p", "."], "TS_V_token": ["arc"], "File": "arc4", "Func": "arc_vector_mode_supported_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33520, "Length": 37}
{"ground_truth": ["<s>", "int", "arc_verify_short", "(", "rtx_insn", "*", "insn", ",", "int", ",", "int", "check_attr", ")", "{", "enum", "attr_iscompact", "iscompact", ";", "struct", "machine_function", "*", "machine", ";", "if", "(", "check_attr", ">", "0", ")", "{", "iscompact", "=", "get_attr_iscompact", "(", "insn", ")", ";", "if", "(", "iscompact", "==", "ISCOMPACT_FALSE", ")", "return", "0", ";", "}", "machine", "=", "cfun", "->", "machine", ";", "if", "(", "machine", "->", "force_short_suffix", ">=", "0", ")", "return", "machine", "->", "force_short_suffix", ";", "return", "(", "get_attr_length", "(", "insn", ")", "&", "2", ")", "!=", "0", ";", "}", "</s>"], "natrual_language": ["Return", "non-zero", "if", "INSN", "should", "be", "output", "as", "a", "short", "insn", ".", "UNALIGN", "is", "zero", "if", "the", "current", "insn", "is", "aligned", "to", "a", "4-byte-boundary", ",", "two", "otherwise", ".", "If", "CHECK_ATTR", "is", "greater", "than", "0", ",", "check", "the", "iscompact", "attribute", "first", "."], "TS_V_token": ["arc", "0", "0", "0", "2", "0"], "File": "arc4", "Func": "arc_verify_short", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33521, "Length": 78}
{"ground_truth": ["<s>", "int", "branch_dest", "(", "rtx", "branch", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "branch", ")", ";", "rtx", "dest", "=", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", "?", "SET_SRC", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ")", ":", "SET_SRC", "(", "pat", ")", ")", ";", "int", "dest_uid", ";", "if", "(", "GET_CODE", "(", "dest", ")", "==", "IF_THEN_ELSE", ")", "dest", "=", "XEXP", "(", "dest", ",", "XEXP", "(", "dest", ",", "1", ")", "==", "pc_rtx", "?", "2", ":", "1", ")", ";", "dest", "=", "XEXP", "(", "dest", ",", "0", ")", ";", "dest_uid", "=", "INSN_UID", "(", "dest", ")", ";", "return", "INSN_ADDRESSES", "(", "dest_uid", ")", ";", "}", "</s>"], "natrual_language": ["Return", "the", "destination", "address", "of", "BRANCH", ".", "We", "need", "to", "use", "this", "instead", "of", "get_attr_length", ",", "because", "the", "cbranch_with_nops", "pattern", "conservatively", "sets", "its", "length", "to", "6", ",", "and", "we", "still", "prefer", "to", "use", "shorter", "sequences", "."], "TS_V_token": ["arc", "0", "0", "1", "2", "1", "0"], "File": "arc4", "Func": "branch_dest", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33522, "Length": 99}
{"ground_truth": ["<s>", "bool", "check_if_valid_regno_const", "(", "rtx", "*", "operands", ",", "int", "opno", ")", "{", "switch", "(", "GET_CODE", "(", "operands", "[", "opno", "]", ")", ")", "{", "case", "SYMBOL_REF", ":", "case", "CONST", ":", "case", "CONST_INT", ":", "return", "true", ";", "default", ":", "error", "(", "\"register number must be a compile-time constant. Try giving higher optimization levels\"", ")", ";", "break", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Returns", "true", "if", "the", "operands", "[", "opno", "]", "is", "a", "valid", "compile-time", "constant", "to", "be", "used", "as", "register", "number", "in", "the", "code", "for", "builtins", ".", "Else", "it", "flags", "an", "error", "and", "returns", "false", "."], "TS_V_token": ["arc", "\"register number must be a compile-time constant. Try giving higher optimization levels\""], "File": "arc4", "Func": "check_if_valid_regno_const", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33523, "Length": 48}
{"ground_truth": ["<s>", "bool", "check_if_valid_sleep_operand", "(", "rtx", "*", "operands", ",", "int", "opno", ")", "{", "switch", "(", "GET_CODE", "(", "operands", "[", "opno", "]", ")", ")", "{", "case", "CONST", ":", "case", "CONST_INT", ":", "if", "(", "UNSIGNED_INT6", "(", "INTVAL", "(", "operands", "[", "opno", "]", ")", ")", ")", "return", "true", ";", "default", ":", "fatal_error", "(", "input_location", ",", "\"operand for sleep instruction must be an unsigned 6 bit compile-time constant\"", ")", ";", "break", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Check", "that", "after", "all", "the", "constant", "folding", ",", "whether", "the", "operand", "to", "__builtin_arc_sleep", "is", "an", "unsigned", "int", "of", "6", "bits", ".", "If", "not", ",", "flag", "an", "error", "."], "TS_V_token": ["arc", "\"operand for sleep instruction must be an unsigned 6 bit compile-time constant\""], "File": "arc4", "Func": "check_if_valid_sleep_operand", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33524, "Length": 60}
{"ground_truth": ["<s>", "bool", "compact_sda_memory_operand", "(", "rtx", "op", ",", "machine_mode", "mode", ")", "{", "rtx", "addr", ";", "int", "size", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "false", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "GET_MODE", "(", "op", ")", ";", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "size", ">", "UNITS_PER_WORD", ")", "return", "false", ";", "addr", "=", "XEXP", "(", "op", ",", "0", ")", ";", "return", "LEGITIMATE_SMALL_DATA_ADDRESS_P", "(", "addr", ")", ";", "}", "</s>"], "natrual_language": ["volatile", "cache", "option", "still", "to", "be", "handled", "."], "TS_V_token": ["arc", "0"], "File": "arc4", "Func": "compact_sda_memory_operand", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33525, "Length": 73}
{"ground_truth": ["<s>", "static", "rtx", "conditionalize_nonjump", "(", "rtx", "pat", ",", "rtx", "cond", ",", "rtx", "insn", ",", "bool", "annulled", ")", "{", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SET", ")", "{", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "if", "(", "COMMUTATIVE_P", "(", "src", ")", ")", "{", "rtx", "src0", "=", "XEXP", "(", "src", ",", "0", ")", ";", "rtx", "src1", "=", "XEXP", "(", "src", ",", "1", ")", ";", "rtx", "dst", "=", "SET_DEST", "(", "pat", ")", ";", "if", "(", "rtx_equal_p", "(", "src1", ",", "dst", ")", "&&", "!", "rtx_equal_p", "(", "src0", ",", "dst", ")", "&&", "REG_P", "(", "src0", ")", ")", "pat", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "dst", ",", "gen_rtx_fmt_ee", "(", "GET_CODE", "(", "src", ")", ",", "GET_MODE", "(", "src", ")", ",", "src1", ",", "src0", ")", ")", ";", "}", "}", "if", "(", "RTX_FRAME_RELATED_P", "(", "insn", ")", ")", "{", "gcc_assert", "(", "annulled", ")", ";", "rtx", "note", "=", "alloc_reg_note", "(", "REG_FRAME_RELATED_EXPR", ",", "pat", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "validate_change", "(", "insn", ",", "&", "REG_NOTES", "(", "insn", ")", ",", "note", ",", "1", ")", ";", "}", "pat", "=", "gen_rtx_COND_EXEC", "(", "VOIDmode", ",", "cond", ",", "pat", ")", ";", "return", "pat", ";", "}", "</s>"], "natrual_language": ["Return", "version", "of", "PAT", "conditionalized", "with", "COND", ",", "which", "is", "part", "of", "INSN", ".", "ANNULLED", "indicates", "if", "INSN", "is", "an", "annulled", "delay-slot", "insn", ".", "Register", "further", "changes", "if", "necessary", "."], "TS_V_token": ["arc", "0", "1", "1"], "File": "arc4", "Func": "conditionalize_nonjump", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33526, "Length": 180}
{"ground_truth": ["<s>", "void", "emit_pic_move", "(", "rtx", "*", "operands", ",", "machine_mode", ")", "{", "rtx", "temp", "=", "reload_in_progress", "?", "operands", "[", "0", "]", ":", "gen_reg_rtx", "(", "Pmode", ")", ";", "if", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "MEM", "&&", "SYMBOLIC_CONST", "(", "operands", "[", "1", "]", ")", ")", "operands", "[", "1", "]", "=", "force_reg", "(", "Pmode", ",", "operands", "[", "1", "]", ")", ";", "else", "operands", "[", "1", "]", "=", "arc_legitimize_pic_address", "(", "operands", "[", "1", "]", ",", "temp", ")", ";", "}", "</s>"], "natrual_language": ["Emit", "insns", "to", "move", "operands", "[", "1", "]", "into", "operands", "[", "0", "]", "."], "TS_V_token": ["arc", "0", "0", "1", "1", "1", "1", "1"], "File": "arc4", "Func": "emit_pic_move", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33527, "Length": 77}
{"ground_truth": ["<s>", "static", "void", "emit_store_direct", "(", "rtx", "block", ",", "int", "offset", ",", "int", "value", ")", "{", "emit_insn", "(", "gen_store_direct", "(", "adjust_address", "(", "block", ",", "SImode", ",", "offset", ")", ",", "force_reg", "(", "SImode", ",", "gen_int_mode", "(", "value", ",", "SImode", ")", ")", ")", ")", ";", "}", "</s>"], "natrual_language": ["Directly", "store", "VALUE", "into", "memory", "object", "BLOCK", "at", "OFFSET", "."], "TS_V_token": ["arc"], "File": "arc4", "Func": "emit_store_direct", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33528, "Length": 42}
{"ground_truth": ["<s>", "static", "rtx", "force_offsettable", "(", "rtx", "addr", ",", "HOST_WIDE_INT", "size", ",", "bool", "reuse", ")", "{", "rtx", "base", "=", "addr", ";", "rtx", "offs", "=", "const0_rtx", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", ")", "{", "offs", "=", "XEXP", "(", "base", ",", "1", ")", ";", "base", "=", "XEXP", "(", "base", ",", "0", ")", ";", "}", "if", "(", "!", "REG_P", "(", "base", ")", "||", "(", "REGNO", "(", "base", ")", "!=", "STACK_POINTER_REGNUM", "&&", "REGNO_PTR_FRAME_P", "(", "REGNO", "(", "addr", ")", ")", ")", "||", "!", "CONST_INT_P", "(", "offs", ")", "||", "!", "SMALL_INT", "(", "INTVAL", "(", "offs", ")", ")", "||", "!", "SMALL_INT", "(", "INTVAL", "(", "offs", ")", "+", "size", ")", ")", "{", "if", "(", "reuse", ")", "emit_insn", "(", "gen_add2_insn", "(", "addr", ",", "offs", ")", ")", ";", "else", "addr", "=", "copy_to_mode_reg", "(", "Pmode", ",", "addr", ")", ";", "}", "return", "addr", ";", "}", "</s>"], "natrual_language": ["Helper", "function", "of", "arc_expand_movmem", ".", "ADDR", "points", "to", "a", "chunk", "of", "memory", ".", "Emit", "code", "and", "return", "an", "potentially", "modified", "address", "such", "that", "offsets", "up", "to", "SIZE", "are", "can", "be", "added", "to", "yield", "a", "legitimate", "address", ".", "if", "REUSE", "is", "set", ",", "ADDR", "is", "a", "register", "that", "may", "be", "modified", "."], "TS_V_token": ["arc", "1", "0"], "File": "arc4", "Func": "force_offsettable", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33529, "Length": 134}
{"ground_truth": ["<s>", "static", "rtx", "frame_move", "(", "rtx", "dst", ",", "rtx", "src", ")", "{", "return", "frame_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dst", ",", "src", ")", ")", ";", "}", "</s>"], "natrual_language": ["Emit", "a", "frame", "insn", "to", "move", "SRC", "to", "DST", "."], "TS_V_token": ["arc"], "File": "arc4", "Func": "frame_move", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33530, "Length": 25}
{"ground_truth": ["<s>", "rtx", "gen_mhi", "(", "void", ")", "{", "return", "gen_rtx_REG", "(", "SImode", ",", "TARGET_BIG_ENDIAN", "?", "58", ":", "59", ")", ";", "}", "</s>"], "natrual_language": ["Return", "a", "REG", "rtx", "for", "mhi", ".", "N.B", ".", "the", "gcc-internal", "representation", "may", "differ", "from", "the", "hardware", "register", "number", "in", "order", "to", "allow", "the", "generic", "code", "to", "correctly", "split", "the", "concatenation", "of", "mhi", "and", "mlo", "."], "TS_V_token": ["arc", "58", "59"], "File": "arc4", "Func": "gen_mhi", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33531, "Length": 19}
{"ground_truth": ["<s>", "rtx", "gen_mlo", "(", "void", ")", "{", "return", "gen_rtx_REG", "(", "SImode", ",", "TARGET_BIG_ENDIAN", "?", "59", ":", "58", ")", ";", "}", "</s>"], "natrual_language": ["Return", "a", "REG", "rtx", "for", "mlo", ".", "N.B", ".", "the", "gcc-internal", "representation", "may", "differ", "from", "the", "hardware", "register", "number", "in", "order", "to", "allow", "the", "generic", "code", "to", "correctly", "split", "the", "concatenation", "of", "mhi", "and", "mlo", "."], "TS_V_token": ["arc", "59", "58"], "File": "arc4", "Func": "gen_mlo", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33532, "Length": 19}
{"ground_truth": ["<s>", "static", "int", "get_arc_condition_code", "(", "rtx", "comparison", ")", "{", "switch", "(", "GET_MODE", "(", "XEXP", "(", "comparison", ",", "0", ")", ")", ")", "{", "case", "CCmode", ":", "case", "SImode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "EQ", ":", "return", "ARC_CC_EQ", ";", "case", "NE", ":", "return", "ARC_CC_NE", ";", "case", "GT", ":", "return", "ARC_CC_GT", ";", "case", "LE", ":", "return", "ARC_CC_LE", ";", "case", "GE", ":", "return", "ARC_CC_GE", ";", "case", "LT", ":", "return", "ARC_CC_LT", ";", "case", "GTU", ":", "return", "ARC_CC_HI", ";", "case", "LEU", ":", "return", "ARC_CC_LS", ";", "case", "LTU", ":", "return", "ARC_CC_LO", ";", "case", "GEU", ":", "return", "ARC_CC_HS", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "CC_ZNmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "EQ", ":", "return", "ARC_CC_EQ", ";", "case", "NE", ":", "return", "ARC_CC_NE", ";", "case", "GE", ":", "return", "ARC_CC_P", ";", "case", "LT", ":", "return", "ARC_CC_N", ";", "case", "GT", ":", "return", "ARC_CC_PNZ", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "CC_Zmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "EQ", ":", "return", "ARC_CC_EQ", ";", "case", "NE", ":", "return", "ARC_CC_NE", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "CC_Cmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "LTU", ":", "return", "ARC_CC_C", ";", "case", "GEU", ":", "return", "ARC_CC_NC", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "CC_FP_GTmode", ":", "if", "(", "TARGET_ARGONAUT_SET", "&&", "TARGET_SPFP", ")", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "GT", ":", "return", "ARC_CC_N", ";", "case", "UNLE", ":", "return", "ARC_CC_P", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "else", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "GT", ":", "return", "ARC_CC_HI", ";", "case", "UNLE", ":", "return", "ARC_CC_LS", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "CC_FP_GEmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "GE", ":", "return", "ARC_CC_HS", ";", "case", "UNLT", ":", "return", "ARC_CC_LO", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "CC_FP_UNEQmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "UNEQ", ":", "return", "ARC_CC_EQ", ";", "case", "LTGT", ":", "return", "ARC_CC_NE", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "CC_FP_ORDmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "UNORDERED", ":", "return", "ARC_CC_C", ";", "case", "ORDERED", ":", "return", "ARC_CC_NC", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "CC_FPXmode", ":", "switch", "(", "GET_CODE", "(", "comparison", ")", ")", "{", "case", "EQ", ":", "return", "ARC_CC_EQ", ";", "case", "NE", ":", "return", "ARC_CC_NE", ";", "case", "UNORDERED", ":", "return", "ARC_CC_C", ";", "case", "ORDERED", ":", "return", "ARC_CC_NC", ";", "case", "LTGT", ":", "return", "ARC_CC_HI", ";", "case", "UNEQ", ":", "return", "ARC_CC_LS", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "(", "42", ")", ";", "}", "</s>"], "natrual_language": ["Returns", "the", "index", "of", "the", "ARC", "condition", "code", "string", "in", "`", "arc_condition_codes", "'", ".", "COMPARISON", "should", "be", "an", "rtx", "like", "`", "(", "eq", "(", "...", ")", "(", "...", ")", ")", "'", "."], "TS_V_token": ["arc", "0", "42"], "File": "arc4", "Func": "get_arc_condition_code", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33533, "Length": 431}
{"ground_truth": ["<s>", "static", "void", "output_short_suffix", "(", "FILE", "*", "file", ")", "{", "rtx_insn", "*", "insn", "=", "current_output_insn", ";", "if", "(", "arc_verify_short", "(", "insn", ",", "cfun", "->", "machine", "->", "unalign", ",", "1", ")", ")", "{", "fprintf", "(", "file", ",", "\"_s\"", ")", ";", "cfun", "->", "machine", "->", "unalign", "^=", "2", ";", "}", "extract_insn_cached", "(", "insn", ")", ";", "}", "</s>"], "natrual_language": ["When", "outputting", "an", "instruction", "(", "alternative", ")", "that", "can", "potentially", "be", "short", ",", "output", "the", "short", "suffix", "if", "the", "insn", "is", "in", "fact", "short", ",", "and", "update", "cfun-", ">", "machine-", ">", "unalign", "accordingly", "."], "TS_V_token": ["arc", "1", "\"_s\"", "2"], "File": "arc4", "Func": "output_short_suffix", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33534, "Length": 53}
{"ground_truth": ["<s>", "bool", "prepare_extend_operands", "(", "rtx", "*", "operands", ",", "enum", "rtx_code", "code", ",", "machine_mode", "omode", ")", "{", "if", "(", "!", "TARGET_NO_SDATA_SET", "&&", "small_data_pattern", "(", "operands", "[", "1", "]", ",", "Pmode", ")", ")", "{", "operands", "[", "1", "]", "=", "gen_rtx_fmt_e", "(", "code", ",", "omode", ",", "arc_rewrite_small_data", "(", "operands", "[", "1", "]", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "omode", ",", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", ";", "set_unique_reg_note", "(", "get_last_insn", "(", ")", ",", "REG_EQUAL", ",", "operands", "[", "1", "]", ")", ";", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "operands", "[", "0", "]", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Prepare", "OPERANDS", "for", "an", "extension", "using", "CODE", "to", "OMODE", ".", "Return", "true", "iff", "the", "move", "has", "been", "emitted", "."], "TS_V_token": ["arc", "1", "1", "1", "0", "1", "1", "0", "0"], "File": "arc4", "Func": "prepare_extend_operands", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33535, "Length": 104}
{"ground_truth": ["<s>", "bool", "prepare_move_operands", "(", "rtx", "*", "operands", ",", "machine_mode", "mode", ")", "{", "if", "(", "1", ")", "{", "if", "(", "!", "TARGET_NO_SDATA_SET", "&&", "small_data_pattern", "(", "operands", "[", "0", "]", ",", "Pmode", ")", ")", "operands", "[", "0", "]", "=", "arc_rewrite_small_data", "(", "operands", "[", "0", "]", ")", ";", "else", "if", "(", "mode", "==", "SImode", "&&", "flag_pic", "&&", "SYMBOLIC_CONST", "(", "operands", "[", "1", "]", ")", ")", "{", "emit_pic_move", "(", "operands", ",", "SImode", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "!=", "MEM", "&&", "!", "TARGET_NO_SDATA_SET", "&&", "small_data_pattern", "(", "operands", "[", "1", "]", ",", "Pmode", ")", ")", "{", "operands", "[", "1", "]", "=", "arc_rewrite_small_data", "(", "operands", "[", "1", "]", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "mode", ",", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", ";", "set_unique_reg_note", "(", "get_last_insn", "(", ")", ",", "REG_EQUAL", ",", "operands", "[", "1", "]", ")", ";", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "operands", "[", "0", "]", ")", ";", "return", "true", ";", "}", "}", "if", "(", "MEM_P", "(", "operands", "[", "0", "]", ")", "&&", "!", "(", "reload_in_progress", "||", "reload_completed", ")", ")", "{", "operands", "[", "1", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "if", "(", "!", "move_dest_operand", "(", "operands", "[", "0", "]", ",", "mode", ")", ")", "{", "rtx", "addr", "=", "copy_to_mode_reg", "(", "Pmode", ",", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ")", ";", "rtx", "pat", "=", "change_address", "(", "operands", "[", "0", "]", ",", "mode", ",", "addr", ")", ";", "MEM_COPY_ATTRIBUTES", "(", "pat", ",", "operands", "[", "0", "]", ")", ";", "operands", "[", "0", "]", "=", "pat", ";", "}", "if", "(", "!", "cse_not_expected", ")", "{", "rtx", "pat", "=", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ";", "pat", "=", "arc_legitimize_address_0", "(", "pat", ",", "pat", ",", "mode", ")", ";", "if", "(", "pat", ")", "{", "pat", "=", "change_address", "(", "operands", "[", "0", "]", ",", "mode", ",", "pat", ")", ";", "MEM_COPY_ATTRIBUTES", "(", "pat", ",", "operands", "[", "0", "]", ")", ";", "operands", "[", "0", "]", "=", "pat", ";", "}", "}", "}", "if", "(", "MEM_P", "(", "operands", "[", "1", "]", ")", "&&", "!", "cse_not_expected", ")", "{", "rtx", "pat", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ";", "pat", "=", "arc_legitimize_address_0", "(", "pat", ",", "pat", ",", "mode", ")", ";", "if", "(", "pat", ")", "{", "pat", "=", "change_address", "(", "operands", "[", "1", "]", ",", "mode", ",", "pat", ")", ";", "MEM_COPY_ATTRIBUTES", "(", "pat", ",", "operands", "[", "1", "]", ")", ";", "operands", "[", "1", "]", "=", "pat", ";", "}", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Prepare", "operands", "for", "a", "move", "define_expand", "in", "MODE", "."], "TS_V_token": ["arc", "1", "0", "0", "0", "1", "0", "1", "1", "1", "0", "1", "1", "0", "0", "0", "1", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "1", "0", "1", "1", "1"], "File": "arc4", "Func": "prepare_move_operands", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33536, "Length": 407}
{"ground_truth": ["<s>", "bool", "small_data_pattern", "(", "rtx", "op", ",", "machine_mode", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "SEQUENCE", ")", "return", "false", ";", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "op", ",", "ALL", ")", "{", "const_rtx", "x", "=", "*", "iter", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "rtx_equal_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "pic_offset_table_rtx", ")", ")", "iter", ".", "skip_subrtxes", "(", ")", ";", "else", "if", "(", "arc_rewrite_small_data_p", "(", "x", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "OP", "refers", "to", "small", "data", "symbols", "directly", ",", "not", "through", "a", "PLUS", "."], "TS_V_token": ["arc", "0"], "File": "arc4", "Func": "small_data_pattern", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33537, "Length": 86}
{"ground_truth": ["<s>", "static", "hashval_t", "unspec_prof_hash", "(", "const", "void", "*", "x", ")", "{", "const_rtx", "u", "=", "(", "const_rtx", ")", "x", ";", "const_rtx", "s1", "=", "XVECEXP", "(", "u", ",", "0", ",", "1", ")", ";", "return", "(", "htab_hash_string", "(", "XSTR", "(", "XVECEXP", "(", "u", ",", "0", ",", "0", ")", ",", "0", ")", ")", "^", "(", "s1", "->", "code", "==", "SYMBOL_REF", "?", "htab_hash_string", "(", "XSTR", "(", "s1", ",", "0", ")", ")", ":", "0", ")", ")", ";", "}", "</s>"], "natrual_language": ["Hash", "function", "for", "UNSPEC_PROF", "htab", ".", "Use", "both", "the", "caller", "'s", "name", "and", "the", "callee", "'s", "name", "(", "if", "known", ")", "."], "TS_V_token": ["arc", "0", "1", "0", "0", "0", "0", "0"], "File": "arc4", "Func": "unspec_prof_hash", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33538, "Length": 71}
{"ground_truth": ["<s>", "static", "int", "unspec_prof_htab_eq", "(", "const", "void", "*", "x", ",", "const", "void", "*", "y", ")", "{", "const_rtx", "u0", "=", "(", "const_rtx", ")", "x", ";", "const_rtx", "u1", "=", "(", "const_rtx", ")", "y", ";", "const_rtx", "s01", "=", "XVECEXP", "(", "u0", ",", "0", ",", "1", ")", ";", "const_rtx", "s11", "=", "XVECEXP", "(", "u1", ",", "0", ",", "1", ")", ";", "return", "(", "!", "strcmp", "(", "XSTR", "(", "XVECEXP", "(", "u0", ",", "0", ",", "0", ")", ",", "0", ")", ",", "XSTR", "(", "XVECEXP", "(", "u1", ",", "0", ",", "0", ")", ",", "0", ")", ")", "&&", "rtx_equal_p", "(", "s01", ",", "s11", ")", ")", ";", "}", "</s>"], "natrual_language": ["Equality", "function", "for", "UNSPEC_PROF", "htab", ".", "Two", "pieces", "of", "UNSPEC_PROF", "rtl", "shall", "refer", "to", "the", "same", "counter", "if", "both", "caller", "name", "and", "callee", "rtl", "are", "identical", "."], "TS_V_token": ["arc", "0", "1", "0", "1", "0", "0", "0", "0", "0", "0"], "File": "arc4", "Func": "unspec_prof_htab_eq", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33539, "Length": 98}
{"ground_truth": ["<s>", "static", "void", "write_profile_sections", "(", "rtx", "dest", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ",", "void", "*", "data", ")", "{", "rtx", "*", "srcp", ",", "src", ";", "htab_t", "htab", "=", "(", "htab_t", ")", "data", ";", "rtx", "*", "slot", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "SET", ")", "return", ";", "srcp", "=", "&", "SET_SRC", "(", "x", ")", ";", "if", "(", "MEM_P", "(", "*", "srcp", ")", ")", "srcp", "=", "&", "XEXP", "(", "*", "srcp", ",", "0", ")", ";", "else", "if", "(", "MEM_P", "(", "SET_DEST", "(", "x", ")", ")", ")", "srcp", "=", "&", "XEXP", "(", "SET_DEST", "(", "x", ")", ",", "0", ")", ";", "src", "=", "*", "srcp", ";", "if", "(", "GET_CODE", "(", "src", ")", "!=", "CONST", ")", "return", ";", "src", "=", "XEXP", "(", "src", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "!=", "UNSPEC", "||", "XINT", "(", "src", ",", "1", ")", "!=", "UNSPEC_PROF", ")", "return", ";", "gcc_assert", "(", "XVECLEN", "(", "src", ",", "0", ")", "==", "3", ")", ";", "if", "(", "!", "htab_elements", "(", "htab", ")", ")", "{", "output_asm_insn", "(", "\".section .__arc_profile_desc, \\\"a\\\"\\n\"", "\"\\t.long %0 + 1\\n\"", ",", "&", "XVECEXP", "(", "src", ",", "0", ",", "0", ")", ")", ";", "}", "slot", "=", "(", "rtx", "*", ")", "htab_find_slot", "(", "htab", ",", "src", ",", "INSERT", ")", ";", "if", "(", "*", "slot", "==", "HTAB_EMPTY_ENTRY", ")", "{", "static", "int", "count_nr", ";", "char", "buf", "[", "24", "]", ";", "rtx", "count", ";", "*", "slot", "=", "src", ";", "sprintf", "(", "buf", ",", "\"__prof_count%d\"", ",", "count_nr", "++", ")", ";", "count", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "xstrdup", "(", "buf", ")", ")", ";", "XVECEXP", "(", "src", ",", "0", ",", "2", ")", "=", "count", ";", "output_asm_insn", "(", "\".section\\t.__arc_profile_desc, \\\"a\\\"\\n\"", "\"\\t.long\\t%1\\n\"", "\"\\t.section\\t.__arc_profile_counters, \\\"aw\\\"\\n\"", "\"\\t.type\\t%o2, @object\\n\"", "\"\\t.size\\t%o2, 4\\n\"", "\"%o2:\\t.zero 4\"", ",", "&", "XVECEXP", "(", "src", ",", "0", ",", "0", ")", ")", ";", "*", "srcp", "=", "count", ";", "}", "else", "*", "srcp", "=", "XVECEXP", "(", "*", "slot", ",", "0", ",", "2", ")", ";", "}", "</s>"], "natrual_language": ["Called", "via", "walk_stores", ".", "DATA", "points", "to", "a", "hash", "table", "we", "can", "use", "to", "establish", "a", "unique", "SYMBOL_REF", "for", "each", "counter", ",", "which", "corresponds", "to", "a", "caller-callee", "pair", ".", "X", "is", "a", "store", "which", "we", "want", "to", "examine", "for", "an", "UNSPEC_PROF", ",", "which", "would", "be", "an", "address", "loaded", "into", "a", "register", ",", "or", "directly", "used", "in", "a", "MEM", ".", "If", "we", "found", "an", "UNSPEC_PROF", ",", "if", "we", "encounter", "a", "new", "counter", "the", "first", "time", ",", "write", "out", "a", "description", "and", "a", "data", "allocation", "for", "a", "32", "bit", "counter", ".", "Also", ",", "fill", "in", "the", "appropriate", "symbol_ref", "into", "each", "UNSPEC_PROF", "instance", "."], "TS_V_token": ["arc", "0", "0", "0", "1", "0", "3", "\".section .__arc_profile_desc, \\\"a\\\"\\n\"", "\"\\t.long %0 + 1\\n\"", "0", "0", "24", "\"__prof_count%d\"", "0", "2", "\".section\\t.__arc_profile_desc, \\\"a\\\"\\n\"", "\"\\t.long\\t%1\\n\"", "\"\\t.section\\t.__arc_profile_counters, \\\"aw\\\"\\n\"", "\"\\t.type\\t%o2, @object\\n\"", "\"\\t.size\\t%o2, 4\\n\"", "\"%o2:\\t.zero 4\"", "0", "0", "0", "2"], "File": "arc4", "Func": "write_profile_sections", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33540, "Length": 294}
{"ground_truth": ["<s>", "enum", "arc_function_type", "arc_compute_function_type", "(", "struct", "function", "*", "fun", ")", "{", "tree", "decl", "=", "fun", "->", "decl", ";", "tree", "a", ";", "enum", "arc_function_type", "fn_type", "=", "fun", "->", "machine", "->", "fn_type", ";", "if", "(", "fn_type", "!=", "ARC_FUNCTION_UNKNOWN", ")", "return", "fn_type", ";", "fn_type", "=", "ARC_FUNCTION_NORMAL", ";", "for", "(", "a", "=", "DECL_ATTRIBUTES", "(", "decl", ")", ";", "a", ";", "a", "=", "TREE_CHAIN", "(", "a", ")", ")", "{", "tree", "name", "=", "TREE_PURPOSE", "(", "a", ")", ",", "args", "=", "TREE_VALUE", "(", "a", ")", ";", "if", "(", "name", "==", "get_identifier", "(", "\"interrupt\"", ")", "&&", "list_length", "(", "args", ")", "==", "1", "&&", "TREE_CODE", "(", "TREE_VALUE", "(", "args", ")", ")", "==", "STRING_CST", ")", "{", "tree", "value", "=", "TREE_VALUE", "(", "args", ")", ";", "if", "(", "!", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink1\"", ")", "||", "!", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink\"", ")", ")", "fn_type", "=", "ARC_FUNCTION_ILINK1", ";", "else", "if", "(", "!", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink2\"", ")", ")", "fn_type", "=", "ARC_FUNCTION_ILINK2", ";", "else", "gcc_unreachable", "(", ")", ";", "break", ";", "}", "}", "return", "fun", "->", "machine", "->", "fn_type", "=", "fn_type", ";", "}", "</s>"], "natrual_language": ["Type", "of", "function", "DECL", ".", "The", "result", "is", "cached", ".", "To", "reset", "the", "cache", "at", "the", "end", "of", "a", "function", ",", "call", "with", "DECL", "=", "NULL_TREE", "."], "TS_V_token": ["arc", "\"interrupt\"", "1", "\"ilink1\"", "\"ilink\"", "\"ilink2\""], "File": "arc5", "Func": "arc_compute_function_type", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33541, "Length": 177}
{"ground_truth": ["<s>", "static", "rtx", "arc_dwarf_register_span", "(", "rtx", "rtl", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "rtl", ")", ";", "unsigned", "regno", ";", "rtx", "p", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "!=", "8", ")", "return", "NULL_RTX", ";", "p", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "2", ")", ")", ";", "regno", "=", "REGNO", "(", "rtl", ")", ";", "XVECEXP", "(", "p", ",", "0", ",", "0", ")", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "XVECEXP", "(", "p", ",", "0", ",", "1", ")", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", "+", "1", ")", ";", "return", "p", ";", "}", "</s>"], "natrual_language": ["Return", "a", "parallel", "of", "registers", "to", "represent", "where", "to", "find", "the", "register", "pieces", "if", "required", ",", "otherwise", "NULL_RTX", "."], "TS_V_token": ["arc", "8", "2", "0", "0", "0", "1", "1"], "File": "arc5", "Func": "arc_dwarf_register_span", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33542, "Length": 92}
{"ground_truth": ["<s>", "static", "rtx", "arc_expand_builtin_aligned", "(", "tree", "exp", ")", "{", "tree", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "tree", "arg1", "=", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ";", "fold", "(", "arg1", ")", ";", "rtx", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "rtx", "op1", "=", "expand_expr", "(", "arg1", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "op1", ")", ")", "{", "if", "(", "optimize", ")", "warning", "(", "0", ",", "\"__builtin_arc_aligned with non-constant alignment\"", ")", ";", "}", "else", "{", "HOST_WIDE_INT", "alignTest", "=", "INTVAL", "(", "op1", ")", ";", "if", "(", "alignTest", "<=", "0", "||", "alignTest", "!=", "(", "alignTest", "&", "-", "alignTest", ")", ")", "{", "error", "(", "\"invalid alignment value for __builtin_arc_aligned\"", ")", ";", "return", "NULL_RTX", ";", "}", "if", "(", "CONST_INT_P", "(", "op0", ")", ")", "{", "HOST_WIDE_INT", "pnt", "=", "INTVAL", "(", "op0", ")", ";", "if", "(", "(", "pnt", "&", "(", "alignTest", "-", "1", ")", ")", "==", "0", ")", "return", "const1_rtx", ";", "}", "else", "{", "unsigned", "align", "=", "get_pointer_alignment", "(", "arg0", ")", ";", "unsigned", "numBits", "=", "alignTest", "*", "BITS_PER_UNIT", ";", "if", "(", "align", "&&", "align", ">=", "numBits", ")", "return", "const1_rtx", ";", "if", "(", "POINTER_TYPE_P", "(", "TREE_TYPE", "(", "arg0", ")", ")", "&&", "TYPE_ALIGN", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "arg0", ")", ")", ")", ">=", "numBits", ")", "return", "const1_rtx", ";", "}", "}", "return", "const0_rtx", ";", "}", "</s>"], "natrual_language": ["Helper", "to", "expand", "__builtin_arc_aligned", "(", "void", "*", "val", ",", "int", "alignval", ")", "."], "TS_V_token": ["arc", "0", "1", "0", "\"__builtin_arc_aligned with non-constant alignment\"", "0", "\"invalid alignment value for __builtin_arc_aligned\"", "1", "0"], "File": "arc5", "Func": "arc_expand_builtin_aligned", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33543, "Length": 211}
{"ground_truth": ["<s>", "bool", "arc_expand_movmem", "(", "rtx", "*", "operands", ")", "{", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "rtx", "dst_addr", ",", "src_addr", ";", "HOST_WIDE_INT", "size", ";", "int", "align", "=", "INTVAL", "(", "operands", "[", "3", "]", ")", ";", "unsigned", "n_pieces", ";", "int", "piece", "=", "align", ";", "rtx", "store", "[", "2", "]", ";", "rtx", "tmpx", "[", "2", "]", ";", "int", "i", ";", "if", "(", "!", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", ")", "return", "false", ";", "size", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "align", ">=", "4", ")", "{", "if", "(", "TARGET_LL64", ")", "n_pieces", "=", "(", "size", "+", "4", ")", "/", "8U", "+", "(", "(", "size", ">>", "1", ")", "&", "1", ")", "+", "(", "size", "&", "1", ")", ";", "else", "n_pieces", "=", "(", "size", "+", "2", ")", "/", "4U", "+", "(", "size", "&", "1", ")", ";", "}", "else", "if", "(", "align", "==", "2", ")", "n_pieces", "=", "(", "size", "+", "1", ")", "/", "2U", ";", "else", "n_pieces", "=", "size", ";", "if", "(", "n_pieces", ">=", "(", "unsigned", "int", ")", "(", "optimize_size", "?", "3", ":", "15", ")", ")", "return", "false", ";", "if", "(", "TARGET_LL64", "&&", "(", "piece", ">=", "4", ")", "&&", "(", "size", ">=", "8", ")", ")", "piece", "=", "8", ";", "else", "if", "(", "piece", ">", "4", ")", "piece", "=", "4", ";", "dst_addr", "=", "force_offsettable", "(", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ",", "size", ",", "0", ")", ";", "src_addr", "=", "force_offsettable", "(", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ",", "size", ",", "0", ")", ";", "store", "[", "0", "]", "=", "store", "[", "1", "]", "=", "NULL_RTX", ";", "tmpx", "[", "0", "]", "=", "tmpx", "[", "1", "]", "=", "NULL_RTX", ";", "for", "(", "i", "=", "0", ";", "size", ">", "0", ";", "i", "^=", "1", ",", "size", "-=", "piece", ")", "{", "rtx", "tmp", ";", "machine_mode", "mode", ";", "while", "(", "piece", ">", "size", ")", "piece", ">>=", "1", ";", "mode", "=", "smallest_mode_for_size", "(", "piece", "*", "BITS_PER_UNIT", ",", "MODE_INT", ")", ";", "if", "(", "0", "&&", "tmpx", "[", "i", "]", "&&", "GET_MODE", "(", "tmpx", "[", "i", "]", ")", "==", "mode", ")", "tmp", "=", "tmpx", "[", "i", "]", ";", "else", "tmpx", "[", "i", "]", "=", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "dst_addr", "=", "force_offsettable", "(", "dst_addr", ",", "piece", ",", "1", ")", ";", "src_addr", "=", "force_offsettable", "(", "src_addr", ",", "piece", ",", "1", ")", ";", "if", "(", "store", "[", "i", "]", ")", "emit_insn", "(", "store", "[", "i", "]", ")", ";", "emit_move_insn", "(", "tmp", ",", "change_address", "(", "src", ",", "mode", ",", "src_addr", ")", ")", ";", "store", "[", "i", "]", "=", "gen_move_insn", "(", "change_address", "(", "dst", ",", "mode", ",", "dst_addr", ")", ",", "tmp", ")", ";", "dst_addr", "=", "plus_constant", "(", "Pmode", ",", "dst_addr", ",", "piece", ")", ";", "src_addr", "=", "plus_constant", "(", "Pmode", ",", "src_addr", ",", "piece", ")", ";", "}", "if", "(", "store", "[", "i", "]", ")", "emit_insn", "(", "store", "[", "i", "]", ")", ";", "if", "(", "store", "[", "i", "^", "1", "]", ")", "emit_insn", "(", "store", "[", "i", "^", "1", "]", ")", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Like", "move_by_pieces", ",", "but", "take", "account", "of", "load", "latency", ",", "and", "actual", "offset", "ranges", ".", "Return", "true", "on", "success", "."], "TS_V_token": ["arc", "0", "1", "3", "2", "2", "2", "2", "4", "4", "8U", "1", "1", "1", "2", "4U", "1", "2", "1", "2U", "3", "15", "4", "8", "8", "4", "4", "0", "0", "0", "1", "0", "0", "0", "1", "0", "1", "0", "0", "1", "1", "0", "1", "1", "1", "1"], "File": "arc5", "Func": "arc_expand_movmem", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33544, "Length": 495}
{"ground_truth": ["<s>", "static", "void", "arc_finalize_pic", "(", "void", ")", "{", "rtx", "pat", ";", "rtx", "baseptr_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "PIC_OFFSET_TABLE_REGNUM", ")", ";", "if", "(", "crtl", "->", "uses_pic_offset_table", "==", "0", ")", "return", ";", "gcc_assert", "(", "flag_pic", "!=", "0", ")", ";", "pat", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"_DYNAMIC\"", ")", ";", "pat", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "pat", ")", ",", "ARC_UNSPEC_GOT", ")", ";", "pat", "=", "gen_rtx_CONST", "(", "Pmode", ",", "pat", ")", ";", "pat", "=", "gen_rtx_SET", "(", "baseptr_rtx", ",", "pat", ")", ";", "emit_insn", "(", "pat", ")", ";", "}", "</s>"], "natrual_language": ["If", "the", "function", "has", "any", "GOTOFF", "relocations", ",", "then", "the", "GOTBASE", "register", "has", "to", "be", "setup", "in", "the", "prologue", "The", "instruction", "needed", "at", "the", "function", "start", "for", "setting", "up", "the", "GOTBASE", "register", "is", "add", "rdest", ",", "pc", ",", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "The", "rtl", "to", "be", "emitted", "for", "this", "should", "be", ":", "set", "(", "reg", "basereg", ")", "(", "plus", "(", "reg", "pc", ")", "(", "const", "(", "unspec", "(", "symref", "_DYNAMIC", ")", "3", ")", ")", ")", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--"], "TS_V_token": ["arc", "0", "0", "\"_DYNAMIC\"", "1"], "File": "arc5", "Func": "arc_finalize_pic", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33545, "Length": 86}
{"ground_truth": ["<s>", "static", "tree", "arc_handle_interrupt_attribute", "(", "tree", "*", ",", "tree", "name", ",", "tree", "args", ",", "int", ",", "bool", "*", "no_add_attrs", ")", "{", "gcc_assert", "(", "args", ")", ";", "tree", "value", "=", "TREE_VALUE", "(", "args", ")", ";", "if", "(", "TREE_CODE", "(", "value", ")", "!=", "STRING_CST", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"argument of %qE attribute is not a string constant\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink1\"", ")", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink2\"", ")", "&&", "!", "TARGET_V2", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"argument of %qE attribute is not \\\"ilink1\\\" or \\\"ilink2\\\"\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "TARGET_V2", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink\"", ")", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"argument of %qE attribute is not \\\"ilink\\\"\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>"], "natrual_language": ["Handle", "an", "``", "interrupt", "''", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "."], "TS_V_token": ["arc", "\"argument of %qE attribute is not a string constant\"", "\"ilink1\"", "\"ilink2\"", "\"argument of %qE attribute is not \\\"ilink1\\\" or \\\"ilink2\\\"\"", "\"ilink\"", "\"argument of %qE attribute is not \\\"ilink\\\"\""], "File": "arc5", "Func": "arc_handle_interrupt_attribute", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33546, "Length": 135}
{"ground_truth": ["<s>", "int", "arc_hazard", "(", "rtx_insn", "*", "pred", ",", "rtx_insn", "*", "succ", ")", "{", "if", "(", "!", "pred", "||", "!", "INSN_P", "(", "pred", ")", "||", "!", "succ", "||", "!", "INSN_P", "(", "succ", ")", ")", "return", "0", ";", "if", "(", "arc_loop_hazard", "(", "pred", ",", "succ", ")", ")", "return", "4", ";", "if", "(", "TARGET_ARC600", ")", "return", "arc600_corereg_hazard", "(", "pred", ",", "succ", ")", ";", "return", "0", ";", "}", "</s>"], "natrual_language": ["For", "ARC600", ":", "A", "write", "to", "a", "core", "reg", "greater", "or", "equal", "to", "32", "must", "not", "be", "immediately", "followed", "by", "a", "use", ".", "Anticipate", "the", "length", "requirement", "to", "insert", "a", "nop", "between", "PRED", "and", "SUCC", "to", "prevent", "a", "hazard", "."], "TS_V_token": ["arc", "0", "4", "0"], "File": "arc5", "Func": "arc_hazard", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33547, "Length": 63}
{"ground_truth": ["<s>", "static", "void", "arc_init_reg_tables", "(", "void", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "NUM_MACHINE_MODES", ";", "i", "++", ")", "{", "machine_mode", "m", "=", "(", "machine_mode", ")", "i", ";", "switch", "(", "GET_MODE_CLASS", "(", "m", ")", ")", "{", "case", "MODE_INT", ":", "case", "MODE_PARTIAL_INT", ":", "case", "MODE_COMPLEX_INT", ":", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "<=", "4", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "S_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "8", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "D_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "16", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "T_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "32", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "O_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "case", "MODE_FLOAT", ":", "case", "MODE_COMPLEX_FLOAT", ":", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "<=", "4", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "SF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "8", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "DF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "16", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "TF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "32", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "OF_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "case", "MODE_VECTOR_INT", ":", "arc_mode_class", "[", "i", "]", "=", "(", "1", "<<", "(", "int", ")", "V_MODE", ")", ";", "break", ";", "case", "MODE_CC", ":", "default", ":", "if", "(", "i", "==", "(", "int", ")", "CCmode", "||", "i", "==", "(", "int", ")", "CC_ZNmode", "||", "i", "==", "(", "int", ")", "CC_Zmode", "||", "i", "==", "(", "int", ")", "CC_Cmode", "||", "i", "==", "CC_FP_GTmode", "||", "i", "==", "CC_FP_GEmode", "||", "i", "==", "CC_FP_ORDmode", "||", "i", "==", "CC_FPUmode", "||", "i", "==", "CC_FPU_UNEQmode", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "C_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "}", "}", "}", "</s>"], "natrual_language": ["Initialize", "the", "arc_mode_class", "array", "."], "TS_V_token": ["arc", "0", "4", "1", "8", "1", "16", "1", "32", "1", "0", "4", "1", "8", "1", "16", "1", "32", "1", "0", "1", "1", "0"], "File": "arc5", "Func": "arc_init_reg_tables", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33548, "Length": 348}
{"ground_truth": ["<s>", "static", "void", "arc_override_options", "(", "void", ")", "{", "if", "(", "arc_cpu", "==", "PROCESSOR_NONE", ")", "arc_cpu", "=", "PROCESSOR_ARC700", ";", "if", "(", "arc_size_opt_level", "==", "3", ")", "optimize_size", "=", "1", ";", "if", "(", "flag_pic", ")", "target_flags", "|=", "MASK_NO_SDATA_SET", ";", "if", "(", "flag_no_common", "==", "255", ")", "flag_no_common", "=", "!", "TARGET_NO_SDATA_SET", ";", "if", "(", "TARGET_MIXED_CODE", ")", "TARGET_Q_CLASS", "=", "1", ";", "if", "(", "!", "TARGET_Q_CLASS", ")", "TARGET_COMPACT_CASESI", "=", "0", ";", "if", "(", "TARGET_COMPACT_CASESI", ")", "TARGET_CASE_VECTOR_PC_RELATIVE", "=", "1", ";", "arc_init", "(", ")", ";", "}", "</s>"], "natrual_language": ["Check", "ARC", "options", ",", "generate", "derived", "target", "attributes", "."], "TS_V_token": ["arc", "3", "1", "255", "1", "0", "1"], "File": "arc5", "Func": "arc_override_options", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33549, "Length": 76}
{"ground_truth": ["<s>", "void", "arc_print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "register", "rtx", "base", ",", "index", "=", "0", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "fputs", "(", "reg_names", "[", "REGNO", "(", "addr", ")", "]", ",", "file", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "output_addr_const", "(", "file", ",", "addr", ")", ";", "if", "(", "SYMBOL_REF_SMALL_P", "(", "addr", ")", ")", "fprintf", "(", "file", ",", "\"@sda\"", ")", ";", "break", ";", "case", "PLUS", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "MULT", ")", "index", "=", "XEXP", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ",", "base", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "if", "(", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", "index", "=", "XEXP", "(", "addr", ",", "0", ")", ",", "base", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "base", "=", "XEXP", "(", "addr", ",", "0", ")", ",", "index", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "gcc_assert", "(", "OBJECT_P", "(", "base", ")", ")", ";", "arc_print_operand_address", "(", "file", ",", "base", ")", ";", "if", "(", "CONSTANT_P", "(", "base", ")", "&&", "CONST_INT_P", "(", "index", ")", ")", "fputc", "(", "'+'", ",", "file", ")", ";", "else", "fputc", "(", "','", ",", "file", ")", ";", "gcc_assert", "(", "OBJECT_P", "(", "index", ")", ")", ";", "arc_print_operand_address", "(", "file", ",", "index", ")", ";", "break", ";", "case", "CONST", ":", "{", "rtx", "c", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "c", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "c", ",", "1", ")", ")", "==", "CONST_INT", ")", ";", "output_address", "(", "VOIDmode", ",", "XEXP", "(", "addr", ",", "0", ")", ")", ";", "break", ";", "}", "case", "PRE_INC", ":", "case", "PRE_DEC", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "default", ":", "if", "(", "flag_pic", ")", "arc_output_pic_addr_const", "(", "file", ",", "addr", ",", "0", ")", ";", "else", "output_addr_const", "(", "file", ",", "addr", ")", ";", "break", ";", "}", "}", "</s>"], "natrual_language": ["Print", "a", "memory", "address", "as", "an", "operand", "to", "reference", "that", "memory", "location", "."], "TS_V_token": ["arc", "0", "\"@sda\"", "0", "0", "0", "1", "0", "0", "1", "0", "1", "0", "0", "1", "0", "0"], "File": "arc5", "Func": "arc_print_operand_address", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33550, "Length": 318}
{"ground_truth": ["<s>", "static", "bool", "arc_process_double_reg_moves", "(", "rtx", "*", "operands", ")", "{", "rtx", "dest", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "enum", "usesDxState", "{", "none", ",", "srcDx", ",", "destDx", ",", "maxDx", "}", ";", "enum", "usesDxState", "state", "=", "none", ";", "if", "(", "refers_to_regno_p", "(", "40", ",", "44", ",", "src", ",", "0", ")", ")", "state", "=", "srcDx", ";", "if", "(", "refers_to_regno_p", "(", "40", ",", "44", ",", "dest", ",", "0", ")", ")", "{", "gcc_assert", "(", "state", "==", "none", ")", ";", "state", "=", "destDx", ";", "}", "if", "(", "state", "==", "none", ")", "return", "false", ";", "if", "(", "state", "==", "srcDx", ")", "{", "if", "(", "TARGET_DPFP_DISABLE_LRSR", ")", "{", "rtx", "set", "=", "gen_rtx_SET", "(", "dest", ",", "src", ")", ";", "rtx", "use1", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "const1_rtx", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "set", ",", "use1", ")", ")", ")", ";", "}", "else", "{", "rtx", "destHigh", "=", "simplify_gen_subreg", "(", "SImode", ",", "dest", ",", "DFmode", ",", "4", ")", ";", "rtx", "destLow", "=", "simplify_gen_subreg", "(", "SImode", ",", "dest", ",", "DFmode", ",", "0", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "destHigh", ",", "gen_rtx_UNSPEC_VOLATILE", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "src", ")", ",", "VUNSPEC_ARC_LR_HIGH", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "destLow", ",", "gen_rtx_UNSPEC_VOLATILE", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "src", ")", ",", "VUNSPEC_ARC_LR", ")", ")", ")", ";", "}", "}", "else", "if", "(", "state", "==", "destDx", ")", "{", "rtx", "srcHigh", "=", "simplify_gen_subreg", "(", "SImode", ",", "src", ",", "DFmode", ",", "4", ")", ";", "rtx", "srcLow", "=", "simplify_gen_subreg", "(", "SImode", ",", "src", ",", "DFmode", ",", "0", ")", ";", "emit_insn", "(", "gen_rtx_UNSPEC_VOLATILE", "(", "Pmode", ",", "gen_rtvec", "(", "3", ",", "dest", ",", "srcHigh", ",", "srcLow", ")", ",", "VUNSPEC_ARC_DEXCL_NORES", ")", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Handle", "DOUBLE_REGS", "uses", ".", "Operand", "0", ":", "destination", "register", "Operand", "1", ":", "source", "register"], "TS_V_token": ["arc", "0", "1", "40", "44", "0", "40", "44", "0", "2", "4", "0", "1", "1", "4", "0", "3"], "File": "arc5", "Func": "arc_process_double_reg_moves", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33551, "Length": 288}
{"ground_truth": ["<s>", "static", "reg_class_t", "arc_secondary_reload", "(", "bool", "in_p", ",", "rtx", "x", ",", "reg_class_t", "cl", ",", "machine_mode", "mode", ",", "secondary_reload_info", "*", "sri", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "if", "(", "cl", "==", "DOUBLE_REGS", ")", "return", "GENERAL_REGS", ";", "if", "(", "(", "cl", "==", "LPCOUNT_REG", "||", "cl", "==", "WRITABLE_CORE_REGS", ")", "&&", "in_p", "&&", "MEM_P", "(", "x", ")", ")", "return", "GENERAL_REGS", ";", "if", "(", "code", "==", "SUBREG", ")", "{", "rtx", "addr", "=", "NULL_RTX", ";", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "if", "(", "REG_P", "(", "x", ")", ")", "{", "int", "regno", "=", "REGNO", "(", "x", ")", ";", "if", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "regno", "=", "reg_renumber", "[", "regno", "]", ";", "if", "(", "regno", "!=", "-", "1", ")", "return", "NO_REGS", ";", "if", "(", "reg_equiv_mem", "(", "REGNO", "(", "x", ")", ")", ")", "{", "rtx", "mem", "=", "reg_equiv_mem", "(", "REGNO", "(", "x", ")", ")", ";", "addr", "=", "find_replacement", "(", "&", "XEXP", "(", "mem", ",", "0", ")", ")", ";", "}", "}", "else", "{", "gcc_assert", "(", "MEM_P", "(", "x", ")", ")", ";", "addr", "=", "XEXP", "(", "x", ",", "0", ")", ";", "addr", "=", "simplify_rtx", "(", "addr", ")", ";", "}", "if", "(", "addr", "&&", "GET_CODE", "(", "addr", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "&&", "(", "!", "RTX_OK_FOR_OFFSET_P", "(", "mode", ",", "XEXP", "(", "addr", ",", "1", ")", ")", ")", ")", "{", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "sri", "->", "icode", "=", "in_p", "?", "CODE_FOR_reload_qi_load", ":", "CODE_FOR_reload_qi_store", ";", "break", ";", "case", "HImode", ":", "sri", "->", "icode", "=", "in_p", "?", "CODE_FOR_reload_hi_load", ":", "CODE_FOR_reload_hi_store", ";", "break", ";", "default", ":", "break", ";", "}", "}", "}", "return", "NO_REGS", ";", "}", "</s>"], "natrual_language": ["For", "ARC", "base", "register", "+", "offset", "addressing", ",", "the", "validity", "of", "the", "address", "is", "mode-dependent", "for", "most", "of", "the", "offset", "range", ",", "as", "the", "offset", "can", "be", "scaled", "by", "the", "access", "size", ".", "We", "do", "n't", "expose", "these", "as", "mode-dependent", "addresses", "in", "the", "mode_dependent_address_p", "target", "hook", ",", "because", "that", "would", "disable", "lots", "of", "optimizations", ",", "and", "most", "uses", "of", "these", "addresses", "are", "for", "32", "or", "64", "bit", "accesses", "anyways", ",", "which", "are", "fine", ".", "However", ",", "that", "leaves", "some", "addresses", "for", "8", "/", "16", "bit", "values", "not", "properly", "reloaded", "by", "the", "generic", "code", ",", "which", "is", "why", "we", "have", "to", "schedule", "secondary", "reloads", "for", "these", "."], "TS_V_token": ["arc", "1", "0", "0", "1", "1"], "File": "arc5", "Func": "arc_secondary_reload", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33552, "Length": 266}
{"ground_truth": ["<s>", "static", "void", "arc_setup_incoming_varargs", "(", "cumulative_args_t", "args_so_far", ",", "machine_mode", "mode", ",", "tree", "type", ",", "int", "*", "pretend_size", ",", "int", "no_rtl", ")", "{", "int", "first_anon_arg", ";", "CUMULATIVE_ARGS", "next_cum", ";", "next_cum", "=", "*", "get_cumulative_args", "(", "args_so_far", ")", ";", "arc_function_arg_advance", "(", "pack_cumulative_args", "(", "&", "next_cum", ")", ",", "mode", ",", "type", ",", "true", ")", ";", "first_anon_arg", "=", "next_cum", ";", "if", "(", "FUNCTION_ARG_REGNO_P", "(", "first_anon_arg", ")", ")", "{", "int", "first_reg_offset", "=", "first_anon_arg", ";", "if", "(", "!", "no_rtl", ")", "{", "rtx", "regblock", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "plus_constant", "(", "Pmode", ",", "arg_pointer_rtx", ",", "FIRST_PARM_OFFSET", "(", "0", ")", ")", ")", ";", "move_block_from_reg", "(", "first_reg_offset", ",", "regblock", ",", "MAX_ARC_PARM_REGS", "-", "first_reg_offset", ")", ";", "}", "*", "pretend_size", "=", "(", "(", "MAX_ARC_PARM_REGS", "-", "first_reg_offset", ")", "*", "UNITS_PER_WORD", ")", ";", "}", "}", "</s>"], "natrual_language": ["Do", "any", "needed", "setup", "for", "a", "variadic", "function", ".", "For", "the", "ARC", ",", "we", "must", "create", "a", "register", "parameter", "block", ",", "and", "then", "copy", "any", "anonymous", "arguments", "in", "registers", "to", "memory", ".", "CUM", "has", "not", "been", "updated", "for", "the", "last", "named", "argument", "which", "has", "type", "TYPE", "and", "mode", "MODE", ",", "and", "we", "rely", "on", "this", "fact", "."], "TS_V_token": ["arc", "0"], "File": "arc5", "Func": "arc_setup_incoming_varargs", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33553, "Length": 120}
{"ground_truth": ["<s>", "void", "arc_split_move", "(", "rtx", "*", "operands", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "int", "i", ";", "int", "swap", "=", "0", ";", "rtx", "xop", "[", "4", "]", ";", "if", "(", "TARGET_DPFP", ")", "{", "if", "(", "arc_process_double_reg_moves", "(", "operands", ")", ")", "return", ";", "}", "if", "(", "TARGET_LL64", "&&", "(", "(", "memory_operand", "(", "operands", "[", "0", "]", ",", "mode", ")", "&&", "even_register_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "||", "(", "memory_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", "&&", "even_register_operand", "(", "operands", "[", "0", "]", ",", "mode", ")", ")", ")", ")", "{", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "return", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "2", ";", "i", "++", ")", "{", "if", "(", "MEM_P", "(", "operands", "[", "i", "]", ")", "&&", "auto_inc_p", "(", "XEXP", "(", "operands", "[", "i", "]", ",", "0", ")", ")", ")", "{", "rtx", "addr", "=", "XEXP", "(", "operands", "[", "i", "]", ",", "0", ")", ";", "rtx", "r", ",", "o", ";", "enum", "rtx_code", "code", ";", "gcc_assert", "(", "!", "reg_overlap_mentioned_p", "(", "operands", "[", "0", "]", ",", "addr", ")", ")", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "PRE_DEC", ":", "o", "=", "GEN_INT", "(", "-", "8", ")", ";", "goto", "pre_modify", ";", "case", "PRE_INC", ":", "o", "=", "GEN_INT", "(", "8", ")", ";", "goto", "pre_modify", ";", "case", "PRE_MODIFY", ":", "o", "=", "XEXP", "(", "XEXP", "(", "addr", ",", "1", ")", ",", "1", ")", ";", "pre_modify", ":", "code", "=", "PRE_MODIFY", ";", "break", ";", "case", "POST_DEC", ":", "o", "=", "GEN_INT", "(", "-", "8", ")", ";", "goto", "post_modify", ";", "case", "POST_INC", ":", "o", "=", "GEN_INT", "(", "8", ")", ";", "goto", "post_modify", ";", "case", "POST_MODIFY", ":", "o", "=", "XEXP", "(", "XEXP", "(", "addr", ",", "1", ")", ",", "1", ")", ";", "post_modify", ":", "code", "=", "POST_MODIFY", ";", "swap", "=", "2", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "r", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "xop", "[", "0", "+", "i", "]", "=", "adjust_automodify_address_nv", "(", "operands", "[", "i", "]", ",", "SImode", ",", "gen_rtx_fmt_ee", "(", "code", ",", "Pmode", ",", "r", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "r", ",", "o", ")", ")", ",", "0", ")", ";", "xop", "[", "2", "+", "i", "]", "=", "adjust_automodify_address_nv", "(", "operands", "[", "i", "]", ",", "SImode", ",", "plus_constant", "(", "Pmode", ",", "r", ",", "4", ")", ",", "4", ")", ";", "}", "else", "{", "xop", "[", "0", "+", "i", "]", "=", "operand_subword", "(", "operands", "[", "i", "]", ",", "0", ",", "0", ",", "mode", ")", ";", "xop", "[", "2", "+", "i", "]", "=", "operand_subword", "(", "operands", "[", "i", "]", ",", "1", ",", "0", ",", "mode", ")", ";", "}", "}", "if", "(", "reg_overlap_mentioned_p", "(", "xop", "[", "0", "]", ",", "xop", "[", "3", "]", ")", ")", "{", "swap", "=", "2", ";", "gcc_assert", "(", "!", "reg_overlap_mentioned_p", "(", "xop", "[", "2", "]", ",", "xop", "[", "1", "]", ")", ")", ";", "}", "emit_move_insn", "(", "xop", "[", "0", "+", "swap", "]", ",", "xop", "[", "1", "+", "swap", "]", ")", ";", "emit_move_insn", "(", "xop", "[", "2", "-", "swap", "]", ",", "xop", "[", "3", "-", "swap", "]", ")", ";", "}", "</s>"], "natrual_language": ["operands", "0", "..", "1", "are", "the", "operands", "of", "a", "64", "bit", "move", "instruction", ".", "split", "it", "into", "two", "moves", "with", "operands", "2/3", "and", "4/5", "."], "TS_V_token": ["arc", "0", "0", "4", "0", "1", "1", "0", "0", "1", "0", "2", "0", "0", "0", "8", "8", "1", "1", "8", "8", "1", "1", "2", "0", "0", "0", "2", "4", "4", "0", "0", "0", "2", "1", "0", "0", "3", "2", "2", "1", "0", "1", "2", "3"], "File": "arc5", "Func": "arc_split_move", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33554, "Length": 506}
{"ground_truth": ["<s>", "static", "void", "emit_unlikely_jump", "(", "rtx", "insn", ")", "{", "int", "very_unlikely", "=", "REG_BR_PROB_BASE", "/", "100", "-", "1", ";", "insn", "=", "emit_jump_insn", "(", "insn", ")", ";", "add_int_reg_note", "(", "insn", ",", "REG_BR_PROB", ",", "very_unlikely", ")", ";", "}", "</s>"], "natrual_language": ["Mark", "the", "previous", "jump", "instruction", "as", "unlikely", "."], "TS_V_token": ["arc", "100", "1"], "File": "arc5", "Func": "emit_unlikely_jump", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33555, "Length": 34}
{"ground_truth": ["<s>", "bool", "prepare_extend_operands", "(", "rtx", "*", "operands", ",", "enum", "rtx_code", "code", ",", "machine_mode", "omode", ")", "{", "if", "(", "!", "TARGET_NO_SDATA_SET", "&&", "small_data_pattern", "(", "operands", "[", "1", "]", ",", "Pmode", ")", ")", "{", "operands", "[", "1", "]", "=", "gen_rtx_fmt_e", "(", "code", ",", "omode", ",", "arc_rewrite_small_data", "(", "operands", "[", "1", "]", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", ";", "set_unique_reg_note", "(", "get_last_insn", "(", ")", ",", "REG_EQUAL", ",", "operands", "[", "1", "]", ")", ";", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "operands", "[", "0", "]", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Prepare", "OPERANDS", "for", "an", "extension", "using", "CODE", "to", "OMODE", ".", "Return", "true", "iff", "the", "move", "has", "been", "emitted", "."], "TS_V_token": ["arc", "1", "1", "1", "0", "1", "1", "0", "0"], "File": "arc5", "Func": "prepare_extend_operands", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33556, "Length": 102}
{"ground_truth": ["<s>", "bool", "prepare_move_operands", "(", "rtx", "*", "operands", ",", "machine_mode", "mode", ")", "{", "if", "(", "1", ")", "{", "if", "(", "!", "TARGET_NO_SDATA_SET", "&&", "small_data_pattern", "(", "operands", "[", "0", "]", ",", "Pmode", ")", ")", "operands", "[", "0", "]", "=", "arc_rewrite_small_data", "(", "operands", "[", "0", "]", ")", ";", "else", "if", "(", "mode", "==", "SImode", "&&", "flag_pic", "&&", "SYMBOLIC_CONST", "(", "operands", "[", "1", "]", ")", ")", "{", "emit_pic_move", "(", "operands", ",", "SImode", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "!=", "MEM", "&&", "!", "TARGET_NO_SDATA_SET", "&&", "small_data_pattern", "(", "operands", "[", "1", "]", ",", "Pmode", ")", ")", "{", "operands", "[", "1", "]", "=", "arc_rewrite_small_data", "(", "operands", "[", "1", "]", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", ";", "set_unique_reg_note", "(", "get_last_insn", "(", ")", ",", "REG_EQUAL", ",", "operands", "[", "1", "]", ")", ";", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "operands", "[", "0", "]", ")", ";", "return", "true", ";", "}", "}", "if", "(", "MEM_P", "(", "operands", "[", "0", "]", ")", "&&", "!", "(", "reload_in_progress", "||", "reload_completed", ")", ")", "{", "operands", "[", "1", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "if", "(", "!", "move_dest_operand", "(", "operands", "[", "0", "]", ",", "mode", ")", ")", "{", "rtx", "addr", "=", "copy_to_mode_reg", "(", "Pmode", ",", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ")", ";", "rtx", "pat", "=", "change_address", "(", "operands", "[", "0", "]", ",", "mode", ",", "addr", ")", ";", "MEM_COPY_ATTRIBUTES", "(", "pat", ",", "operands", "[", "0", "]", ")", ";", "operands", "[", "0", "]", "=", "pat", ";", "}", "if", "(", "!", "cse_not_expected", ")", "{", "rtx", "pat", "=", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ";", "pat", "=", "arc_legitimize_address_0", "(", "pat", ",", "pat", ",", "mode", ")", ";", "if", "(", "pat", ")", "{", "pat", "=", "change_address", "(", "operands", "[", "0", "]", ",", "mode", ",", "pat", ")", ";", "MEM_COPY_ATTRIBUTES", "(", "pat", ",", "operands", "[", "0", "]", ")", ";", "operands", "[", "0", "]", "=", "pat", ";", "}", "}", "}", "if", "(", "MEM_P", "(", "operands", "[", "1", "]", ")", "&&", "!", "cse_not_expected", ")", "{", "rtx", "pat", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ";", "pat", "=", "arc_legitimize_address_0", "(", "pat", ",", "pat", ",", "mode", ")", ";", "if", "(", "pat", ")", "{", "pat", "=", "change_address", "(", "operands", "[", "1", "]", ",", "mode", ",", "pat", ")", ";", "MEM_COPY_ATTRIBUTES", "(", "pat", ",", "operands", "[", "1", "]", ")", ";", "operands", "[", "1", "]", "=", "pat", ";", "}", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Prepare", "operands", "for", "a", "move", "define_expand", "in", "MODE", "."], "TS_V_token": ["arc", "1", "0", "0", "0", "1", "0", "1", "1", "1", "0", "1", "1", "0", "0", "0", "1", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "1", "0", "1", "1", "1"], "File": "arc5", "Func": "prepare_move_operands", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33557, "Length": 405}
{"ground_truth": ["<s>", "static", "void", "workaround_arc_anomaly", "(", "void", ")", "{", "rtx_insn", "*", "insn", ",", "*", "succ0", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "succ0", "=", "next_real_insn", "(", "insn", ")", ";", "if", "(", "arc_hazard", "(", "insn", ",", "succ0", ")", ")", "{", "emit_insn_before", "(", "gen_nopv", "(", ")", ",", "succ0", ")", ";", "}", "}", "}", "</s>"], "natrual_language": ["The", "same", "functionality", "as", "arc_hazard", ".", "It", "is", "called", "in", "machine", "reorg", "before", "any", "other", "optimization", ".", "Hence", ",", "the", "NOP", "size", "is", "taken", "into", "account", "when", "doing", "branch", "shortening", "."], "TS_V_token": ["arc"], "File": "arc5", "Func": "workaround_arc_anomaly", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33558, "Length": 61}
{"ground_truth": ["<s>", "int", "arc_address_cost", "(", "rtx", "addr", ",", "machine_mode", ",", "addr_space_t", ",", "bool", "speed", ")", "{", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "return", "speed", "||", "satisfies_constraint_Rcq", "(", "addr", ")", "?", "0", ":", "1", ";", "case", "PRE_INC", ":", "case", "PRE_DEC", ":", "case", "POST_INC", ":", "case", "POST_DEC", ":", "case", "PRE_MODIFY", ":", "case", "POST_MODIFY", ":", "return", "!", "speed", ";", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "case", "CONST", ":", "if", "(", "TARGET_NPS_CMEM", "&&", "cmem_address", "(", "addr", ",", "SImode", ")", ")", "return", "0", ";", "return", "COSTS_N_INSNS", "(", "1", ")", ";", "case", "PLUS", ":", "{", "register", "rtx", "plus0", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "register", "rtx", "plus1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "plus0", ")", "!=", "REG", "&&", "(", "GET_CODE", "(", "plus0", ")", "!=", "MULT", "||", "!", "CONST_INT_P", "(", "XEXP", "(", "plus0", ",", "1", ")", ")", "||", "(", "INTVAL", "(", "XEXP", "(", "plus0", ",", "1", ")", ")", "!=", "2", "&&", "INTVAL", "(", "XEXP", "(", "plus0", ",", "1", ")", ")", "!=", "4", ")", ")", ")", "break", ";", "switch", "(", "GET_CODE", "(", "plus1", ")", ")", "{", "case", "CONST_INT", ":", "return", "(", "!", "RTX_OK_FOR_OFFSET_P", "(", "SImode", ",", "plus1", ")", "?", "COSTS_N_INSNS", "(", "1", ")", ":", "speed", "?", "0", ":", "(", "satisfies_constraint_Rcq", "(", "plus0", ")", "&&", "satisfies_constraint_O", "(", "plus1", ")", ")", "?", "0", ":", "1", ")", ";", "case", "REG", ":", "return", "(", "speed", "<", "1", "?", "0", ":", "(", "satisfies_constraint_Rcq", "(", "plus0", ")", "&&", "satisfies_constraint_Rcq", "(", "plus1", ")", ")", "?", "0", ":", "1", ")", ";", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "return", "COSTS_N_INSNS", "(", "1", ")", ";", "default", ":", "break", ";", "}", "break", ";", "}", "default", ":", "break", ";", "}", "return", "4", ";", "}", "</s>"], "natrual_language": ["Provide", "the", "costs", "of", "an", "addressing", "mode", "that", "contains", "ADDR", ".", "If", "ADDR", "is", "not", "a", "valid", "address", ",", "its", "cost", "is", "irrelevant", "."], "TS_V_token": ["arc", "0", "1", "0", "1", "0", "1", "1", "1", "2", "1", "4", "1", "0", "0", "1", "1", "0", "0", "1", "1", "4"], "File": "arc6", "Func": "arc_address_cost", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33559, "Length": 278}
{"ground_truth": ["<s>", "static", "unsigned", "int", "arc_autovectorize_vector_sizes", "(", "void", ")", "{", "return", "TARGET_PLUS_QMACW", "?", "(", "8", "|", "4", ")", ":", "0", ";", "}", "</s>"], "natrual_language": ["Implements", "target", "hook", "TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES", "."], "TS_V_token": ["arc", "8", "4", "0"], "File": "arc6", "Func": "arc_autovectorize_vector_sizes", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33560, "Length": 20}
{"ground_truth": ["<s>", "static", "rtx", "arc_emit_call_tls_get_addr", "(", "rtx", "sym", ",", "int", "reloc", ",", "rtx", "eqv", ")", "{", "rtx", "r0", "=", "gen_rtx_REG", "(", "Pmode", ",", "R0_REG", ")", ";", "rtx", "call_fusage", "=", "NULL_RTX", ";", "start_sequence", "(", ")", ";", "rtx", "x", "=", "arc_unspec_offset", "(", "sym", ",", "reloc", ")", ";", "emit_move_insn", "(", "r0", ",", "x", ")", ";", "use_reg", "(", "&", "call_fusage", ",", "r0", ")", ";", "gcc_assert", "(", "reloc", "==", "UNSPEC_TLS_GD", ")", ";", "rtx", "call_insn", "=", "emit_call_insn", "(", "gen_tls_gd_get_addr", "(", "sym", ")", ")", ";", "RTL_PURE_CALL_P", "(", "call_insn", ")", "=", "1", ";", "add_function_usage_to", "(", "call_insn", ",", "call_fusage", ")", ";", "rtx_insn", "*", "insns", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "rtx", "dest", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_libcall_block", "(", "insns", ",", "dest", ",", "r0", ",", "eqv", ")", ";", "return", "dest", ";", "}", "</s>"], "natrual_language": ["Helper", "to", "be", "used", "by", "TLS", "Global", "dynamic", "model", "."], "TS_V_token": ["arc", "1"], "File": "arc6", "Func": "arc_emit_call_tls_get_addr", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33561, "Length": 125}
{"ground_truth": ["<s>", "bool", "arc_epilogue_uses", "(", "int", "regno", ")", "{", "if", "(", "regno", "==", "arc_tp_regno", ")", "return", "true", ";", "if", "(", "reload_completed", ")", "{", "if", "(", "ARC_INTERRUPT_P", "(", "cfun", "->", "machine", "->", "fn_type", ")", ")", "{", "if", "(", "!", "fixed_regs", "[", "regno", "]", ")", "return", "true", ";", "return", "(", "(", "regno", "==", "arc_return_address_regs", "[", "cfun", "->", "machine", "->", "fn_type", "]", ")", "||", "(", "regno", "==", "RETURN_ADDR_REGNUM", ")", ")", ";", "}", "else", "return", "regno", "==", "RETURN_ADDR_REGNUM", ";", "}", "else", "return", "regno", "==", "arc_return_address_regs", "[", "arc_compute_function_type", "(", "cfun", ")", "]", ";", "}", "</s>"], "natrual_language": ["Implement", "EPILOGUE__USES", ".", "Return", "true", "if", "REGNO", "should", "be", "added", "to", "the", "deemed", "uses", "of", "the", "epilogue", ".", "We", "use", "the", "return", "address", "arc_return_address_regs", "[", "arc_compute_function_type", "(", "cfun", ")", "]", ".", "But", "also", ",", "we", "have", "to", "make", "sure", "all", "the", "register", "restore", "instructions", "are", "known", "to", "be", "live", "in", "interrupt", "functions", ",", "plus", "the", "blink", "register", "if", "it", "is", "clobbered", "by", "the", "isr", "."], "TS_V_token": ["arc"], "File": "arc6", "Func": "arc_epilogue_uses", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33562, "Length": 87}
{"ground_truth": ["<s>", "static", "void", "arc_finalize_pic", "(", "void", ")", "{", "rtx", "pat", ";", "rtx", "baseptr_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "PIC_OFFSET_TABLE_REGNUM", ")", ";", "if", "(", "crtl", "->", "uses_pic_offset_table", "==", "0", ")", "return", ";", "gcc_assert", "(", "flag_pic", "!=", "0", ")", ";", "pat", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"_DYNAMIC\"", ")", ";", "pat", "=", "arc_unspec_offset", "(", "pat", ",", "ARC_UNSPEC_GOT", ")", ";", "pat", "=", "gen_rtx_SET", "(", "baseptr_rtx", ",", "pat", ")", ";", "emit_insn", "(", "pat", ")", ";", "}", "</s>"], "natrual_language": ["If", "the", "function", "has", "any", "GOTOFF", "relocations", ",", "then", "the", "GOTBASE", "register", "has", "to", "be", "setup", "in", "the", "prologue", "The", "instruction", "needed", "at", "the", "function", "start", "for", "setting", "up", "the", "GOTBASE", "register", "is", "add", "rdest", ",", "pc", ",", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "The", "rtl", "to", "be", "emitted", "for", "this", "should", "be", ":", "set", "(", "reg", "basereg", ")", "(", "plus", "(", "reg", "pc", ")", "(", "const", "(", "unspec", "(", "symref", "_DYNAMIC", ")", "3", ")", ")", ")", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--"], "TS_V_token": ["arc", "0", "0", "\"_DYNAMIC\""], "File": "arc6", "Func": "arc_finalize_pic", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33563, "Length": 70}
{"ground_truth": ["<s>", "static", "rtx", "arc_get_tp", "(", "void", ")", "{", "if", "(", "arc_tp_regno", "!=", "-", "1", ")", "return", "gen_rtx_REG", "(", "Pmode", ",", "arc_tp_regno", ")", ";", "rtx", "reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_tls_load_tp_soft", "(", ")", ")", ";", "emit_move_insn", "(", "reg", ",", "gen_rtx_REG", "(", "Pmode", ",", "R0_REG", ")", ")", ";", "return", "reg", ";", "}", "</s>"], "natrual_language": ["Get", "the", "thread", "pointer", "."], "TS_V_token": ["arc", "1"], "File": "arc6", "Func": "arc_get_tp", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33564, "Length": 53}
{"ground_truth": ["<s>", "static", "void", "arc_init", "(", "void", ")", "{", "if", "(", "TARGET_V2", ")", "{", "if", "(", "TARGET_MPYW", "||", "TARGET_MULTI", ")", "arc_multcost", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "}", "if", "(", "arc_multcost", "<", "0", ")", "switch", "(", "arc_tune", ")", "{", "case", "TUNE_ARC700_4_2_STD", ":", "arc_multcost", "=", "COSTS_N_INSNS", "(", "4", ")", ";", "if", "(", "TARGET_NOMPY_SET", ")", "arc_multcost", "=", "COSTS_N_INSNS", "(", "30", ")", ";", "break", ";", "case", "TUNE_ARC700_4_2_XMAC", ":", "arc_multcost", "=", "COSTS_N_INSNS", "(", "3", ")", ";", "if", "(", "TARGET_NOMPY_SET", ")", "arc_multcost", "=", "COSTS_N_INSNS", "(", "30", ")", ";", "break", ";", "case", "TUNE_ARC600", ":", "if", "(", "TARGET_MUL64_SET", ")", "{", "arc_multcost", "=", "COSTS_N_INSNS", "(", "4", ")", ";", "break", ";", "}", "default", ":", "arc_multcost", "=", "COSTS_N_INSNS", "(", "30", ")", ";", "break", ";", "}", "if", "(", "TARGET_NOMPY_SET", "&&", "TARGET_ARC600_FAMILY", ")", "error", "(", "\"-mno-mpy supported only for ARC700 or ARCv2\"", ")", ";", "if", "(", "!", "TARGET_DPFP", "&&", "TARGET_DPFP_DISABLE_LRSR", ")", "error", "(", "\"-mno-dpfp-lrsr supported only with -mdpfp\"", ")", ";", "if", "(", "(", "TARGET_DPFP_FAST_SET", "&&", "TARGET_DPFP_COMPACT_SET", ")", "||", "(", "TARGET_SPFP_FAST_SET", "&&", "TARGET_SPFP_COMPACT_SET", ")", ")", "error", "(", "\"FPX fast and compact options cannot be specified together\"", ")", ";", "if", "(", "TARGET_SPFP_FAST_SET", "&&", "TARGET_ARC600_FAMILY", ")", "error", "(", "\"-mspfp_fast not available on ARC600 or ARC601\"", ")", ";", "if", "(", "(", "TARGET_DPFP_FAST_SET", "||", "TARGET_DPFP_COMPACT_SET", "||", "TARGET_SPFP", ")", "&&", "TARGET_HARD_FLOAT", ")", "error", "(", "\"No FPX/FPU mixing allowed\"", ")", ";", "if", "(", "flag_pic", "&&", "TARGET_ARC600_FAMILY", ")", "{", "warning", "(", "DK_WARNING", ",", "\"PIC is not supported for %s. Generating non-PIC code only..\"", ",", "arc_cpu_string", ")", ";", "flag_pic", "=", "0", ";", "}", "arc_init_reg_tables", "(", ")", ";", "memset", "(", "arc_punct_chars", ",", "0", ",", "sizeof", "(", "arc_punct_chars", ")", ")", ";", "arc_punct_chars", "[", "'#'", "]", "=", "1", ";", "arc_punct_chars", "[", "'*'", "]", "=", "1", ";", "arc_punct_chars", "[", "'?'", "]", "=", "1", ";", "arc_punct_chars", "[", "'!'", "]", "=", "1", ";", "arc_punct_chars", "[", "'^'", "]", "=", "1", ";", "arc_punct_chars", "[", "'&'", "]", "=", "1", ";", "arc_punct_chars", "[", "'+'", "]", "=", "1", ";", "arc_punct_chars", "[", "'_'", "]", "=", "1", ";", "if", "(", "optimize", ">", "1", "&&", "!", "TARGET_NO_COND_EXEC", ")", "{", "opt_pass", "*", "pass_arc_ifcvt_4", "=", "make_pass_arc_ifcvt", "(", "g", ")", ";", "struct", "register_pass_info", "arc_ifcvt4_info", "=", "{", "pass_arc_ifcvt_4", ",", "\"dbr\"", ",", "1", ",", "PASS_POS_INSERT_AFTER", "}", ";", "struct", "register_pass_info", "arc_ifcvt5_info", "=", "{", "pass_arc_ifcvt_4", "->", "clone", "(", ")", ",", "\"shorten\"", ",", "1", ",", "PASS_POS_INSERT_BEFORE", "}", ";", "register_pass", "(", "&", "arc_ifcvt4_info", ")", ";", "register_pass", "(", "&", "arc_ifcvt5_info", ")", ";", "}", "if", "(", "flag_delayed_branch", ")", "{", "opt_pass", "*", "pass_arc_predicate_delay_insns", "=", "make_pass_arc_predicate_delay_insns", "(", "g", ")", ";", "struct", "register_pass_info", "arc_predicate_delay_info", "=", "{", "pass_arc_predicate_delay_insns", ",", "\"dbr\"", ",", "1", ",", "PASS_POS_INSERT_AFTER", "}", ";", "register_pass", "(", "&", "arc_predicate_delay_info", ")", ";", "}", "}", "</s>"], "natrual_language": ["Called", "by", "OVERRIDE_OPTIONS", "to", "initialize", "various", "things", "."], "TS_V_token": ["arc", "1", "0", "4", "30", "3", "30", "4", "30", "\"-mno-mpy supported only for ARC700 or ARCv2\"", "\"-mno-dpfp-lrsr supported only with -mdpfp\"", "\"FPX fast and compact options cannot be specified together\"", "\"-mspfp_fast not available on ARC600 or ARC601\"", "\"No FPX/FPU mixing allowed\"", "\"PIC is not supported for %s. Generating non-PIC code only..\"", "0", "0", "1", "1", "1", "1", "1", "1", "1", "1", "1", "\"dbr\"", "1", "\"shorten\"", "1", "\"dbr\"", "1"], "File": "arc6", "Func": "arc_init", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33565, "Length": 376}
{"ground_truth": ["<s>", "static", "void", "arc_init_reg_tables", "(", "void", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "NUM_MACHINE_MODES", ";", "i", "++", ")", "{", "machine_mode", "m", "=", "(", "machine_mode", ")", "i", ";", "switch", "(", "GET_MODE_CLASS", "(", "m", ")", ")", "{", "case", "MODE_INT", ":", "case", "MODE_PARTIAL_INT", ":", "case", "MODE_COMPLEX_INT", ":", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "<=", "4", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "S_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "8", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "D_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "16", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "T_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "32", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "O_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "case", "MODE_FLOAT", ":", "case", "MODE_COMPLEX_FLOAT", ":", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "<=", "4", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "SF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "8", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "DF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "16", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "TF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "32", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "OF_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "case", "MODE_VECTOR_INT", ":", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "4", ")", "arc_mode_class", "[", "i", "]", "=", "(", "1", "<<", "(", "int", ")", "S_MODE", ")", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "8", ")", "arc_mode_class", "[", "i", "]", "=", "(", "1", "<<", "(", "int", ")", "D_MODE", ")", ";", "else", "arc_mode_class", "[", "i", "]", "=", "(", "1", "<<", "(", "int", ")", "V_MODE", ")", ";", "break", ";", "case", "MODE_CC", ":", "default", ":", "if", "(", "i", "==", "(", "int", ")", "CCmode", "||", "i", "==", "(", "int", ")", "CC_ZNmode", "||", "i", "==", "(", "int", ")", "CC_Zmode", "||", "i", "==", "(", "int", ")", "CC_Cmode", "||", "i", "==", "CC_FP_GTmode", "||", "i", "==", "CC_FP_GEmode", "||", "i", "==", "CC_FP_ORDmode", "||", "i", "==", "CC_FPUmode", "||", "i", "==", "CC_FPU_UNEQmode", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "C_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "}", "}", "}", "</s>"], "natrual_language": ["Initialize", "the", "arc_mode_class", "array", "."], "TS_V_token": ["arc", "0", "4", "1", "8", "1", "16", "1", "32", "1", "0", "4", "1", "8", "1", "16", "1", "32", "1", "0", "4", "1", "8", "1", "1", "1", "0"], "File": "arc6", "Func": "arc_init_reg_tables", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33566, "Length": 396}
{"ground_truth": ["<s>", "int", "arc_label_align", "(", "rtx_insn", "*", "label", ")", "{", "int", "loop_align", "=", "LOOP_ALIGN", "(", "LABEL", ")", ";", "if", "(", "loop_align", ">", "align_labels_log", ")", "{", "rtx_insn", "*", "prev", "=", "prev_nonnote_insn", "(", "label", ")", ";", "if", "(", "prev", "&&", "NONJUMP_INSN_P", "(", "prev", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "prev", ")", ")", "==", "PARALLEL", "&&", "recog_memoized", "(", "prev", ")", "==", "CODE_FOR_doloop_begin_i", ")", "return", "loop_align", ";", "}", "if", "(", "align_labels_log", "<", "1", ")", "{", "rtx_insn", "*", "next", "=", "next_nonnote_nondebug_insn", "(", "label", ")", ";", "if", "(", "INSN_P", "(", "next", ")", "&&", "recog_memoized", "(", "next", ")", ">=", "0", ")", "return", "1", ";", "}", "return", "align_labels_log", ";", "}", "</s>"], "natrual_language": ["Oddly", "enough", ",", "sometimes", "we", "get", "a", "zero", "overhead", "loop", "that", "branch", "shortening", "does", "n't", "think", "is", "a", "loop", "-", "observed", "with", "compile/pr24883.c", "-O3", "-fomit-frame-pointer", "-funroll-loops", ".", "Make", "sure", "to", "include", "the", "alignment", "visible", "for", "branch", "shortening", "(", "we", "actually", "align", "the", "loop", "insn", "before", "it", ",", "but", "that", "is", "equivalent", "since", "the", "loop", "insn", "is", "4", "byte", "long", ".", ")"], "TS_V_token": ["arc", "1", "0", "1"], "File": "arc6", "Func": "arc_label_align", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33567, "Length": 100}
{"ground_truth": ["<s>", "bool", "arc_legitimate_constant_p", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ")", "return", "false", ";", "if", "(", "!", "flag_pic", "&&", "mode", "!=", "Pmode", ")", "return", "true", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST", ":", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "if", "(", "flag_pic", "?", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "!=", "CONST_INT", ":", "!", "arc_legitimate_constant_p", "(", "mode", ",", "XEXP", "(", "x", ",", "1", ")", ")", ")", "return", "false", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", ")", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "case", "ARC_UNSPEC_PLT", ":", "case", "ARC_UNSPEC_GOTOFF", ":", "case", "ARC_UNSPEC_GOTOFFPC", ":", "case", "ARC_UNSPEC_GOT", ":", "case", "UNSPEC_TLS_GD", ":", "case", "UNSPEC_TLS_IE", ":", "case", "UNSPEC_TLS_OFF", ":", "return", "true", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "arc_raw_symbolic_reference_mentioned_p", "(", "x", ",", "false", ")", ")", "return", "false", ";", "break", ";", "case", "SYMBOL_REF", ":", "if", "(", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ")", "return", "false", ";", "case", "LABEL_REF", ":", "if", "(", "flag_pic", ")", "return", "false", ";", "default", ":", "break", ";", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["Determine", "if", "a", "given", "RTX", "is", "a", "valid", "constant", ".", "We", "already", "know", "this", "satisfies", "CONSTANT_P", "."], "TS_V_token": ["arc", "0", "1", "1", "0", "1"], "File": "arc6", "Func": "arc_legitimate_constant_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33568, "Length": 207}
{"ground_truth": ["<s>", "bool", "arc_legitimate_pc_offset_p", "(", "rtx", "addr", ")", "{", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "CONST", ")", "return", "false", ";", "return", "arc_needs_pcl_p", "(", "addr", ")", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "ADDR", "is", "an", "address", "that", "needs", "to", "be", "expressed", "as", "an", "explicit", "sum", "of", "pcl", "+", "offset", "."], "TS_V_token": ["arc"], "File": "arc6", "Func": "arc_legitimate_pc_offset_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33569, "Length": 26}
{"ground_truth": ["<s>", "bool", "arc_legitimate_pic_addr_p", "(", "rtx", "addr", ")", "{", "if", "(", "GET_CODE", "(", "addr", ")", "==", "LABEL_REF", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "CONST", ")", "return", "false", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "!=", "CONST_INT", ")", "return", "false", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "UNSPEC", "||", "XVECLEN", "(", "addr", ",", "0", ")", "!=", "1", ")", "return", "false", ";", "if", "(", "XINT", "(", "addr", ",", "1", ")", "!=", "ARC_UNSPEC_GOT", "&&", "XINT", "(", "addr", ",", "1", ")", "!=", "ARC_UNSPEC_GOTOFF", "&&", "XINT", "(", "addr", ",", "1", ")", "!=", "ARC_UNSPEC_GOTOFFPC", "&&", "XINT", "(", "addr", ",", "1", ")", "!=", "UNSPEC_TLS_GD", "&&", "XINT", "(", "addr", ",", "1", ")", "!=", "UNSPEC_TLS_IE", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "XVECEXP", "(", "addr", ",", "0", ",", "0", ")", ")", "!=", "SYMBOL_REF", "&&", "GET_CODE", "(", "XVECEXP", "(", "addr", ",", "0", ",", "0", ")", ")", "!=", "LABEL_REF", ")", "return", "false", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "ADDR", "is", "a", "valid", "pic", "address", ".", "A", "valid", "pic", "address", "on", "arc", "should", "look", "like", "const", "(", "unspec", "(", "SYMBOL_REF/LABEL", ")", "(", "ARC_UNSPEC_GOTOFF/ARC_UNSPEC_GOT", ")", ")"], "TS_V_token": ["arc", "0", "1", "0", "0", "1", "1", "1", "1", "1", "1", "0", "0", "0", "0"], "File": "arc6", "Func": "arc_legitimate_pic_addr_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33570, "Length": 185}
{"ground_truth": ["<s>", "static", "rtx", "arc_legitimize_tls_address", "(", "rtx", "addr", ",", "enum", "tls_model", "model", ")", "{", "if", "(", "!", "flag_pic", "&&", "model", "==", "TLS_MODEL_LOCAL_DYNAMIC", ")", "model", "=", "TLS_MODEL_LOCAL_EXEC", ";", "switch", "(", "model", ")", "{", "case", "TLS_MODEL_LOCAL_DYNAMIC", ":", "rtx", "base", ";", "tree", "decl", ";", "const", "char", "*", "base_name", ";", "rtvec", "v", ";", "decl", "=", "SYMBOL_REF_DECL", "(", "addr", ")", ";", "base_name", "=", "DTPOFF_ZERO_SYM", ";", "if", "(", "decl", "&&", "bss_initializer_p", "(", "decl", ")", ")", "base_name", "=", "\".tbss\"", ";", "base", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "base_name", ")", ";", "if", "(", "strcmp", "(", "base_name", ",", "DTPOFF_ZERO_SYM", ")", "==", "0", ")", "{", "if", "(", "!", "flag_pic", ")", "goto", "local_exec", ";", "v", "=", "gen_rtvec", "(", "1", ",", "addr", ")", ";", "}", "else", "v", "=", "gen_rtvec", "(", "2", ",", "addr", ",", "base", ")", ";", "addr", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "v", ",", "UNSPEC_TLS_OFF", ")", ";", "addr", "=", "gen_rtx_CONST", "(", "Pmode", ",", "addr", ")", ";", "base", "=", "arc_legitimize_tls_address", "(", "base", ",", "TLS_MODEL_GLOBAL_DYNAMIC", ")", ";", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "force_reg", "(", "Pmode", ",", "base", ")", ",", "addr", ")", ";", "case", "TLS_MODEL_GLOBAL_DYNAMIC", ":", "return", "arc_emit_call_tls_get_addr", "(", "addr", ",", "UNSPEC_TLS_GD", ",", "addr", ")", ";", "case", "TLS_MODEL_INITIAL_EXEC", ":", "addr", "=", "arc_unspec_offset", "(", "addr", ",", "UNSPEC_TLS_IE", ")", ";", "addr", "=", "copy_to_mode_reg", "(", "Pmode", ",", "gen_const_mem", "(", "Pmode", ",", "addr", ")", ")", ";", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "arc_get_tp", "(", ")", ",", "addr", ")", ";", "case", "TLS_MODEL_LOCAL_EXEC", ":", "local_exec", ":", "addr", "=", "arc_unspec_offset", "(", "addr", ",", "UNSPEC_TLS_OFF", ")", ";", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "arc_get_tp", "(", ")", ",", "addr", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Return", "a", "legitimized", "address", "for", "ADDR", ",", "which", "is", "a", "SYMBOL_REF", "with", "tls_model", "MODEL", "."], "TS_V_token": ["arc", "\".tbss\"", "0", "1", "2"], "File": "arc6", "Func": "arc_legitimize_tls_address", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33571, "Length": 251}
{"ground_truth": ["<s>", "static", "bool", "arc_needs_pcl_p", "(", "rtx", "x", ")", "{", "register", "const", "char", "*", "fmt", ";", "register", "int", "i", ",", "j", ";", "if", "(", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", ")", "&&", "(", "XVECLEN", "(", "x", ",", "0", ")", "==", "1", ")", "&&", "(", "GET_CODE", "(", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", ")", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "case", "ARC_UNSPEC_GOT", ":", "case", "ARC_UNSPEC_GOTOFFPC", ":", "case", "UNSPEC_TLS_GD", ":", "case", "UNSPEC_TLS_IE", ":", "return", "true", ";", "default", ":", "break", ";", "}", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "x", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "x", ")", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'e'", ")", "{", "if", "(", "arc_needs_pcl_p", "(", "XEXP", "(", "x", ",", "i", ")", ")", ")", "return", "true", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "for", "(", "j", "=", "XVECLEN", "(", "x", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "if", "(", "arc_needs_pcl_p", "(", "XVECEXP", "(", "x", ",", "i", ",", "j", ")", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Helper", "used", "by", "arc_legitimate_pc_offset_p", "."], "TS_V_token": ["arc", "0", "1", "0", "0", "1", "1", "0", "1", "0"], "File": "arc6", "Func": "arc_needs_pcl_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33572, "Length": 198}
{"ground_truth": ["<s>", "int", "arc_output_addsi", "(", "rtx", "*", "operands", ",", "bool", "cond_p", ",", "bool", "output_p", ")", "{", "char", "format", "[", "35", "]", ";", "int", "match", "=", "operands_match_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "int", "match2", "=", "operands_match_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ")", ";", "int", "intval", "=", "(", "REG_P", "(", "operands", "[", "2", "]", ")", "?", "1", ":", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", "?", "INTVAL", "(", "operands", "[", "2", "]", ")", ":", "0xbadc057", ")", ";", "int", "neg_intval", "=", "-", "intval", ";", "int", "short_0", "=", "satisfies_constraint_Rcq", "(", "operands", "[", "0", "]", ")", ";", "int", "short_p", "=", "(", "!", "cond_p", "&&", "short_0", "&&", "satisfies_constraint_Rcq", "(", "operands", "[", "1", "]", ")", ")", ";", "int", "ret", "=", "0", ";", "if", "(", "output_p", ")", "\\", "output_asm_insn", "(", "FORMAT", ",", "operands", ")", ";", "\\", "return", "ret", ";", "\\", "}", "</s>"], "natrual_language": ["Emit", "code", "for", "an", "addsi3", "instruction", "with", "OPERANDS", ".", "COND_P", "indicates", "if", "this", "will", "use", "conditional", "execution", ".", "Return", "the", "length", "of", "the", "instruction", ".", "If", "OUTPUT_P", "is", "false", ",", "do", "n't", "actually", "output", "the", "instruction", ",", "just", "return", "its", "length", "."], "TS_V_token": ["arc", "35", "0", "1", "0", "2", "2", "1", "2", "2", "0xbadc057", "0", "1", "0"], "File": "arc6", "Func": "arc_output_addsi", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33573, "Length": 143}
{"ground_truth": ["<s>", "int", "arc_output_commutative_cond_exec", "(", "rtx", "*", "operands", ",", "bool", "output_p", ")", "{", "enum", "rtx_code", "commutative_op", "=", "GET_CODE", "(", "operands", "[", "3", "]", ")", ";", "const", "char", "*", "pat", "=", "NULL", ";", "gcc_assert", "(", "!", "CONSTANT_P", "(", "operands", "[", "1", "]", ")", ")", ";", "switch", "(", "commutative_op", ")", "{", "case", "AND", ":", "if", "(", "satisfies_constraint_C1p", "(", "operands", "[", "2", "]", ")", ")", "pat", "=", "\"bmsk%? %0,%1,%Z2\"", ";", "else", "if", "(", "satisfies_constraint_C2p", "(", "operands", "[", "2", "]", ")", ")", "{", "operands", "[", "2", "]", "=", "GEN_INT", "(", "(", "~", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", ")", ";", "pat", "=", "\"bmskn%? %0,%1,%Z2\"", ";", "}", "else", "if", "(", "satisfies_constraint_Ccp", "(", "operands", "[", "2", "]", ")", ")", "pat", "=", "\"bclr%? %0,%1,%M2\"", ";", "else", "if", "(", "satisfies_constraint_CnL", "(", "operands", "[", "2", "]", ")", ")", "pat", "=", "\"bic%? %0,%1,%n2-1\"", ";", "break", ";", "case", "IOR", ":", "if", "(", "satisfies_constraint_C0p", "(", "operands", "[", "2", "]", ")", ")", "pat", "=", "\"bset%? %0,%1,%z2\"", ";", "break", ";", "case", "XOR", ":", "if", "(", "satisfies_constraint_C0p", "(", "operands", "[", "2", "]", ")", ")", "pat", "=", "\"bxor%? %0,%1,%z2\"", ";", "break", ";", "case", "PLUS", ":", "return", "arc_output_addsi", "(", "operands", ",", "true", ",", "output_p", ")", ";", "default", ":", "break", ";", "}", "if", "(", "output_p", ")", "output_asm_insn", "(", "pat", "?", "pat", ":", "\"%O3.%d5 %0,%1,%2\"", ",", "operands", ")", ";", "if", "(", "pat", "||", "REG_P", "(", "operands", "[", "2", "]", ")", "||", "satisfies_constraint_L", "(", "operands", "[", "2", "]", ")", ")", "return", "4", ";", "return", "8", ";", "}", "</s>"], "natrual_language": ["Emit", "code", "for", "an", "commutative_cond_exec", "instruction", "with", "OPERANDS", ".", "Return", "the", "length", "of", "the", "instruction", ".", "If", "OUTPUT_P", "is", "false", ",", "do", "n't", "actually", "output", "the", "instruction", ",", "just", "return", "its", "length", "."], "TS_V_token": ["arc", "3", "1", "2", "\"bmsk%? %0,%1,%Z2\"", "2", "2", "2", "\"bmskn%? %0,%1,%Z2\"", "2", "\"bclr%? %0,%1,%M2\"", "2", "\"bic%? %0,%1,%n2-1\"", "2", "\"bset%? %0,%1,%z2\"", "2", "\"bxor%? %0,%1,%z2\"", "\"%O3.%d5 %0,%1,%2\"", "2", "2", "4", "8"], "File": "arc6", "Func": "arc_output_commutative_cond_exec", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33574, "Length": 230}
{"ground_truth": ["<s>", "static", "machine_mode", "arc_preferred_simd_mode", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "HImode", ":", "return", "TARGET_PLUS_QMACW", "?", "V4HImode", ":", "V2HImode", ";", "case", "SImode", ":", "return", "V2SImode", ";", "default", ":", "return", "word_mode", ";", "}", "}", "</s>"], "natrual_language": ["Implements", "target", "hook", "TARGET_VECTORIZE_PREFERRED_SIMD_MODE", "."], "TS_V_token": ["arc"], "File": "arc6", "Func": "arc_preferred_simd_mode", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33575, "Length": 36}
{"ground_truth": ["<s>", "void", "arc_print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "register", "rtx", "base", ",", "index", "=", "0", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "fputs", "(", "reg_names", "[", "REGNO", "(", "addr", ")", "]", ",", "file", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "output_addr_const", "(", "file", ",", "addr", ")", ";", "if", "(", "SYMBOL_REF_SMALL_P", "(", "addr", ")", ")", "fprintf", "(", "file", ",", "\"@sda\"", ")", ";", "break", ";", "case", "PLUS", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "MULT", ")", "index", "=", "XEXP", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ",", "base", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "if", "(", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", "index", "=", "XEXP", "(", "addr", ",", "0", ")", ",", "base", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "base", "=", "XEXP", "(", "addr", ",", "0", ")", ",", "index", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "gcc_assert", "(", "OBJECT_P", "(", "base", ")", ")", ";", "arc_print_operand_address", "(", "file", ",", "base", ")", ";", "if", "(", "CONSTANT_P", "(", "base", ")", "&&", "CONST_INT_P", "(", "index", ")", ")", "fputc", "(", "'+'", ",", "file", ")", ";", "else", "fputc", "(", "','", ",", "file", ")", ";", "gcc_assert", "(", "OBJECT_P", "(", "index", ")", ")", ";", "arc_print_operand_address", "(", "file", ",", "index", ")", ";", "break", ";", "case", "CONST", ":", "{", "rtx", "c", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "(", "GET_CODE", "(", "c", ")", "==", "UNSPEC", "&&", "(", "XINT", "(", "c", ",", "1", ")", "==", "UNSPEC_TLS_OFF", "||", "XINT", "(", "c", ",", "1", ")", "==", "UNSPEC_TLS_IE", ")", ")", "||", "(", "GET_CODE", "(", "c", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "c", ",", "0", ")", ")", "==", "UNSPEC", "&&", "(", "XINT", "(", "XEXP", "(", "c", ",", "0", ")", ",", "1", ")", "==", "UNSPEC_TLS_OFF", "||", "XINT", "(", "XEXP", "(", "c", ",", "0", ")", ",", "1", ")", "==", "ARC_UNSPEC_GOTOFFPC", ")", ")", ")", "{", "arc_output_pic_addr_const", "(", "file", ",", "c", ",", "0", ")", ";", "break", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "c", ")", "==", "PLUS", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "c", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "c", ",", "1", ")", ")", "==", "CONST_INT", ")", ";", "output_address", "(", "VOIDmode", ",", "XEXP", "(", "addr", ",", "0", ")", ")", ";", "break", ";", "}", "case", "PRE_INC", ":", "case", "PRE_DEC", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "default", ":", "if", "(", "flag_pic", ")", "arc_output_pic_addr_const", "(", "file", ",", "addr", ",", "0", ")", ";", "else", "output_addr_const", "(", "file", ",", "addr", ")", ";", "break", ";", "}", "}", "</s>"], "natrual_language": ["Print", "a", "memory", "address", "as", "an", "operand", "to", "reference", "that", "memory", "location", "."], "TS_V_token": ["arc", "0", "\"@sda\"", "0", "0", "0", "1", "0", "0", "1", "0", "1", "0", "1", "1", "0", "0", "1", "0", "1", "0", "0", "1", "0", "0"], "File": "arc6", "Func": "arc_print_operand_address", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33576, "Length": 423}
{"ground_truth": ["<s>", "static", "bool", "arc_process_double_reg_moves", "(", "rtx", "*", "operands", ")", "{", "rtx", "dest", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "enum", "usesDxState", "{", "none", ",", "srcDx", ",", "destDx", ",", "maxDx", "}", ";", "enum", "usesDxState", "state", "=", "none", ";", "if", "(", "refers_to_regno_p", "(", "40", ",", "44", ",", "src", ",", "0", ")", ")", "state", "=", "srcDx", ";", "if", "(", "refers_to_regno_p", "(", "40", ",", "44", ",", "dest", ",", "0", ")", ")", "{", "gcc_assert", "(", "state", "==", "none", ")", ";", "state", "=", "destDx", ";", "}", "if", "(", "state", "==", "none", ")", "return", "false", ";", "if", "(", "state", "==", "srcDx", ")", "{", "if", "(", "TARGET_DPFP_DISABLE_LRSR", ")", "{", "rtx", "set", "=", "gen_rtx_SET", "(", "dest", ",", "src", ")", ";", "rtx", "use1", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "const1_rtx", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "set", ",", "use1", ")", ")", ")", ";", "}", "else", "{", "rtx", "destHigh", "=", "simplify_gen_subreg", "(", "SImode", ",", "dest", ",", "DFmode", ",", "TARGET_BIG_ENDIAN", "?", "0", ":", "4", ")", ";", "rtx", "destLow", "=", "simplify_gen_subreg", "(", "SImode", ",", "dest", ",", "DFmode", ",", "TARGET_BIG_ENDIAN", "?", "4", ":", "0", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "destHigh", ",", "gen_rtx_UNSPEC_VOLATILE", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "src", ")", ",", "VUNSPEC_ARC_LR_HIGH", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "destLow", ",", "gen_rtx_UNSPEC_VOLATILE", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "src", ")", ",", "VUNSPEC_ARC_LR", ")", ")", ")", ";", "}", "}", "else", "if", "(", "state", "==", "destDx", ")", "{", "rtx", "srcHigh", "=", "simplify_gen_subreg", "(", "SImode", ",", "src", ",", "DFmode", ",", "TARGET_BIG_ENDIAN", "?", "0", ":", "4", ")", ";", "rtx", "srcLow", "=", "simplify_gen_subreg", "(", "SImode", ",", "src", ",", "DFmode", ",", "TARGET_BIG_ENDIAN", "?", "4", ":", "0", ")", ";", "emit_insn", "(", "gen_dexcl_2op", "(", "dest", ",", "srcHigh", ",", "srcLow", ")", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Handle", "DOUBLE_REGS", "uses", ".", "Operand", "0", ":", "destination", "register", "Operand", "1", ":", "source", "register"], "TS_V_token": ["arc", "0", "1", "40", "44", "0", "40", "44", "0", "2", "0", "4", "4", "0", "1", "1", "0", "4", "4", "0"], "File": "arc6", "Func": "arc_process_double_reg_moves", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33577, "Length": 295}
{"ground_truth": ["<s>", "int", "arc_register_move_cost", "(", "machine_mode", ",", "enum", "reg_class", "from_class", ",", "enum", "reg_class", "to_class", ")", "{", "if", "(", "TARGET_ARC600", ")", "{", "if", "(", "to_class", "==", "MPY_WRITABLE_CORE_REGS", ")", "return", "3", ";", "else", "if", "(", "to_class", "==", "LPCOUNT_REG", ")", "return", "6", ";", "else", "if", "(", "to_class", "==", "WRITABLE_CORE_REGS", ")", "return", "6", ";", "}", "if", "(", "TARGET_ARC700", "&&", "(", "from_class", "==", "LPCOUNT_REG", "||", "from_class", "==", "ALL_CORE_REGS", "||", "from_class", "==", "WRITABLE_CORE_REGS", ")", ")", "return", "8", ";", "if", "(", "(", "TARGET_ARC700", "||", "TARGET_EM", ")", "&&", "TARGET_DPFP", "&&", "from_class", "==", "DOUBLE_REGS", "&&", "to_class", "==", "DOUBLE_REGS", ")", "return", "100", ";", "return", "2", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_REGISTER_MOVE_COST", "."], "TS_V_token": ["arc", "3", "6", "6", "8", "100", "2"], "File": "arc6", "Func": "arc_register_move_cost", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33578, "Length": 95}
{"ground_truth": ["<s>", "static", "bool", "arc_rewrite_small_data_p", "(", "const_rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_SMALL_P", "(", "x", ")", ")", "{", "gcc_assert", "(", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "==", "0", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "X", "is", "a", "small", "data", "address", "that", "can", "be", "rewritten", "as", "a", "gp+symref", "."], "TS_V_token": ["arc", "0", "1", "0", "0"], "File": "arc6", "Func": "arc_rewrite_small_data_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33579, "Length": 93}
{"ground_truth": ["<s>", "bool", "arc_store_addr_hazard_p", "(", "rtx_insn", "*", "producer", ",", "rtx_insn", "*", "consumer", ")", "{", "rtx", "in_set", ",", "out_set", ";", "rtx", "out_addr", ",", "in_addr", ";", "if", "(", "!", "producer", ")", "return", "false", ";", "if", "(", "!", "consumer", ")", "return", "false", ";", "out_set", "=", "single_set", "(", "producer", ")", ";", "if", "(", "out_set", ")", "{", "out_addr", "=", "SET_DEST", "(", "out_set", ")", ";", "if", "(", "!", "out_addr", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "out_addr", ")", "==", "ZERO_EXTEND", "||", "GET_CODE", "(", "out_addr", ")", "==", "SIGN_EXTEND", ")", "out_addr", "=", "XEXP", "(", "out_addr", ",", "0", ")", ";", "if", "(", "!", "MEM_P", "(", "out_addr", ")", ")", "return", "false", ";", "in_set", "=", "single_set", "(", "consumer", ")", ";", "if", "(", "in_set", ")", "{", "in_addr", "=", "SET_SRC", "(", "in_set", ")", ";", "if", "(", "!", "in_addr", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "in_addr", ")", "==", "ZERO_EXTEND", "||", "GET_CODE", "(", "in_addr", ")", "==", "SIGN_EXTEND", ")", "in_addr", "=", "XEXP", "(", "in_addr", ",", "0", ")", ";", "if", "(", "!", "MEM_P", "(", "in_addr", ")", ")", "return", "false", ";", "in_addr", "=", "XEXP", "(", "in_addr", ",", "0", ")", ";", "out_addr", "=", "XEXP", "(", "out_addr", ",", "0", ")", ";", "return", "exp_equiv_p", "(", "in_addr", ",", "out_addr", ",", "0", ",", "true", ")", ";", "}", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "a", "load", "instruction", "(", "CONSUMER", ")", "uses", "the", "same", "address", "as", "a", "store", "instruction", "(", "PRODUCER", ")", ".", "This", "function", "is", "used", "to", "avoid", "st/ld", "address", "hazard", "in", "ARC700", "cores", "."], "TS_V_token": ["arc", "0", "0", "0", "0", "0"], "File": "arc6", "Func": "arc_store_addr_hazard_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33580, "Length": 200}
{"ground_truth": ["<s>", "static", "bool", "arc_vector_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "V2HImode", ":", "return", "TARGET_PLUS_DMPY", ";", "case", "V4HImode", ":", "case", "V2SImode", ":", "return", "TARGET_PLUS_QMACW", ";", "case", "V4SImode", ":", "case", "V8HImode", ":", "return", "TARGET_SIMD_SET", ";", "default", ":", "return", "false", ";", "}", "}", "</s>"], "natrual_language": ["Implements", "target", "hook", "vector_mode_supported_p", "."], "TS_V_token": ["arc"], "File": "arc6", "Func": "arc_vector_mode_supported_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33581, "Length": 44}
{"ground_truth": ["<s>", "static", "void", "emit_unlikely_jump", "(", "rtx", "insn", ")", "{", "int", "very_unlikely", "=", "REG_BR_PROB_BASE", "/", "100", "-", "1", ";", "rtx_insn", "*", "jump", "=", "emit_jump_insn", "(", "insn", ")", ";", "add_int_reg_note", "(", "jump", ",", "REG_BR_PROB", ",", "very_unlikely", ")", ";", "}", "</s>"], "natrual_language": ["Mark", "the", "previous", "jump", "instruction", "as", "unlikely", "."], "TS_V_token": ["arc", "100", "1"], "File": "arc6", "Func": "emit_unlikely_jump", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33582, "Length": 36}
{"ground_truth": ["<s>", "static", "rtx", "force_offsettable", "(", "rtx", "addr", ",", "HOST_WIDE_INT", "size", ",", "bool", "reuse", ")", "{", "rtx", "base", "=", "addr", ";", "rtx", "offs", "=", "const0_rtx", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", ")", "{", "offs", "=", "XEXP", "(", "base", ",", "1", ")", ";", "base", "=", "XEXP", "(", "base", ",", "0", ")", ";", "}", "if", "(", "!", "REG_P", "(", "base", ")", "||", "(", "REGNO", "(", "base", ")", "!=", "STACK_POINTER_REGNUM", "&&", "REGNO_PTR_FRAME_P", "(", "REGNO", "(", "base", ")", ")", ")", "||", "!", "CONST_INT_P", "(", "offs", ")", "||", "!", "SMALL_INT", "(", "INTVAL", "(", "offs", ")", ")", "||", "!", "SMALL_INT", "(", "INTVAL", "(", "offs", ")", "+", "size", ")", ")", "{", "if", "(", "reuse", ")", "emit_insn", "(", "gen_add2_insn", "(", "addr", ",", "offs", ")", ")", ";", "else", "addr", "=", "copy_to_mode_reg", "(", "Pmode", ",", "addr", ")", ";", "}", "return", "addr", ";", "}", "</s>"], "natrual_language": ["Helper", "function", "of", "arc_expand_movmem", ".", "ADDR", "points", "to", "a", "chunk", "of", "memory", ".", "Emit", "code", "and", "return", "an", "potentially", "modified", "address", "such", "that", "offsets", "up", "to", "SIZE", "are", "can", "be", "added", "to", "yield", "a", "legitimate", "address", ".", "if", "REUSE", "is", "set", ",", "ADDR", "is", "a", "register", "that", "may", "be", "modified", "."], "TS_V_token": ["arc", "1", "0"], "File": "arc6", "Func": "force_offsettable", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33583, "Length": 134}
{"ground_truth": ["<s>", "bool", "prepare_move_operands", "(", "rtx", "*", "operands", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "TARGET_NO_SDATA_SET", "&&", "small_data_pattern", "(", "operands", "[", "0", "]", ",", "Pmode", ")", ")", "operands", "[", "0", "]", "=", "arc_rewrite_small_data", "(", "operands", "[", "0", "]", ")", ";", "if", "(", "mode", "==", "SImode", "&&", "SYMBOLIC_CONST", "(", "operands", "[", "1", "]", ")", ")", "{", "prepare_pic_move", "(", "operands", ",", "SImode", ")", ";", "}", "if", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "!=", "MEM", "&&", "!", "TARGET_NO_SDATA_SET", "&&", "small_data_pattern", "(", "operands", "[", "1", "]", ",", "Pmode", ")", ")", "{", "operands", "[", "1", "]", "=", "arc_rewrite_small_data", "(", "operands", "[", "1", "]", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", ";", "set_unique_reg_note", "(", "get_last_insn", "(", ")", ",", "REG_EQUAL", ",", "operands", "[", "1", "]", ")", ";", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "operands", "[", "0", "]", ")", ";", "return", "true", ";", "}", "if", "(", "MEM_P", "(", "operands", "[", "0", "]", ")", "&&", "!", "(", "reload_in_progress", "||", "reload_completed", ")", ")", "{", "operands", "[", "1", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "if", "(", "!", "move_dest_operand", "(", "operands", "[", "0", "]", ",", "mode", ")", ")", "{", "rtx", "addr", "=", "copy_to_mode_reg", "(", "Pmode", ",", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ")", ";", "rtx", "pat", "=", "change_address", "(", "operands", "[", "0", "]", ",", "mode", ",", "addr", ")", ";", "MEM_COPY_ATTRIBUTES", "(", "pat", ",", "operands", "[", "0", "]", ")", ";", "operands", "[", "0", "]", "=", "pat", ";", "}", "if", "(", "!", "cse_not_expected", ")", "{", "rtx", "pat", "=", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ";", "pat", "=", "arc_legitimize_address_0", "(", "pat", ",", "pat", ",", "mode", ")", ";", "if", "(", "pat", ")", "{", "pat", "=", "change_address", "(", "operands", "[", "0", "]", ",", "mode", ",", "pat", ")", ";", "MEM_COPY_ATTRIBUTES", "(", "pat", ",", "operands", "[", "0", "]", ")", ";", "operands", "[", "0", "]", "=", "pat", ";", "}", "}", "}", "if", "(", "MEM_P", "(", "operands", "[", "1", "]", ")", "&&", "!", "cse_not_expected", ")", "{", "rtx", "pat", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ";", "pat", "=", "arc_legitimize_address_0", "(", "pat", ",", "pat", ",", "mode", ")", ";", "if", "(", "pat", ")", "{", "pat", "=", "change_address", "(", "operands", "[", "1", "]", ",", "mode", ",", "pat", ")", ";", "MEM_COPY_ATTRIBUTES", "(", "pat", ",", "operands", "[", "1", "]", ")", ";", "operands", "[", "1", "]", "=", "pat", ";", "}", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Prepare", "operands", "for", "a", "move", "define_expand", "in", "MODE", "."], "TS_V_token": ["arc", "0", "0", "0", "1", "0", "1", "1", "1", "0", "1", "1", "0", "0", "0", "1", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "1", "0", "1", "1", "1"], "File": "arc6", "Func": "prepare_move_operands", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33584, "Length": 395}
{"ground_truth": ["<s>", "static", "void", "prepare_pic_move", "(", "rtx", "*", "operands", ",", "machine_mode", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "MEM", "&&", "SYMBOLIC_CONST", "(", "operands", "[", "1", "]", ")", "&&", "flag_pic", ")", "operands", "[", "1", "]", "=", "force_reg", "(", "Pmode", ",", "operands", "[", "1", "]", ")", ";", "else", "{", "rtx", "temp", "=", "(", "reload_in_progress", "?", "operands", "[", "0", "]", ":", "flag_pic", "?", "gen_reg_rtx", "(", "Pmode", ")", ":", "NULL_RTX", ")", ";", "operands", "[", "1", "]", "=", "arc_legitimize_pic_address", "(", "operands", "[", "1", "]", ",", "temp", ")", ";", "}", "}", "</s>"], "natrual_language": ["Emit", "insns", "to", "move", "operands", "[", "1", "]", "into", "operands", "[", "0", "]", "."], "TS_V_token": ["arc", "0", "1", "1", "1", "0", "1", "1"], "File": "arc6", "Func": "prepare_pic_move", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33585, "Length": 88}
{"ground_truth": ["<s>", "static", "void", "workaround_arc_anomaly", "(", "void", ")", "{", "rtx_insn", "*", "insn", ",", "*", "succ0", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "succ0", "=", "next_real_insn", "(", "insn", ")", ";", "if", "(", "arc_hazard", "(", "insn", ",", "succ0", ")", ")", "{", "emit_insn_before", "(", "gen_nopv", "(", ")", ",", "succ0", ")", ";", "}", "}", "if", "(", "TARGET_ARC700", ")", "{", "rtx_insn", "*", "succ1", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "succ0", "=", "next_real_insn", "(", "insn", ")", ";", "if", "(", "arc_store_addr_hazard_p", "(", "insn", ",", "succ0", ")", ")", "{", "emit_insn_after", "(", "gen_nopv", "(", ")", ",", "insn", ")", ";", "emit_insn_after", "(", "gen_nopv", "(", ")", ",", "insn", ")", ";", "continue", ";", "}", "succ1", "=", "next_real_insn", "(", "succ0", ")", ";", "if", "(", "succ0", "&&", "!", "JUMP_P", "(", "succ0", ")", "&&", "!", "CALL_P", "(", "succ0", ")", "&&", "arc_store_addr_hazard_p", "(", "insn", ",", "succ1", ")", ")", "emit_insn_after", "(", "gen_nopv", "(", ")", ",", "insn", ")", ";", "}", "}", "}", "</s>"], "natrual_language": ["The", "same", "functionality", "as", "arc_hazard", ".", "It", "is", "called", "in", "machine", "reorg", "before", "any", "other", "optimization", ".", "Hence", ",", "the", "NOP", "size", "is", "taken", "into", "account", "when", "doing", "branch", "shortening", "."], "TS_V_token": ["arc"], "File": "arc6", "Func": "workaround_arc_anomaly", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33586, "Length": 167}
{"ground_truth": ["<s>", "static", "void", "arc_autovectorize_vector_sizes", "(", "vector_sizes", "*", "sizes", ")", "{", "if", "(", "TARGET_PLUS_QMACW", ")", "{", "sizes", "->", "quick_push", "(", "8", ")", ";", "sizes", "->", "quick_push", "(", "4", ")", ";", "}", "}", "</s>"], "natrual_language": ["Implements", "target", "hook", "TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES", "."], "TS_V_token": ["arc", "8", "4"], "File": "arc7", "Func": "arc_autovectorize_vector_sizes", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33587, "Length": 30}
{"ground_truth": ["<s>", "static", "rtx", "arc_builtin_setjmp_frame_value", "(", "void", ")", "{", "return", "gen_raw_REG", "(", "Pmode", ",", "FRAME_POINTER_REGNUM", ")", ";", "}", "</s>"], "natrual_language": ["Return", "the", "frame", "pointer", "value", "to", "be", "backed", "up", "in", "the", "setjmp", "buffer", "."], "TS_V_token": ["arc"], "File": "arc7", "Func": "arc_builtin_setjmp_frame_value", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33588, "Length": 16}
{"ground_truth": ["<s>", "static", "bool", "arc_can_eliminate", "(", "const", "int", "from", "ATTRIBUTE_UNUSED", ",", "const", "int", "to", ")", "{", "return", "(", "(", "to", "==", "FRAME_POINTER_REGNUM", ")", "||", "!", "arc_frame_pointer_needed", "(", ")", ")", ";", "}", "</s>"], "natrual_language": ["Given", "FROM", "and", "TO", "register", "numbers", ",", "say", "whether", "this", "elimination", "is", "allowed", ".", "Frame", "pointer", "elimination", "is", "automatically", "handled", ".", "All", "eliminations", "are", "permissible", ".", "If", "we", "need", "a", "frame", "pointer", ",", "we", "must", "eliminate", "ARG_POINTER_REGNUM", "into", "FRAME_POINTER_REGNUM", "and", "not", "into", "STACK_POINTER_REGNUM", "."], "TS_V_token": ["arc"], "File": "arc7", "Func": "arc_can_eliminate", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33589, "Length": 29}
{"ground_truth": ["<s>", "static", "unsigned", "int", "arc_compute_frame_size", "(", "void", ")", "{", "int", "regno", ";", "unsigned", "int", "total_size", ",", "var_size", ",", "args_size", ",", "pretend_size", ",", "extra_size", ";", "unsigned", "int", "reg_size", ",", "reg_offset", ";", "unsigned", "int", "gmask", ";", "struct", "arc_frame_info", "*", "frame_info", ";", "int", "size", ";", "if", "(", "cfun", "->", "machine", "->", "frame_info", ".", "initialized", ")", "return", "cfun", "->", "machine", "->", "frame_info", ".", "total_size", ";", "frame_info", "=", "&", "cfun", "->", "machine", "->", "frame_info", ";", "size", "=", "ARC_STACK_ALIGN", "(", "get_frame_size", "(", ")", ")", ";", "var_size", "=", "size", ";", "args_size", "=", "crtl", "->", "outgoing_args_size", ";", "reg_size", "=", "0", ";", "gmask", "=", "0", ";", "for", "(", "regno", "=", "0", ";", "regno", "<=", "31", ";", "regno", "++", ")", "{", "if", "(", "arc_must_save_register", "(", "regno", ",", "cfun", ")", ")", "{", "reg_size", "+=", "UNITS_PER_WORD", ";", "gmask", "|=", "1L", "<<", "regno", ";", "}", "}", "if", "(", "crtl", "->", "calls_eh_return", ")", "for", "(", "regno", "=", "0", ";", "EH_RETURN_DATA_REGNO", "(", "regno", ")", "!=", "INVALID_REGNUM", ";", "regno", "++", ")", "{", "reg_size", "+=", "UNITS_PER_WORD", ";", "gmask", "|=", "1", "<<", "regno", ";", "}", "frame_info", "->", "save_return_addr", "=", "(", "!", "crtl", "->", "is_leaf", "||", "df_regs_ever_live_p", "(", "RETURN_ADDR_REGNUM", ")", "||", "crtl", "->", "calls_eh_return", ")", ";", "if", "(", "optimize_size", "&&", "!", "TARGET_NO_MILLICODE_THUNK_SET", "&&", "!", "crtl", "->", "calls_eh_return", ")", "{", "if", "(", "arc_compute_millicode_save_restore_regs", "(", "gmask", ",", "frame_info", ")", ")", "frame_info", "->", "save_return_addr", "=", "true", ";", "}", "extra_size", "=", "0", ";", "if", "(", "arc_must_save_return_addr", "(", "cfun", ")", ")", "extra_size", "=", "4", ";", "if", "(", "arc_frame_pointer_needed", "(", ")", ")", "extra_size", "+=", "4", ";", "pretend_size", "=", "crtl", "->", "args", ".", "pretend_args_size", ";", "{", "unsigned", "int", "extra_plus_reg_size", ";", "unsigned", "int", "extra_plus_reg_size_aligned", ";", "extra_plus_reg_size", "=", "extra_size", "+", "reg_size", ";", "extra_plus_reg_size_aligned", "=", "ARC_STACK_ALIGN", "(", "extra_plus_reg_size", ")", ";", "reg_size", "=", "extra_plus_reg_size_aligned", "-", "extra_size", ";", "}", "total_size", "=", "var_size", "+", "args_size", "+", "extra_size", "+", "pretend_size", "+", "reg_size", ";", "gcc_assert", "(", "total_size", "==", "ARC_STACK_ALIGN", "(", "total_size", ")", ")", ";", "reg_offset", "=", "(", "total_size", "-", "(", "pretend_size", "+", "reg_size", "+", "extra_size", ")", "+", "(", "arc_frame_pointer_needed", "(", ")", "?", "4", ":", "0", ")", ")", ";", "frame_info", "->", "total_size", "=", "total_size", ";", "frame_info", "->", "extra_size", "=", "extra_size", ";", "frame_info", "->", "pretend_size", "=", "pretend_size", ";", "frame_info", "->", "var_size", "=", "var_size", ";", "frame_info", "->", "args_size", "=", "args_size", ";", "frame_info", "->", "reg_size", "=", "reg_size", ";", "frame_info", "->", "reg_offset", "=", "reg_offset", ";", "frame_info", "->", "gmask", "=", "gmask", ";", "frame_info", "->", "initialized", "=", "reload_completed", ";", "return", "total_size", ";", "}", "</s>"], "natrual_language": ["Return", "the", "bytes", "needed", "to", "compute", "the", "frame", "pointer", "from", "the", "current", "stack", "pointer", ".", "SIZE", "is", "the", "size", "needed", "for", "local", "variables", "."], "TS_V_token": ["arc", "0", "0", "0", "31", "1L", "0", "1", "0", "4", "4", "4", "0"], "File": "arc7", "Func": "arc_compute_frame_size", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33590, "Length": 381}
{"ground_truth": ["<s>", "unsigned", "int", "arc_compute_function_type", "(", "struct", "function", "*", "fun", ")", "{", "tree", "attr", ",", "decl", "=", "fun", "->", "decl", ";", "unsigned", "int", "fn_type", "=", "fun", "->", "machine", "->", "fn_type", ";", "if", "(", "fn_type", "!=", "ARC_FUNCTION_UNKNOWN", ")", "return", "fn_type", ";", "if", "(", "lookup_attribute", "(", "\"naked\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", "!=", "NULL_TREE", ")", "fn_type", "|=", "ARC_FUNCTION_NAKED", ";", "else", "fn_type", "|=", "ARC_FUNCTION_NORMAL", ";", "attr", "=", "lookup_attribute", "(", "\"interrupt\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ";", "if", "(", "attr", "!=", "NULL_TREE", ")", "{", "tree", "value", ",", "args", "=", "TREE_VALUE", "(", "attr", ")", ";", "gcc_assert", "(", "list_length", "(", "args", ")", "==", "1", ")", ";", "value", "=", "TREE_VALUE", "(", "args", ")", ";", "gcc_assert", "(", "TREE_CODE", "(", "value", ")", "==", "STRING_CST", ")", ";", "if", "(", "!", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink1\"", ")", "||", "!", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink\"", ")", ")", "fn_type", "|=", "ARC_FUNCTION_ILINK1", ";", "else", "if", "(", "!", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink2\"", ")", ")", "fn_type", "|=", "ARC_FUNCTION_ILINK2", ";", "else", "if", "(", "!", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"firq\"", ")", ")", "fn_type", "|=", "ARC_FUNCTION_FIRQ", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "return", "fun", "->", "machine", "->", "fn_type", "=", "fn_type", ";", "}", "</s>"], "natrual_language": ["Type", "of", "function", "DECL", ".", "The", "result", "is", "cached", ".", "To", "reset", "the", "cache", "at", "the", "end", "of", "a", "function", ",", "call", "with", "DECL", "=", "NULL_TREE", "."], "TS_V_token": ["arc", "\"naked\"", "\"interrupt\"", "1", "\"ilink1\"", "\"ilink\"", "\"ilink2\"", "\"firq\""], "File": "arc7", "Func": "arc_compute_function_type", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33591, "Length": 197}
{"ground_truth": ["<s>", "rtx", "arc_eh_return_address_location", "(", "void", ")", "{", "rtx", "mem", ";", "int", "offset", ";", "struct", "arc_frame_info", "*", "afi", ";", "arc_compute_frame_size", "(", ")", ";", "afi", "=", "&", "cfun", "->", "machine", "->", "frame_info", ";", "gcc_assert", "(", "crtl", "->", "calls_eh_return", ")", ";", "gcc_assert", "(", "afi", "->", "save_return_addr", ")", ";", "gcc_assert", "(", "afi", "->", "extra_size", ">=", "4", ")", ";", "offset", "=", "afi", "->", "reg_size", "+", "afi", "->", "extra_size", "-", "4", ";", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "frame_pointer_rtx", ",", "offset", ")", ")", ";", "MEM_VOLATILE_P", "(", "mem", ")", "=", "1", ";", "return", "mem", ";", "}", "</s>"], "natrual_language": ["Return", "rtx", "for", "the", "location", "of", "the", "return", "address", "on", "the", "stack", ",", "suitable", "for", "use", "in", "__builtin_eh_return", ".", "The", "new", "return", "address", "will", "be", "written", "to", "this", "location", "in", "order", "to", "redirect", "the", "return", "to", "the", "exception", "handler", "."], "TS_V_token": ["arc", "4", "4", "1"], "File": "arc7", "Func": "arc_eh_return_address_location", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33592, "Length": 92}
{"ground_truth": ["<s>", "bool", "arc_epilogue_uses", "(", "int", "regno", ")", "{", "unsigned", "int", "fn_type", ";", "if", "(", "regno", "==", "arc_tp_regno", ")", "return", "true", ";", "fn_type", "=", "arc_compute_function_type", "(", "cfun", ")", ";", "if", "(", "reload_completed", ")", "{", "if", "(", "ARC_INTERRUPT_P", "(", "cfun", "->", "machine", "->", "fn_type", ")", ")", "{", "if", "(", "!", "fixed_regs", "[", "regno", "]", ")", "return", "true", ";", "return", "(", "(", "regno", "==", "arc_return_address_register", "(", "fn_type", ")", ")", "||", "(", "regno", "==", "RETURN_ADDR_REGNUM", ")", ")", ";", "}", "else", "return", "regno", "==", "RETURN_ADDR_REGNUM", ";", "}", "else", "return", "regno", "==", "arc_return_address_register", "(", "fn_type", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "EPILOGUE__USES", ".", "Return", "true", "if", "REGNO", "should", "be", "added", "to", "the", "deemed", "uses", "of", "the", "epilogue", ".", "We", "use", "the", "return", "address", "arc_return_address_regs", "[", "arc_compute_function_type", "(", "cfun", ")", "]", ".", "But", "also", ",", "we", "have", "to", "make", "sure", "all", "the", "register", "restore", "instructions", "are", "known", "to", "be", "live", "in", "interrupt", "functions", ",", "plus", "the", "blink", "register", "if", "it", "is", "clobbered", "by", "the", "isr", "."], "TS_V_token": ["arc"], "File": "arc7", "Func": "arc_epilogue_uses", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33593, "Length": 91}
{"ground_truth": ["<s>", "bool", "arc_expand_movmem", "(", "rtx", "*", "operands", ")", "{", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "rtx", "dst_addr", ",", "src_addr", ";", "HOST_WIDE_INT", "size", ";", "int", "align", "=", "INTVAL", "(", "operands", "[", "3", "]", ")", ";", "unsigned", "n_pieces", ";", "int", "piece", "=", "align", ";", "rtx", "store", "[", "2", "]", ";", "rtx", "tmpx", "[", "2", "]", ";", "int", "i", ";", "if", "(", "!", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", ")", "return", "false", ";", "size", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "align", ">=", "4", ")", "{", "if", "(", "TARGET_LL64", ")", "n_pieces", "=", "(", "size", "+", "4", ")", "/", "8U", "+", "(", "(", "size", ">>", "1", ")", "&", "1", ")", "+", "(", "size", "&", "1", ")", ";", "else", "n_pieces", "=", "(", "size", "+", "2", ")", "/", "4U", "+", "(", "size", "&", "1", ")", ";", "}", "else", "if", "(", "align", "==", "2", ")", "n_pieces", "=", "(", "size", "+", "1", ")", "/", "2U", ";", "else", "n_pieces", "=", "size", ";", "if", "(", "n_pieces", ">=", "(", "unsigned", "int", ")", "(", "optimize_size", "?", "3", ":", "15", ")", ")", "return", "false", ";", "if", "(", "TARGET_LL64", "&&", "(", "piece", ">=", "4", ")", "&&", "(", "size", ">=", "8", ")", ")", "piece", "=", "8", ";", "else", "if", "(", "piece", ">", "4", ")", "piece", "=", "4", ";", "dst_addr", "=", "force_offsettable", "(", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ",", "size", ",", "0", ")", ";", "src_addr", "=", "force_offsettable", "(", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ",", "size", ",", "0", ")", ";", "store", "[", "0", "]", "=", "store", "[", "1", "]", "=", "NULL_RTX", ";", "tmpx", "[", "0", "]", "=", "tmpx", "[", "1", "]", "=", "NULL_RTX", ";", "for", "(", "i", "=", "0", ";", "size", ">", "0", ";", "i", "^=", "1", ",", "size", "-=", "piece", ")", "{", "rtx", "tmp", ";", "machine_mode", "mode", ";", "while", "(", "piece", ">", "size", ")", "piece", ">>=", "1", ";", "mode", "=", "smallest_int_mode_for_size", "(", "piece", "*", "BITS_PER_UNIT", ")", ";", "if", "(", "0", "&&", "tmpx", "[", "i", "]", "&&", "GET_MODE", "(", "tmpx", "[", "i", "]", ")", "==", "mode", ")", "tmp", "=", "tmpx", "[", "i", "]", ";", "else", "tmpx", "[", "i", "]", "=", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "dst_addr", "=", "force_offsettable", "(", "dst_addr", ",", "piece", ",", "1", ")", ";", "src_addr", "=", "force_offsettable", "(", "src_addr", ",", "piece", ",", "1", ")", ";", "if", "(", "store", "[", "i", "]", ")", "emit_insn", "(", "store", "[", "i", "]", ")", ";", "emit_move_insn", "(", "tmp", ",", "change_address", "(", "src", ",", "mode", ",", "src_addr", ")", ")", ";", "store", "[", "i", "]", "=", "gen_move_insn", "(", "change_address", "(", "dst", ",", "mode", ",", "dst_addr", ")", ",", "tmp", ")", ";", "dst_addr", "=", "plus_constant", "(", "Pmode", ",", "dst_addr", ",", "piece", ")", ";", "src_addr", "=", "plus_constant", "(", "Pmode", ",", "src_addr", ",", "piece", ")", ";", "}", "if", "(", "store", "[", "i", "]", ")", "emit_insn", "(", "store", "[", "i", "]", ")", ";", "if", "(", "store", "[", "i", "^", "1", "]", ")", "emit_insn", "(", "store", "[", "i", "^", "1", "]", ")", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Like", "move_by_pieces", ",", "but", "take", "account", "of", "load", "latency", ",", "and", "actual", "offset", "ranges", ".", "Return", "true", "on", "success", "."], "TS_V_token": ["arc", "0", "1", "3", "2", "2", "2", "2", "4", "4", "8U", "1", "1", "1", "2", "4U", "1", "2", "1", "2U", "3", "15", "4", "8", "8", "4", "4", "0", "0", "0", "1", "0", "0", "0", "1", "0", "1", "0", "0", "1", "1", "0", "1", "1", "1", "1"], "File": "arc7", "Func": "arc_expand_movmem", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33594, "Length": 493}
{"ground_truth": ["<s>", "void", "arc_expand_prologue", "(", "void", ")", "{", "int", "size", ";", "unsigned", "int", "gmask", "=", "cfun", "->", "machine", "->", "frame_info", ".", "gmask", ";", "unsigned", "int", "frame_size_to_allocate", ";", "int", "first_offset", "=", "0", ";", "unsigned", "int", "fn_type", "=", "arc_compute_function_type", "(", "cfun", ")", ";", "if", "(", "ARC_NAKED_P", "(", "fn_type", ")", ")", "{", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "0", ";", "return", ";", "}", "size", "=", "arc_compute_frame_size", "(", ")", ";", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "size", ";", "frame_size_to_allocate", "=", "size", ";", "gcc_assert", "(", "!", "(", "size", "==", "0", "&&", "gmask", ")", ")", ";", "if", "(", "cfun", "->", "machine", "->", "frame_info", ".", "pretend_size", "!=", "0", ")", "{", "gcc_assert", "(", "cfun", "->", "machine", "->", "frame_info", ".", "pretend_size", "<=", "32", ")", ";", "frame_stack_add", "(", "-", "(", "HOST_WIDE_INT", ")", "cfun", "->", "machine", "->", "frame_info", ".", "pretend_size", ")", ";", "frame_size_to_allocate", "-=", "cfun", "->", "machine", "->", "frame_info", ".", "pretend_size", ";", "}", "if", "(", "ARC_AUTO_IRQ_P", "(", "fn_type", ")", "&&", "!", "ARC_FAST_INTERRUPT_P", "(", "fn_type", ")", ")", "{", "arc_dwarf_emit_irq_save_regs", "(", ")", ";", "}", "if", "(", "arc_must_save_return_addr", "(", "cfun", ")", "&&", "!", "ARC_AUTOBLINK_IRQ_P", "(", "fn_type", ")", ")", "{", "rtx", "ra", "=", "gen_rtx_REG", "(", "SImode", ",", "RETURN_ADDR_REGNUM", ")", ";", "rtx", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "gen_rtx_PRE_DEC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ")", ";", "frame_move_inc", "(", "mem", ",", "ra", ",", "stack_pointer_rtx", ",", "0", ")", ";", "frame_size_to_allocate", "-=", "UNITS_PER_WORD", ";", "}", "if", "(", "cfun", "->", "machine", "->", "frame_info", ".", "reg_size", ")", "{", "first_offset", "=", "-", "cfun", "->", "machine", "->", "frame_info", ".", "reg_size", ";", "arc_save_restore", "(", "stack_pointer_rtx", ",", "gmask", ",", "0", ",", "&", "first_offset", ")", ";", "frame_size_to_allocate", "-=", "cfun", "->", "machine", "->", "frame_info", ".", "reg_size", ";", "}", "if", "(", "cfun", "->", "machine", "->", "frame_info", ".", "millicode_end_reg", ">", "0", "&&", "arc_must_save_return_addr", "(", "cfun", ")", ")", "{", "HOST_WIDE_INT", "tmp", "=", "cfun", "->", "machine", "->", "frame_info", ".", "reg_size", ";", "emit_insn", "(", "gen_rtx_SET", "(", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ",", "gen_rtx_MEM", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "tmp", ")", ")", ")", ")", ";", "}", "if", "(", "arc_frame_pointer_needed", "(", ")", "&&", "!", "ARC_AUTOFP_IRQ_P", "(", "fn_type", ")", ")", "{", "rtx", "addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "UNITS_PER_WORD", "+", "first_offset", ")", ")", ";", "rtx", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "gen_rtx_PRE_MODIFY", "(", "Pmode", ",", "stack_pointer_rtx", ",", "addr", ")", ")", ";", "frame_move_inc", "(", "mem", ",", "frame_pointer_rtx", ",", "stack_pointer_rtx", ",", "0", ")", ";", "frame_size_to_allocate", "-=", "UNITS_PER_WORD", ";", "first_offset", "=", "0", ";", "}", "if", "(", "arc_frame_pointer_needed", "(", ")", ")", "{", "frame_move", "(", "frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ";", "}", "frame_size_to_allocate", "-=", "first_offset", ";", "if", "(", "frame_size_to_allocate", ">", "0", ")", "{", "frame_stack_add", "(", "(", "HOST_WIDE_INT", ")", "0", "-", "frame_size_to_allocate", ")", ";", "if", "(", "arc_frame_pointer_needed", "(", ")", ")", "emit_insn", "(", "gen_stack_tie", "(", "stack_pointer_rtx", ",", "hard_frame_pointer_rtx", ")", ")", ";", "}", "}", "</s>"], "natrual_language": ["Set", "up", "the", "stack", "and", "frame", "pointer", "(", "if", "desired", ")", "for", "the", "function", "."], "TS_V_token": ["arc", "0", "0", "0", "0", "32", "0", "0", "0", "0", "0", "0", "0"], "File": "arc7", "Func": "arc_expand_prologue", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33595, "Length": 438}
{"ground_truth": ["<s>", "static", "void", "arc_file_start", "(", "void", ")", "{", "default_file_start", "(", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.cpu %s\\n\"", ",", "arc_cpu_string", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.arc_attribute Tag_ARC_PCS_config, %d\\n\"", ",", "ATTRIBUTE_PCS", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.arc_attribute Tag_ARC_ABI_rf16, %d\\n\"", ",", "TARGET_RF16", "?", "1", ":", "0", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.arc_attribute Tag_ARC_ABI_pic, %d\\n\"", ",", "flag_pic", "?", "2", ":", "0", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.arc_attribute Tag_ARC_ABI_tls, %d\\n\"", ",", "(", "arc_tp_regno", "!=", "-", "1", ")", "?", "1", ":", "0", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.arc_attribute Tag_ARC_ABI_sda, %d\\n\"", ",", "TARGET_NO_SDATA_SET", "?", "0", ":", "2", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.arc_attribute Tag_ARC_ABI_exceptions, %d\\n\"", ",", "TARGET_OPTFPE", "?", "1", ":", "0", ")", ";", "if", "(", "TARGET_V2", ")", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.arc_attribute Tag_ARC_CPU_variation, %d\\n\"", ",", "arc_tune", "==", "ARC_TUNE_CORE_3", "?", "3", ":", "2", ")", ";", "}", "</s>"], "natrual_language": ["Set", "the", "cpu", "type", "and", "print", "out", "other", "fancy", "things", ",", "at", "the", "top", "of", "the", "file", "."], "TS_V_token": ["arc", "\"\\t.cpu %s\\n\"", "\"\\t.arc_attribute Tag_ARC_PCS_config, %d\\n\"", "\"\\t.arc_attribute Tag_ARC_ABI_rf16, %d\\n\"", "1", "0", "\"\\t.arc_attribute Tag_ARC_ABI_pic, %d\\n\"", "2", "0", "\"\\t.arc_attribute Tag_ARC_ABI_tls, %d\\n\"", "1", "1", "0", "\"\\t.arc_attribute Tag_ARC_ABI_sda, %d\\n\"", "0", "2", "\"\\t.arc_attribute Tag_ARC_ABI_exceptions, %d\\n\"", "1", "0", "\"\\t.arc_attribute Tag_ARC_CPU_variation, %d\\n\"", "3", "2"], "File": "arc7", "Func": "arc_file_start", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33596, "Length": 119}
{"ground_truth": ["<s>", "void", "arc_final_prescan_insn", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "opvec", "ATTRIBUTE_UNUSED", ",", "int", "noperands", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_DUMPISIZE", ")", "fprintf", "(", "asm_out_file", ",", "\"\\n; at %04x\\n\"", ",", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", ")", ";", "if", "(", "!", "cfun", "->", "machine", "->", "prescan_initialized", ")", "{", "memset", "(", "&", "arc_ccfsm_current", ",", "0", ",", "sizeof", "arc_ccfsm_current", ")", ";", "cfun", "->", "machine", "->", "prescan_initialized", "=", "1", ";", "}", "arc_ccfsm_advance", "(", "insn", ",", "&", "arc_ccfsm_current", ")", ";", "cfun", "->", "machine", "->", "size_reason", "=", "0", ";", "}", "</s>"], "natrual_language": ["The", "state", "of", "the", "fsm", "controlling", "condition", "codes", "are", ":", "0", ":", "normal", ",", "do", "nothing", "special", "1", ":", "do", "n't", "output", "this", "insn", "2", ":", "do", "n't", "output", "this", "insn", "3", ":", "make", "insns", "conditional", "4", ":", "make", "insns", "conditional", "State", "transitions", "(", "state-", ">", "state", "by", "whom", ",", "under", "what", "condition", ")", ":", "0", "-", ">", "1", "final_prescan_insn", ",", "if", "insn", "is", "conditional", "branch", "0", "-", ">", "2", "final_prescan_insn", ",", "if", "the", "`", "target", "'", "is", "an", "unconditional", "branch", "1", "-", ">", "3", "branch", "patterns", ",", "after", "having", "not", "output", "the", "conditional", "branch", "2", "-", ">", "4", "branch", "patterns", ",", "after", "having", "not", "output", "the", "conditional", "branch", "3", "-", ">", "0", "(", "*", "targetm.asm_out.internal_label", ")", ",", "if", "the", "`", "target", "'", "label", "is", "reached", "(", "the", "target", "label", "has", "CODE_LABEL_NUMBER", "equal", "to", "arc_ccfsm_target_label", ")", ".", "4", "-", ">", "0", "final_prescan_insn", ",", "if", "`", "target", "'", "unconditional", "branch", "is", "reached", "If", "the", "jump", "clobbers", "the", "conditions", "then", "we", "use", "states", "2", "and", "4", ".", "A", "similar", "thing", "can", "be", "done", "with", "conditional", "return", "insns", ".", "We", "also", "handle", "separating", "branches", "from", "sets", "of", "the", "condition", "code", ".", "This", "is", "done", "here", "because", "knowledge", "of", "the", "ccfsm", "state", "is", "required", ",", "we", "may", "not", "be", "outputting", "the", "branch", "."], "TS_V_token": ["arc", "\"\\n; at %04x\\n\"", "0", "1", "0"], "File": "arc7", "Func": "arc_final_prescan_insn", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33597, "Length": 83}
{"ground_truth": ["<s>", "static", "tree", "arc_handle_aux_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", ",", "int", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "DECL_P", "(", "*", "node", ")", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "VAR_DECL", ")", "{", "error", "(", "\"%qE attribute only applies to variables\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "args", ")", "{", "if", "(", "TREE_CODE", "(", "TREE_VALUE", "(", "args", ")", ")", "==", "NON_LVALUE_EXPR", ")", "TREE_VALUE", "(", "args", ")", "=", "TREE_OPERAND", "(", "TREE_VALUE", "(", "args", ")", ",", "0", ")", ";", "tree", "arg", "=", "TREE_VALUE", "(", "args", ")", ";", "if", "(", "TREE_CODE", "(", "arg", ")", "!=", "INTEGER_CST", ")", "{", "warning", "(", "0", ",", "\"%qE attribute allows only an integer \"", "\"constant argument\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "}", "if", "(", "TREE_CODE", "(", "*", "node", ")", "==", "VAR_DECL", ")", "{", "tree", "fntype", "=", "TREE_TYPE", "(", "*", "node", ")", ";", "if", "(", "fntype", "&&", "TREE_CODE", "(", "fntype", ")", "==", "POINTER_TYPE", ")", "{", "tree", "attrs", "=", "tree_cons", "(", "get_identifier", "(", "\"aux\"", ")", ",", "NULL_TREE", ",", "TYPE_ATTRIBUTES", "(", "fntype", ")", ")", ";", "TYPE_ATTRIBUTES", "(", "fntype", ")", "=", "attrs", ";", "}", "}", "}", "return", "NULL_TREE", ";", "}", "</s>"], "natrual_language": ["Handle", "aux", "attribute", ".", "The", "auxiliary", "registers", "are", "addressed", "using", "special", "instructions", "lr", "and", "sr", ".", "The", "attribute", "'aux", "'", "indicates", "if", "a", "variable", "refers", "to", "the", "aux-regs", "and", "what", "is", "the", "register", "number", "desired", "."], "TS_V_token": ["arc", "\"%qE attribute only applies to variables\"", "0", "0", "\"%qE attribute allows only an integer \"", "\"constant argument\"", "\"aux\""], "File": "arc7", "Func": "arc_handle_aux_attribute", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33598, "Length": 186}
{"ground_truth": ["<s>", "static", "void", "arc_init", "(", "void", ")", "{", "if", "(", "TARGET_V2", ")", "{", "if", "(", "TARGET_MPYW", "||", "TARGET_MULTI", ")", "arc_multcost", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "}", "if", "(", "arc_multcost", "<", "0", ")", "switch", "(", "arc_tune", ")", "{", "case", "ARC_TUNE_ARC700_4_2_STD", ":", "arc_multcost", "=", "COSTS_N_INSNS", "(", "4", ")", ";", "if", "(", "TARGET_NOMPY_SET", ")", "arc_multcost", "=", "COSTS_N_INSNS", "(", "30", ")", ";", "break", ";", "case", "ARC_TUNE_ARC700_4_2_XMAC", ":", "arc_multcost", "=", "COSTS_N_INSNS", "(", "3", ")", ";", "if", "(", "TARGET_NOMPY_SET", ")", "arc_multcost", "=", "COSTS_N_INSNS", "(", "30", ")", ";", "break", ";", "case", "ARC_TUNE_ARC600", ":", "if", "(", "TARGET_MUL64_SET", ")", "{", "arc_multcost", "=", "COSTS_N_INSNS", "(", "4", ")", ";", "break", ";", "}", "default", ":", "arc_multcost", "=", "COSTS_N_INSNS", "(", "30", ")", ";", "break", ";", "}", "if", "(", "TARGET_NOMPY_SET", "&&", "TARGET_ARC600_FAMILY", ")", "error", "(", "\"-mno-mpy supported only for ARC700 or ARCv2\"", ")", ";", "if", "(", "!", "TARGET_DPFP", "&&", "TARGET_DPFP_DISABLE_LRSR", ")", "error", "(", "\"-mno-dpfp-lrsr supported only with -mdpfp\"", ")", ";", "if", "(", "(", "TARGET_DPFP_FAST_SET", "&&", "TARGET_DPFP_COMPACT_SET", ")", "||", "(", "TARGET_SPFP_FAST_SET", "&&", "TARGET_SPFP_COMPACT_SET", ")", ")", "error", "(", "\"FPX fast and compact options cannot be specified together\"", ")", ";", "if", "(", "TARGET_SPFP_FAST_SET", "&&", "TARGET_ARC600_FAMILY", ")", "error", "(", "\"-mspfp_fast not available on ARC600 or ARC601\"", ")", ";", "if", "(", "(", "TARGET_DPFP_FAST_SET", "||", "TARGET_DPFP_COMPACT_SET", "||", "TARGET_SPFP", ")", "&&", "TARGET_HARD_FLOAT", ")", "error", "(", "\"No FPX/FPU mixing allowed\"", ")", ";", "if", "(", "flag_pic", "&&", "TARGET_ARC600_FAMILY", ")", "{", "warning", "(", "DK_WARNING", ",", "\"PIC is not supported for %s. Generating non-PIC code only..\"", ",", "arc_cpu_string", ")", ";", "flag_pic", "=", "0", ";", "}", "arc_init_reg_tables", "(", ")", ";", "memset", "(", "arc_punct_chars", ",", "0", ",", "sizeof", "(", "arc_punct_chars", ")", ")", ";", "arc_punct_chars", "[", "'#'", "]", "=", "1", ";", "arc_punct_chars", "[", "'*'", "]", "=", "1", ";", "arc_punct_chars", "[", "'?'", "]", "=", "1", ";", "arc_punct_chars", "[", "'!'", "]", "=", "1", ";", "arc_punct_chars", "[", "'^'", "]", "=", "1", ";", "arc_punct_chars", "[", "'&'", "]", "=", "1", ";", "arc_punct_chars", "[", "'+'", "]", "=", "1", ";", "arc_punct_chars", "[", "'_'", "]", "=", "1", ";", "if", "(", "optimize", ">", "1", "&&", "!", "TARGET_NO_COND_EXEC", ")", "{", "opt_pass", "*", "pass_arc_ifcvt_4", "=", "make_pass_arc_ifcvt", "(", "g", ")", ";", "struct", "register_pass_info", "arc_ifcvt4_info", "=", "{", "pass_arc_ifcvt_4", ",", "\"dbr\"", ",", "1", ",", "PASS_POS_INSERT_AFTER", "}", ";", "struct", "register_pass_info", "arc_ifcvt5_info", "=", "{", "pass_arc_ifcvt_4", "->", "clone", "(", ")", ",", "\"shorten\"", ",", "1", ",", "PASS_POS_INSERT_BEFORE", "}", ";", "register_pass", "(", "&", "arc_ifcvt4_info", ")", ";", "register_pass", "(", "&", "arc_ifcvt5_info", ")", ";", "}", "if", "(", "flag_delayed_branch", ")", "{", "opt_pass", "*", "pass_arc_predicate_delay_insns", "=", "make_pass_arc_predicate_delay_insns", "(", "g", ")", ";", "struct", "register_pass_info", "arc_predicate_delay_info", "=", "{", "pass_arc_predicate_delay_insns", ",", "\"dbr\"", ",", "1", ",", "PASS_POS_INSERT_AFTER", "}", ";", "register_pass", "(", "&", "arc_predicate_delay_info", ")", ";", "}", "}", "</s>"], "natrual_language": ["Called", "by", "OVERRIDE_OPTIONS", "to", "initialize", "various", "things", "."], "TS_V_token": ["arc", "1", "0", "4", "30", "3", "30", "4", "30", "\"-mno-mpy supported only for ARC700 or ARCv2\"", "\"-mno-dpfp-lrsr supported only with -mdpfp\"", "\"FPX fast and compact options cannot be specified together\"", "\"-mspfp_fast not available on ARC600 or ARC601\"", "\"No FPX/FPU mixing allowed\"", "\"PIC is not supported for %s. Generating non-PIC code only..\"", "0", "0", "1", "1", "1", "1", "1", "1", "1", "1", "1", "\"dbr\"", "1", "\"shorten\"", "1", "\"dbr\"", "1"], "File": "arc7", "Func": "arc_init", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33599, "Length": 376}
{"ground_truth": ["<s>", "int", "arc_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "if", "(", "!", "cfun", "->", "machine", "->", "frame_info", ".", "initialized", ")", "arc_compute_frame_size", "(", ")", ";", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "FRAME_POINTER_REGNUM", ")", "{", "return", "(", "cfun", "->", "machine", "->", "frame_info", ".", "extra_size", "+", "cfun", "->", "machine", "->", "frame_info", ".", "reg_size", ")", ";", "}", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "{", "return", "(", "cfun", "->", "machine", "->", "frame_info", ".", "total_size", "-", "cfun", "->", "machine", "->", "frame_info", ".", "pretend_size", ")", ";", "}", "if", "(", "(", "from", "==", "FRAME_POINTER_REGNUM", ")", "&&", "(", "to", "==", "STACK_POINTER_REGNUM", ")", ")", "{", "return", "(", "cfun", "->", "machine", "->", "frame_info", ".", "total_size", "-", "(", "cfun", "->", "machine", "->", "frame_info", ".", "pretend_size", "+", "cfun", "->", "machine", "->", "frame_info", ".", "extra_size", "+", "cfun", "->", "machine", "->", "frame_info", ".", "reg_size", ")", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>"], "natrual_language": ["Define", "the", "offset", "between", "two", "registers", ",", "one", "to", "be", "eliminated", ",", "and", "the", "other", "its", "replacement", ",", "at", "the", "start", "of", "a", "routine", "."], "TS_V_token": ["arc"], "File": "arc7", "Func": "arc_initial_elimination_offset", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33600, "Length": 145}
{"ground_truth": ["<s>", "bool", "arc_is_uncached_mem_p", "(", "rtx", "pat", ")", "{", "tree", "attrs", ";", "tree", "ttype", ";", "struct", "mem_attrs", "*", "refattrs", ";", "if", "(", "!", "MEM_P", "(", "pat", ")", ")", "return", "false", ";", "refattrs", "=", "MEM_ATTRS", "(", "pat", ")", ";", "if", "(", "!", "refattrs", "||", "!", "refattrs", "->", "expr", ")", "return", "false", ";", "ttype", "=", "TREE_TYPE", "(", "refattrs", "->", "expr", ")", ";", "if", "(", "!", "ttype", ")", "return", "false", ";", "attrs", "=", "TYPE_ATTRIBUTES", "(", "ttype", ")", ";", "if", "(", "lookup_attribute", "(", "\"uncached\"", ",", "attrs", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Return", "TRUE", "if", "PAT", "is", "a", "memory", "addressing", "an", "uncached", "data", "."], "TS_V_token": ["arc", "\"uncached\""], "File": "arc7", "Func": "arc_is_uncached_mem_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33601, "Length": 89}
{"ground_truth": ["<s>", "int", "arc_label_align", "(", "rtx_insn", "*", "label", ")", "{", "if", "(", "align_labels_log", "<", "1", ")", "{", "rtx_insn", "*", "next", "=", "next_nonnote_nondebug_insn", "(", "label", ")", ";", "if", "(", "INSN_P", "(", "next", ")", "&&", "recog_memoized", "(", "next", ")", ">=", "0", ")", "return", "1", ";", "}", "return", "align_labels_log", ";", "}", "</s>"], "natrual_language": ["Oddly", "enough", ",", "sometimes", "we", "get", "a", "zero", "overhead", "loop", "that", "branch", "shortening", "does", "n't", "think", "is", "a", "loop", "-", "observed", "with", "compile/pr24883.c", "-O3", "-fomit-frame-pointer", "-funroll-loops", ".", "Make", "sure", "to", "include", "the", "alignment", "visible", "for", "branch", "shortening", "(", "we", "actually", "align", "the", "loop", "insn", "before", "it", ",", "but", "that", "is", "equivalent", "since", "the", "loop", "insn", "is", "4", "byte", "long", ".", ")"], "TS_V_token": ["arc", "1", "0", "1"], "File": "arc7", "Func": "arc_label_align", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33602, "Length": 46}
{"ground_truth": ["<s>", "static", "bool", "arc_must_save_register", "(", "int", "regno", ",", "struct", "function", "*", "func", ")", "{", "unsigned", "int", "fn_type", "=", "arc_compute_function_type", "(", "func", ")", ";", "bool", "irq_auto_save_p", "=", "(", "(", "irq_ctrl_saved", ".", "irq_save_last_reg", ">=", "regno", ")", "&&", "ARC_AUTO_IRQ_P", "(", "fn_type", ")", ")", ";", "bool", "firq_auto_save_p", "=", "ARC_FAST_INTERRUPT_P", "(", "fn_type", ")", ";", "switch", "(", "rgf_banked_register_count", ")", "{", "case", "4", ":", "firq_auto_save_p", "&=", "(", "regno", "<", "4", ")", ";", "break", ";", "case", "8", ":", "firq_auto_save_p", "&=", "(", "(", "regno", "<", "4", ")", "||", "(", "(", "regno", ">", "11", ")", "&&", "(", "regno", "<", "16", ")", ")", ")", ";", "break", ";", "case", "16", ":", "firq_auto_save_p", "&=", "(", "(", "regno", "<", "4", ")", "||", "(", "(", "regno", ">", "9", ")", "&&", "(", "regno", "<", "16", ")", ")", "||", "(", "(", "regno", ">", "25", ")", "&&", "(", "regno", "<", "29", ")", ")", "||", "(", "(", "regno", ">", "29", ")", "&&", "(", "regno", "<", "32", ")", ")", ")", ";", "break", ";", "case", "32", ":", "firq_auto_save_p", "&=", "(", "regno", "!=", "29", ")", "&&", "(", "regno", "<", "32", ")", ";", "break", ";", "default", ":", "firq_auto_save_p", "=", "false", ";", "break", ";", "}", "if", "(", "(", "regno", ")", "!=", "RETURN_ADDR_REGNUM", "&&", "(", "regno", ")", "!=", "FRAME_POINTER_REGNUM", "&&", "df_regs_ever_live_p", "(", "regno", ")", "&&", "(", "!", "call_used_regs", "[", "regno", "]", "||", "ARC_INTERRUPT_P", "(", "fn_type", ")", ")", "&&", "!", "irq_auto_save_p", "&&", "!", "firq_auto_save_p", ")", "return", "true", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Tell", "prologue", "and", "epilogue", "if", "register", "REGNO", "should", "be", "saved", "/", "restored", ".", "The", "return", "address", ",", "stack", "pointer", "and", "frame", "pointer", "are", "treated", "separately", ".", "Do", "n't", "consider", "them", "here", ".", "Addition", "for", "pic", ":", "The", "gp", "register", "needs", "to", "be", "saved", "if", "the", "current", "function", "changes", "it", "to", "access", "gotoff", "variables", ".", "FIXME", ":", "This", "will", "not", "be", "needed", "if", "we", "used", "some", "arbitrary", "register", "instead", "of", "r26", "."], "TS_V_token": ["arc", "4", "4", "8", "4", "11", "16", "16", "4", "9", "16", "25", "29", "29", "32", "32", "29", "32"], "File": "arc7", "Func": "arc_must_save_register", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33603, "Length": 225}
{"ground_truth": ["<s>", "static", "void", "arc_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", "thunk", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "int", "mi_delta", "=", "delta", ";", "const", "char", "*", "const", "mi_op", "=", "mi_delta", "<", "0", "?", "\"sub\"", ":", "\"add\"", ";", "int", "shift", "=", "0", ";", "int", "this_regno", "=", "aggregate_value_p", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "function", ")", ")", ",", "function", ")", "?", "1", ":", "0", ";", "rtx", "fnaddr", ";", "if", "(", "mi_delta", "<", "0", ")", "mi_delta", "=", "-", "mi_delta", ";", "while", "(", "mi_delta", "!=", "0", ")", "{", "if", "(", "(", "mi_delta", "&", "(", "3", "<<", "shift", ")", ")", "==", "0", ")", "shift", "+=", "2", ";", "else", "{", "asm_fprintf", "(", "file", ",", "\"\\t%s\\t%s, %s, %d\\n\"", ",", "mi_op", ",", "reg_names", "[", "this_regno", "]", ",", "reg_names", "[", "this_regno", "]", ",", "mi_delta", "&", "(", "0xff", "<<", "shift", ")", ")", ";", "mi_delta", "&=", "~", "(", "0xff", "<<", "shift", ")", ";", "shift", "+=", "8", ";", "}", "}", "if", "(", "vcall_offset", "!=", "0", ")", "{", "asm_fprintf", "(", "file", ",", "\"\\tld\\t%s, [%s]\\n\"", ",", "ARC_TEMP_SCRATCH_REG", ",", "reg_names", "[", "this_regno", "]", ")", ";", "asm_fprintf", "(", "file", ",", "\"\\tadd\\t%s, %s, \"", "HOST_WIDE_INT_PRINT_DEC", "\"\\n\"", ",", "ARC_TEMP_SCRATCH_REG", ",", "ARC_TEMP_SCRATCH_REG", ",", "vcall_offset", ")", ";", "asm_fprintf", "(", "file", ",", "\"\\tld\\t%s, [%s]\\n\"", ",", "ARC_TEMP_SCRATCH_REG", ",", "ARC_TEMP_SCRATCH_REG", ")", ";", "asm_fprintf", "(", "file", ",", "\"\\tadd\\t%s, %s, %s\\n\"", ",", "reg_names", "[", "this_regno", "]", ",", "reg_names", "[", "this_regno", "]", ",", "ARC_TEMP_SCRATCH_REG", ")", ";", "}", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ";", "if", "(", "arc_is_longcall_p", "(", "fnaddr", ")", ")", "{", "if", "(", "flag_pic", ")", "{", "asm_fprintf", "(", "file", ",", "\"\\tld\\t%s, [pcl, @\"", ",", "ARC_TEMP_SCRATCH_REG", ")", ";", "assemble_name", "(", "file", ",", "XSTR", "(", "fnaddr", ",", "0", ")", ")", ";", "fputs", "(", "\"@gotpc]\\n\"", ",", "file", ")", ";", "asm_fprintf", "(", "file", ",", "\"\\tj\\t[%s]\"", ",", "ARC_TEMP_SCRATCH_REG", ")", ";", "}", "else", "{", "fputs", "(", "\"\\tj\\t@\"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "XSTR", "(", "fnaddr", ",", "0", ")", ")", ";", "}", "}", "else", "{", "fputs", "(", "\"\\tb\\t@\"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "XSTR", "(", "fnaddr", ",", "0", ")", ")", ";", "if", "(", "flag_pic", ")", "fputs", "(", "\"@plt\\n\"", ",", "file", ")", ";", "}", "fputc", "(", "'\\n'", ",", "file", ")", ";", "}", "</s>"], "natrual_language": ["Output", "code", "to", "add", "DELTA", "to", "the", "first", "argument", ",", "and", "then", "jump", "to", "FUNCTION", ".", "Used", "for", "C++", "multiple", "inheritance", "."], "TS_V_token": ["arc", "0", "\"sub\"", "\"add\"", "0", "1", "0", "0", "0", "3", "0", "2", "\"\\t%s\\t%s, %s, %d\\n\"", "0xff", "0xff", "8", "0", "\"\\tld\\t%s, [%s]\\n\"", "\"\\tadd\\t%s, %s, \"", "\"\\n\"", "\"\\tld\\t%s, [%s]\\n\"", "\"\\tadd\\t%s, %s, %s\\n\"", "0", "\"\\tld\\t%s, [pcl, @\"", "0", "\"@gotpc]\\n\"", "\"\\tj\\t[%s]\"", "\"\\tj\\t@\"", "0", "\"\\tb\\t@\"", "0", "\"@plt\\n\""], "File": "arc7", "Func": "arc_output_mi_thunk", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33604, "Length": 343}
{"ground_truth": ["<s>", "int", "arc_register_move_cost", "(", "machine_mode", ",", "enum", "reg_class", "from_class", ",", "enum", "reg_class", "to_class", ")", "{", "if", "(", "TARGET_ARC600", ")", "{", "if", "(", "to_class", "==", "MPY_WRITABLE_CORE_REGS", ")", "return", "3", ";", "else", "if", "(", "to_class", "==", "LPCOUNT_REG", ")", "return", "6", ";", "else", "if", "(", "to_class", "==", "WRITABLE_CORE_REGS", ")", "return", "6", ";", "}", "if", "(", "from_class", "==", "LPCOUNT_REG", ")", "return", "1000", ";", "if", "(", "to_class", "==", "LPCOUNT_REG", ")", "return", "6", ";", "if", "(", "(", "TARGET_ARC700", "||", "TARGET_EM", ")", "&&", "TARGET_DPFP", "&&", "from_class", "==", "DOUBLE_REGS", "&&", "to_class", "==", "DOUBLE_REGS", ")", "return", "100", ";", "return", "2", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_REGISTER_MOVE_COST", "."], "TS_V_token": ["arc", "3", "6", "6", "1000", "6", "100", "2"], "File": "arc7", "Func": "arc_register_move_cost", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33605, "Length": 92}
{"ground_truth": ["<s>", "int", "arc_return_address_register", "(", "unsigned", "int", "fn_type", ")", "{", "int", "regno", "=", "0", ";", "if", "(", "ARC_INTERRUPT_P", "(", "fn_type", ")", ")", "{", "if", "(", "(", "(", "fn_type", "&", "ARC_FUNCTION_ILINK1", ")", "|", "ARC_FUNCTION_FIRQ", ")", "!=", "0", ")", "regno", "=", "ILINK1_REGNUM", ";", "else", "if", "(", "(", "fn_type", "&", "ARC_FUNCTION_ILINK2", ")", "!=", "0", ")", "regno", "=", "ILINK2_REGNUM", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "ARC_NORMAL_P", "(", "fn_type", ")", "||", "ARC_NAKED_P", "(", "fn_type", ")", ")", "regno", "=", "RETURN_ADDR_REGNUM", ";", "gcc_assert", "(", "regno", "!=", "0", ")", ";", "return", "regno", ";", "}", "</s>"], "natrual_language": ["Return", "the", "register", "number", "of", "the", "register", "holding", "the", "return", "address", "for", "a", "function", "of", "type", "TYPE", "."], "TS_V_token": ["arc", "0", "0", "0", "0"], "File": "arc7", "Func": "arc_return_address_register", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33606, "Length": 88}
{"ground_truth": ["<s>", "rtx", "arc_rewrite_small_data", "(", "rtx", "op", ")", "{", "op", "=", "arc_rewrite_small_data_1", "(", "op", ")", ";", "if", "(", "MEM_P", "(", "op", ")", "&&", "!", "LEGITIMATE_SMALL_DATA_ADDRESS_P", "(", "XEXP", "(", "op", ",", "0", ")", ")", ")", "{", "rtx", "addr", "=", "XEXP", "(", "op", ",", "0", ")", ";", "rtx", "tmp", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_move_insn", "(", "tmp", ",", "addr", ")", ";", "op", "=", "replace_equiv_address_nv", "(", "op", ",", "tmp", ")", ";", "}", "return", "op", ";", "}", "</s>"], "natrual_language": ["If", "possible", ",", "rewrite", "OP", "so", "that", "it", "refers", "to", "small", "data", "using", "explicit", "relocations", "."], "TS_V_token": ["arc", "0", "0"], "File": "arc7", "Func": "arc_rewrite_small_data", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33607, "Length": 72}
{"ground_truth": ["<s>", "static", "rtx", "arc_rewrite_small_data_1", "(", "rtx", "op", ")", "{", "rtx", "rgp", "=", "gen_rtx_REG", "(", "Pmode", ",", "SDATA_BASE_REGNUM", ")", ";", "op", "=", "copy_insn", "(", "op", ")", ";", "subrtx_ptr_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX_PTR", "(", "iter", ",", "array", ",", "&", "op", ",", "ALL", ")", "{", "rtx", "*", "loc", "=", "*", "iter", ";", "if", "(", "arc_rewrite_small_data_p", "(", "*", "loc", ")", ")", "{", "*", "loc", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "rgp", ",", "*", "loc", ")", ";", "iter", ".", "skip_subrtxes", "(", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "*", "loc", ")", "==", "PLUS", "&&", "rtx_equal_p", "(", "XEXP", "(", "*", "loc", ",", "0", ")", ",", "rgp", ")", ")", "iter", ".", "skip_subrtxes", "(", ")", ";", "}", "return", "op", ";", "}", "</s>"], "natrual_language": ["If", "possible", ",", "rewrite", "OP", "so", "that", "it", "refers", "to", "small", "data", "using", "explicit", "relocations", "."], "TS_V_token": ["arc", "0"], "File": "arc7", "Func": "arc_rewrite_small_data_1", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33608, "Length": 113}
{"ground_truth": ["<s>", "static", "reg_class_t", "arc_secondary_reload", "(", "bool", "in_p", ",", "rtx", "x", ",", "reg_class_t", "cl", ",", "machine_mode", "mode", ",", "secondary_reload_info", "*", "sri", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "if", "(", "cl", "==", "DOUBLE_REGS", ")", "return", "GENERAL_REGS", ";", "if", "(", "(", "cl", "==", "LPCOUNT_REG", "||", "cl", "==", "WRITABLE_CORE_REGS", ")", "&&", "in_p", "&&", "MEM_P", "(", "x", ")", ")", "return", "GENERAL_REGS", ";", "if", "(", "code", "==", "SUBREG", ")", "{", "rtx", "addr", "=", "NULL_RTX", ";", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "if", "(", "REG_P", "(", "x", ")", ")", "{", "int", "regno", "=", "REGNO", "(", "x", ")", ";", "if", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "regno", "=", "reg_renumber", "[", "regno", "]", ";", "if", "(", "regno", "!=", "-", "1", ")", "return", "NO_REGS", ";", "if", "(", "reg_equiv_mem", "(", "REGNO", "(", "x", ")", ")", ")", "{", "rtx", "mem", "=", "reg_equiv_mem", "(", "REGNO", "(", "x", ")", ")", ";", "addr", "=", "find_replacement", "(", "&", "XEXP", "(", "mem", ",", "0", ")", ")", ";", "}", "}", "else", "{", "gcc_assert", "(", "MEM_P", "(", "x", ")", ")", ";", "addr", "=", "XEXP", "(", "x", ",", "0", ")", ";", "addr", "=", "simplify_rtx", "(", "addr", ")", ";", "}", "if", "(", "addr", "&&", "GET_CODE", "(", "addr", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "&&", "(", "!", "RTX_OK_FOR_OFFSET_P", "(", "mode", ",", "XEXP", "(", "addr", ",", "1", ")", ")", ")", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "sri", "->", "icode", "=", "in_p", "?", "CODE_FOR_reload_qi_load", ":", "CODE_FOR_reload_qi_store", ";", "break", ";", "case", "E_HImode", ":", "sri", "->", "icode", "=", "in_p", "?", "CODE_FOR_reload_hi_load", ":", "CODE_FOR_reload_hi_store", ";", "break", ";", "default", ":", "break", ";", "}", "}", "}", "return", "NO_REGS", ";", "}", "</s>"], "natrual_language": ["For", "ARC", "base", "register", "+", "offset", "addressing", ",", "the", "validity", "of", "the", "address", "is", "mode-dependent", "for", "most", "of", "the", "offset", "range", ",", "as", "the", "offset", "can", "be", "scaled", "by", "the", "access", "size", ".", "We", "do", "n't", "expose", "these", "as", "mode-dependent", "addresses", "in", "the", "mode_dependent_address_p", "target", "hook", ",", "because", "that", "would", "disable", "lots", "of", "optimizations", ",", "and", "most", "uses", "of", "these", "addresses", "are", "for", "32", "or", "64", "bit", "accesses", "anyways", ",", "which", "are", "fine", ".", "However", ",", "that", "leaves", "some", "addresses", "for", "8", "/", "16", "bit", "values", "not", "properly", "reloaded", "by", "the", "generic", "code", ",", "which", "is", "why", "we", "have", "to", "schedule", "secondary", "reloads", "for", "these", "."], "TS_V_token": ["arc", "1", "0", "0", "1", "1"], "File": "arc7", "Func": "arc_secondary_reload", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33609, "Length": 266}
{"ground_truth": ["<s>", "static", "int", "arc_verify_short", "(", "rtx_insn", "*", "insn", ",", "int", ",", "int", "check_attr", ")", "{", "enum", "attr_iscompact", "iscompact", ";", "struct", "machine_function", "*", "machine", ";", "if", "(", "check_attr", ">", "0", ")", "{", "iscompact", "=", "get_attr_iscompact", "(", "insn", ")", ";", "if", "(", "iscompact", "==", "ISCOMPACT_FALSE", ")", "return", "0", ";", "}", "machine", "=", "cfun", "->", "machine", ";", "if", "(", "machine", "->", "force_short_suffix", ">=", "0", ")", "return", "machine", "->", "force_short_suffix", ";", "return", "(", "get_attr_length", "(", "insn", ")", "&", "2", ")", "!=", "0", ";", "}", "</s>"], "natrual_language": ["Return", "non-zero", "if", "INSN", "should", "be", "output", "as", "a", "short", "insn", ".", "UNALIGN", "is", "zero", "if", "the", "current", "insn", "is", "aligned", "to", "a", "4-byte-boundary", ",", "two", "otherwise", ".", "If", "CHECK_ATTR", "is", "greater", "than", "0", ",", "check", "the", "iscompact", "attribute", "first", "."], "TS_V_token": ["arc", "0", "0", "0", "2", "0"], "File": "arc7", "Func": "arc_verify_short", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33610, "Length": 79}
{"ground_truth": ["<s>", "bool", "compact_sda_memory_operand", "(", "rtx", "op", ",", "machine_mode", "mode", ",", "bool", "short_p", ")", "{", "rtx", "addr", ";", "int", "size", ";", "tree", "decl", "=", "NULL_TREE", ";", "int", "align", "=", "0", ";", "int", "mask", "=", "0", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "false", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "GET_MODE", "(", "op", ")", ";", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "size", ">", "UNITS_PER_WORD", ")", "return", "false", ";", "addr", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "!", "LEGITIMATE_SMALL_DATA_ADDRESS_P", "(", "addr", ")", ")", "return", "false", ";", "if", "(", "!", "short_p", "||", "size", "==", "1", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "==", "SYMBOL_REF", ")", "decl", "=", "SYMBOL_REF_DECL", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ";", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "XEXP", "(", "addr", ",", "1", ")", ",", "0", ")", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", "decl", "=", "SYMBOL_REF_DECL", "(", "XEXP", "(", "XEXP", "(", "XEXP", "(", "addr", ",", "1", ")", ",", "0", ")", ",", "0", ")", ")", ";", "if", "(", "decl", ")", "align", "=", "DECL_ALIGN", "(", "decl", ")", ";", "align", "=", "align", "/", "BITS_PER_UNIT", ";", "switch", "(", "mode", ")", "{", "case", "E_HImode", ":", "mask", "=", "1", ";", "break", ";", "default", ":", "mask", "=", "3", ";", "break", ";", "}", "if", "(", "align", "&&", "(", "(", "align", "&", "mask", ")", "==", "0", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["volatile", "cache", "option", "still", "to", "be", "handled", "."], "TS_V_token": ["arc", "0", "0", "0", "1", "1", "1", "1", "0", "0", "1", "0", "0", "1", "3", "0"], "File": "arc7", "Func": "compact_sda_memory_operand", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33611, "Length": 241}
{"ground_truth": ["<s>", "static", "void", "irq_range", "(", "const", "char", "*", "cstr", ")", "{", "int", "i", ",", "first", ",", "last", ",", "blink", ",", "lpcount", ",", "xreg", ";", "char", "*", "str", ",", "*", "dash", ",", "*", "comma", ";", "i", "=", "strlen", "(", "cstr", ")", ";", "str", "=", "(", "char", "*", ")", "alloca", "(", "i", "+", "1", ")", ";", "memcpy", "(", "str", ",", "cstr", ",", "i", "+", "1", ")", ";", "blink", "=", "-", "1", ";", "lpcount", "=", "-", "1", ";", "dash", "=", "strchr", "(", "str", ",", "'-'", ")", ";", "if", "(", "!", "dash", ")", "{", "warning", "(", "0", ",", "\"value of -mirq-ctrl-saved must have form R0-REGx\"", ")", ";", "return", ";", "}", "*", "dash", "=", "'\\0'", ";", "comma", "=", "strchr", "(", "dash", "+", "1", ",", "','", ")", ";", "if", "(", "comma", ")", "*", "comma", "=", "'\\0'", ";", "first", "=", "decode_reg_name", "(", "str", ")", ";", "if", "(", "first", "!=", "0", ")", "{", "warning", "(", "0", ",", "\"first register must be R0\"", ")", ";", "return", ";", "}", "if", "(", "!", "strcmp", "(", "dash", "+", "1", ",", "\"ilink\"", ")", ")", "last", "=", "29", ";", "else", "last", "=", "decode_reg_name", "(", "dash", "+", "1", ")", ";", "if", "(", "last", "<", "0", ")", "{", "warning", "(", "0", ",", "\"unknown register name: %s\"", ",", "dash", "+", "1", ")", ";", "return", ";", "}", "if", "(", "!", "(", "last", "&", "0x01", ")", ")", "{", "warning", "(", "0", ",", "\"last register name %s must be an odd register\"", ",", "dash", "+", "1", ")", ";", "return", ";", "}", "*", "dash", "=", "'-'", ";", "if", "(", "first", ">", "last", ")", "{", "warning", "(", "0", ",", "\"%s-%s is an empty range\"", ",", "str", ",", "dash", "+", "1", ")", ";", "return", ";", "}", "while", "(", "comma", ")", "{", "*", "comma", "=", "','", ";", "str", "=", "comma", "+", "1", ";", "comma", "=", "strchr", "(", "str", ",", "','", ")", ";", "if", "(", "comma", ")", "*", "comma", "=", "'\\0'", ";", "xreg", "=", "decode_reg_name", "(", "str", ")", ";", "switch", "(", "xreg", ")", "{", "case", "31", ":", "blink", "=", "31", ";", "break", ";", "case", "60", ":", "lpcount", "=", "60", ";", "break", ";", "default", ":", "warning", "(", "0", ",", "\"unknown register name: %s\"", ",", "str", ")", ";", "return", ";", "}", "}", "irq_ctrl_saved", ".", "irq_save_last_reg", "=", "last", ";", "irq_ctrl_saved", ".", "irq_save_blink", "=", "(", "blink", "==", "31", ")", "||", "(", "last", "==", "31", ")", ";", "irq_ctrl_saved", ".", "irq_save_lpcount", "=", "(", "lpcount", "==", "60", ")", ";", "}", "</s>"], "natrual_language": ["Parse", "-mirq-ctrl-saved=RegisterRange", ",", "blink", ",", "lp_copunt", ".", "The", "register", "range", "is", "specified", "as", "two", "registers", "separated", "by", "a", "dash", ".", "It", "always", "starts", "with", "r0", ",", "and", "its", "upper", "limit", "is", "fp", "register", ".", "blink", "and", "lp_count", "registers", "are", "optional", "."], "TS_V_token": ["arc", "1", "1", "1", "1", "0", "\"value of -mirq-ctrl-saved must have form R0-REGx\"", "1", "0", "0", "\"first register must be R0\"", "1", "\"ilink\"", "29", "1", "0", "0", "\"unknown register name: %s\"", "1", "0x01", "0", "\"last register name %s must be an odd register\"", "1", "0", "\"%s-%s is an empty range\"", "1", "1", "31", "31", "60", "60", "0", "\"unknown register name: %s\"", "31", "31", "60"], "File": "arc7", "Func": "irq_range", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33612, "Length": 359}
{"ground_truth": ["<s>", "static", "bool", "legitimate_scaled_address_p", "(", "machine_mode", "mode", ",", "rtx", "op", ",", "bool", "strict", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "!=", "PLUS", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "!=", "MULT", ")", "return", "false", ";", "if", "(", "!", "RTX_OK_FOR_INDEX_P", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "0", ")", ",", "strict", ")", ")", "return", "false", ";", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ")", ")", "return", "false", ";", "switch", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", "{", "case", "2", ":", "if", "(", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ")", "!=", "2", ")", "return", "false", ";", "break", ";", "case", "8", ":", "if", "(", "!", "TARGET_LL64", ")", "return", "false", ";", "case", "4", ":", "if", "(", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ")", "!=", "4", ")", "return", "false", ";", "default", ":", "return", "false", ";", "}", "if", "(", "RTX_OK_FOR_BASE_P", "(", "XEXP", "(", "op", ",", "1", ")", ",", "(", "strict", ")", ")", ")", "return", "true", ";", "if", "(", "flag_pic", ")", "{", "if", "(", "CONST_INT_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "if", "(", "CONSTANT_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "op", ",", "1", ")", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_SMALL_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["TRUE", "if", "op", "is", "an", "scaled", "address", "."], "TS_V_token": ["arc", "0", "0", "0", "0", "1", "2", "0", "1", "2", "8", "4", "0", "1", "4", "1", "1", "1", "1", "1"], "File": "arc7", "Func": "legitimate_scaled_address_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33613, "Length": 255}
{"ground_truth": ["<s>", "static", "void", "parse_mrgf_banked_regs_option", "(", "const", "char", "*", "arg", ")", "{", "long", "int", "val", ";", "char", "*", "end_ptr", ";", "errno", "=", "0", ";", "val", "=", "strtol", "(", "arg", ",", "&", "end_ptr", ",", "10", ")", ";", "if", "(", "errno", "!=", "0", "||", "*", "arg", "==", "'\\0'", "||", "*", "end_ptr", "!=", "'\\0'", "||", "(", "val", "!=", "0", "&&", "val", "!=", "4", "&&", "val", "!=", "8", "&&", "val", "!=", "16", "&&", "val", "!=", "32", ")", ")", "{", "error", "(", "\"invalid number in -mrgf-banked-regs=%s \"", "\"valid values are 0, 4, 8, 16, or 32\"", ",", "arg", ")", ";", "return", ";", "}", "rgf_banked_register_count", "=", "(", "int", ")", "val", ";", "}", "</s>"], "natrual_language": ["Parse", "-mrgf-banked-regs=NUM", "option", "string", ".", "Valid", "values", "for", "NUM", "are", "4", ",", "8", ",", "16", ",", "or", "32", "."], "TS_V_token": ["arc", "0", "10", "0", "0", "4", "8", "16", "32", "\"invalid number in -mrgf-banked-regs=%s \"", "\"valid values are 0, 4, 8, 16, or 32\""], "File": "arc7", "Func": "parse_mrgf_banked_regs_option", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33614, "Length": 92}
{"ground_truth": ["<s>", "bool", "small_data_pattern", "(", "rtx", "op", ",", "machine_mode", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "SEQUENCE", ")", "return", "false", ";", "rtx", "rgp", "=", "gen_rtx_REG", "(", "Pmode", ",", "SDATA_BASE_REGNUM", ")", ";", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "op", ",", "ALL", ")", "{", "const_rtx", "x", "=", "*", "iter", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "rtx_equal_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "rgp", ")", ")", "iter", ".", "skip_subrtxes", "(", ")", ";", "else", "if", "(", "arc_rewrite_small_data_p", "(", "x", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "OP", "refers", "to", "small", "data", "symbols", "directly", ",", "not", "through", "a", "PLUS", "."], "TS_V_token": ["arc", "0"], "File": "arc7", "Func": "small_data_pattern", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33615, "Length": 96}
{"ground_truth": ["<s>", "static", "rtx", "arc_builtin_setjmp_frame_value", "(", "void", ")", "{", "return", "gen_raw_REG", "(", "Pmode", ",", "HARD_FRAME_POINTER_REGNUM", ")", ";", "}", "</s>"], "natrual_language": ["Return", "the", "frame", "pointer", "value", "to", "be", "backed", "up", "in", "the", "setjmp", "buffer", "."], "TS_V_token": ["arc"], "File": "arc8", "Func": "arc_builtin_setjmp_frame_value", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33616, "Length": 16}
{"ground_truth": ["<s>", "static", "unsigned", "int", "arc_compute_frame_size", "(", "void", ")", "{", "int", "regno", ";", "unsigned", "int", "total_size", ",", "var_size", ",", "args_size", ",", "pretend_size", ",", "extra_size", ";", "unsigned", "int", "reg_size", ";", "unsigned", "int", "gmask", ";", "struct", "arc_frame_info", "*", "frame_info", ";", "int", "size", ";", "unsigned", "int", "extra_plus_reg_size", ";", "unsigned", "int", "extra_plus_reg_size_aligned", ";", "if", "(", "cfun", "->", "machine", "->", "frame_info", ".", "initialized", ")", "return", "cfun", "->", "machine", "->", "frame_info", ".", "total_size", ";", "frame_info", "=", "&", "cfun", "->", "machine", "->", "frame_info", ";", "size", "=", "ARC_STACK_ALIGN", "(", "get_frame_size", "(", ")", ")", ";", "var_size", "=", "size", ";", "args_size", "=", "crtl", "->", "outgoing_args_size", ";", "reg_size", "=", "0", ";", "gmask", "=", "0", ";", "for", "(", "regno", "=", "0", ";", "regno", "<=", "31", ";", "regno", "++", ")", "{", "if", "(", "arc_must_save_register", "(", "regno", ",", "cfun", ")", ")", "{", "reg_size", "+=", "UNITS_PER_WORD", ";", "gmask", "|=", "1L", "<<", "regno", ";", "}", "}", "if", "(", "crtl", "->", "calls_eh_return", ")", "for", "(", "regno", "=", "0", ";", "EH_RETURN_DATA_REGNO", "(", "regno", ")", "!=", "INVALID_REGNUM", ";", "regno", "++", ")", "{", "reg_size", "+=", "UNITS_PER_WORD", ";", "gmask", "|=", "1L", "<<", "regno", ";", "}", "frame_info", "->", "save_return_addr", "=", "(", "!", "crtl", "->", "is_leaf", "||", "df_regs_ever_live_p", "(", "RETURN_ADDR_REGNUM", ")", "||", "crtl", "->", "calls_eh_return", ")", ";", "if", "(", "TARGET_MILLICODE_THUNK_SET", "&&", "!", "crtl", "->", "calls_eh_return", ")", "{", "if", "(", "arc_compute_millicode_save_restore_regs", "(", "gmask", ",", "frame_info", ")", ")", "frame_info", "->", "save_return_addr", "=", "true", ";", "}", "extra_size", "=", "0", ";", "if", "(", "arc_must_save_return_addr", "(", "cfun", ")", ")", "extra_size", "=", "4", ";", "if", "(", "arc_frame_pointer_needed", "(", ")", ")", "extra_size", "+=", "4", ";", "pretend_size", "=", "crtl", "->", "args", ".", "pretend_args_size", ";", "extra_plus_reg_size", "=", "extra_size", "+", "reg_size", ";", "extra_plus_reg_size_aligned", "=", "ARC_STACK_ALIGN", "(", "extra_plus_reg_size", ")", ";", "reg_size", "=", "extra_plus_reg_size_aligned", "-", "extra_size", ";", "total_size", "=", "var_size", "+", "args_size", "+", "extra_size", "+", "pretend_size", "+", "reg_size", ";", "gcc_assert", "(", "total_size", "==", "ARC_STACK_ALIGN", "(", "total_size", ")", ")", ";", "frame_info", "->", "total_size", "=", "total_size", ";", "frame_info", "->", "extra_size", "=", "extra_size", ";", "frame_info", "->", "pretend_size", "=", "pretend_size", ";", "frame_info", "->", "var_size", "=", "var_size", ";", "frame_info", "->", "args_size", "=", "args_size", ";", "frame_info", "->", "reg_size", "=", "reg_size", ";", "frame_info", "->", "gmask", "=", "gmask", ";", "frame_info", "->", "initialized", "=", "reload_completed", ";", "return", "total_size", ";", "}", "</s>"], "natrual_language": ["Return", "the", "bytes", "needed", "to", "compute", "the", "frame", "pointer", "from", "the", "current", "stack", "pointer", ".", "SIZE", "is", "the", "size", "needed", "for", "local", "variables", "."], "TS_V_token": ["arc", "0", "0", "0", "31", "1L", "0", "1L", "0", "4", "4"], "File": "arc8", "Func": "arc_compute_frame_size", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33617, "Length": 344}
{"ground_truth": ["<s>", "static", "bool", "arc_enter_leave_p", "(", "unsigned", "int", "gmask", ")", "{", "int", "regno", ";", "unsigned", "int", "rmask", "=", "0", ";", "if", "(", "!", "gmask", ")", "return", "false", ";", "for", "(", "regno", "=", "ENTER_LEAVE_START_REG", ";", "regno", "<=", "ENTER_LEAVE_END_REG", "&&", "(", "gmask", "&", "(", "1L", "<<", "regno", ")", ")", ";", "regno", "++", ")", "rmask", "|=", "1L", "<<", "regno", ";", "if", "(", "rmask", "^", "gmask", ")", "return", "false", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Check", "if", "we", "have", "a", "continous", "range", "to", "be", "save/restored", "with", "the", "help", "of", "enter/leave", "instructions", ".", "A", "vaild", "register", "range", "starts", "from", "$", "r13", "and", "is", "up", "to", "(", "including", ")", "$", "r26", "."], "TS_V_token": ["arc", "0", "1L", "1L"], "File": "arc8", "Func": "arc_enter_leave_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33618, "Length": 68}
{"ground_truth": ["<s>", "void", "arc_expand_epilogue", "(", "int", "sibcall_p", ")", "{", "int", "size", ";", "unsigned", "int", "fn_type", "=", "arc_compute_function_type", "(", "cfun", ")", ";", "unsigned", "int", "size_to_deallocate", ";", "int", "restored", ";", "int", "can_trust_sp_p", "=", "!", "cfun", "->", "calls_alloca", ";", "int", "first_offset", ";", "bool", "restore_fp", "=", "arc_frame_pointer_needed", "(", ")", "&&", "!", "ARC_AUTOFP_IRQ_P", "(", "fn_type", ")", ";", "bool", "restore_blink", "=", "arc_must_save_return_addr", "(", "cfun", ")", "&&", "!", "ARC_AUTOBLINK_IRQ_P", "(", "fn_type", ")", ";", "unsigned", "int", "gmask", "=", "cfun", "->", "machine", "->", "frame_info", ".", "gmask", ";", "bool", "return_p", "=", "!", "sibcall_p", "&&", "fn_type", "==", "ARC_FUNCTION_NORMAL", "&&", "!", "cfun", "->", "machine", "->", "frame_info", ".", "pretend_size", ";", "struct", "arc_frame_info", "*", "frame", "=", "&", "cfun", "->", "machine", "->", "frame_info", ";", "if", "(", "ARC_NAKED_P", "(", "fn_type", ")", ")", "return", ";", "size", "=", "arc_compute_frame_size", "(", ")", ";", "size_to_deallocate", "=", "size", ";", "first_offset", "=", "size", "-", "(", "frame", "->", "pretend_size", "+", "frame", "->", "reg_size", "+", "frame", "->", "extra_size", ")", ";", "if", "(", "!", "can_trust_sp_p", ")", "gcc_assert", "(", "arc_frame_pointer_needed", "(", ")", ")", ";", "if", "(", "size", ")", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "if", "(", "TARGET_CODE_DENSITY", "&&", "TARGET_CODE_DENSITY_FRAME", "&&", "!", "ARC_AUTOFP_IRQ_P", "(", "fn_type", ")", "&&", "!", "ARC_AUTOBLINK_IRQ_P", "(", "fn_type", ")", "&&", "!", "ARC_INTERRUPT_P", "(", "fn_type", ")", "&&", "arc_enter_leave_p", "(", "gmask", ")", ")", "{", "size_to_deallocate", "-=", "arc_restore_callee_leave", "(", "gmask", ",", "restore_blink", ",", "restore_fp", ",", "return_p", ",", "first_offset", ")", ";", "if", "(", "return_p", ")", "{", "gcc_assert", "(", "size_to_deallocate", "==", "0", ")", ";", "return", ";", "}", "}", "else", "if", "(", "frame", "->", "millicode_end_reg", ">", "14", ")", "{", "size_to_deallocate", "-=", "arc_restore_callee_milli", "(", "gmask", ",", "restore_blink", ",", "restore_fp", ",", "return_p", ",", "first_offset", ")", ";", "if", "(", "return_p", ")", "{", "gcc_assert", "(", "size_to_deallocate", "==", "0", ")", ";", "return", ";", "}", "}", "else", "size_to_deallocate", "-=", "arc_restore_callee_saves", "(", "gmask", ",", "restore_blink", ",", "restore_fp", ",", "first_offset", ",", "size_to_deallocate", ")", ";", "restored", "=", "size", "-", "size_to_deallocate", ";", "if", "(", "size", ">", "restored", ")", "frame_stack_add", "(", "size", "-", "restored", ")", ";", "if", "(", "crtl", "->", "calls_eh_return", ")", "emit_insn", "(", "gen_add2_insn", "(", "stack_pointer_rtx", ",", "EH_RETURN_STACKADJ_RTX", ")", ")", ";", "if", "(", "sibcall_p", "==", "FALSE", ")", "emit_jump_insn", "(", "gen_simple_return", "(", ")", ")", ";", "}", "</s>"], "natrual_language": ["Do", "any", "necessary", "cleanup", "after", "a", "function", "to", "restore", "stack", ",", "frame", ",", "and", "regs", "."], "TS_V_token": ["arc", "0", "14", "0"], "File": "arc8", "Func": "arc_expand_epilogue", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33619, "Length": 334}
{"ground_truth": ["<s>", "void", "arc_expand_prologue", "(", "void", ")", "{", "int", "size", ";", "unsigned", "int", "gmask", "=", "cfun", "->", "machine", "->", "frame_info", ".", "gmask", ";", "struct", "arc_frame_info", "*", "frame", "=", "&", "cfun", "->", "machine", "->", "frame_info", ";", "unsigned", "int", "frame_size_to_allocate", ";", "int", "first_offset", "=", "0", ";", "unsigned", "int", "fn_type", "=", "arc_compute_function_type", "(", "cfun", ")", ";", "bool", "save_blink", "=", "false", ";", "bool", "save_fp", "=", "false", ";", "if", "(", "ARC_NAKED_P", "(", "fn_type", ")", ")", "{", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "0", ";", "return", ";", "}", "size", "=", "arc_compute_frame_size", "(", ")", ";", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "size", ";", "frame_size_to_allocate", "=", "size", ";", "gcc_assert", "(", "!", "(", "size", "==", "0", "&&", "gmask", ")", ")", ";", "if", "(", "frame", "->", "pretend_size", "!=", "0", ")", "first_offset", "=", "-", "frame", "->", "pretend_size", ";", "if", "(", "ARC_AUTO_IRQ_P", "(", "fn_type", ")", "&&", "!", "ARC_FAST_INTERRUPT_P", "(", "fn_type", ")", ")", "{", "frame_stack_add", "(", "first_offset", ")", ";", "first_offset", "=", "0", ";", "arc_dwarf_emit_irq_save_regs", "(", ")", ";", "}", "save_blink", "=", "arc_must_save_return_addr", "(", "cfun", ")", "&&", "!", "ARC_AUTOBLINK_IRQ_P", "(", "fn_type", ")", ";", "save_fp", "=", "arc_frame_pointer_needed", "(", ")", "&&", "!", "ARC_AUTOFP_IRQ_P", "(", "fn_type", ")", ";", "if", "(", "TARGET_CODE_DENSITY", "&&", "TARGET_CODE_DENSITY_FRAME", "&&", "!", "ARC_AUTOFP_IRQ_P", "(", "fn_type", ")", "&&", "!", "ARC_AUTOBLINK_IRQ_P", "(", "fn_type", ")", "&&", "!", "ARC_INTERRUPT_P", "(", "fn_type", ")", "&&", "arc_enter_leave_p", "(", "gmask", ")", ")", "frame_size_to_allocate", "-=", "arc_save_callee_enter", "(", "gmask", ",", "save_blink", ",", "save_fp", ",", "first_offset", ")", ";", "else", "if", "(", "frame", "->", "millicode_end_reg", ">", "14", ")", "frame_size_to_allocate", "-=", "arc_save_callee_milli", "(", "gmask", ",", "save_blink", ",", "save_fp", ",", "first_offset", ",", "frame", "->", "reg_size", ")", ";", "else", "frame_size_to_allocate", "-=", "arc_save_callee_saves", "(", "gmask", ",", "save_blink", ",", "save_fp", ",", "first_offset", ")", ";", "if", "(", "frame_size_to_allocate", ">", "0", ")", "frame_stack_add", "(", "(", "HOST_WIDE_INT", ")", "0", "-", "frame_size_to_allocate", ")", ";", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "</s>"], "natrual_language": ["Set", "up", "the", "stack", "and", "frame", "pointer", "(", "if", "desired", ")", "for", "the", "function", "."], "TS_V_token": ["arc", "0", "0", "0", "0", "0", "14", "0", "0"], "File": "arc8", "Func": "arc_expand_prologue", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33620, "Length": 284}
{"ground_truth": ["<s>", "static", "void", "arc_init", "(", "void", ")", "{", "if", "(", "TARGET_V2", ")", "{", "if", "(", "TARGET_MPYW", "||", "TARGET_MULTI", ")", "arc_multcost", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "}", "if", "(", "arc_multcost", "<", "0", ")", "switch", "(", "arc_tune", ")", "{", "case", "ARC_TUNE_ARC700_4_2_STD", ":", "arc_multcost", "=", "COSTS_N_INSNS", "(", "4", ")", ";", "if", "(", "TARGET_NOMPY_SET", ")", "arc_multcost", "=", "COSTS_N_INSNS", "(", "30", ")", ";", "break", ";", "case", "ARC_TUNE_ARC700_4_2_XMAC", ":", "arc_multcost", "=", "COSTS_N_INSNS", "(", "3", ")", ";", "if", "(", "TARGET_NOMPY_SET", ")", "arc_multcost", "=", "COSTS_N_INSNS", "(", "30", ")", ";", "break", ";", "case", "ARC_TUNE_ARC600", ":", "if", "(", "TARGET_MUL64_SET", ")", "{", "arc_multcost", "=", "COSTS_N_INSNS", "(", "4", ")", ";", "break", ";", "}", "default", ":", "arc_multcost", "=", "COSTS_N_INSNS", "(", "30", ")", ";", "break", ";", "}", "if", "(", "TARGET_NOMPY_SET", "&&", "TARGET_ARC600_FAMILY", ")", "error", "(", "\"%<-mno-mpy%> supported only for ARC700 or ARCv2\"", ")", ";", "if", "(", "!", "TARGET_DPFP", "&&", "TARGET_DPFP_DISABLE_LRSR", ")", "error", "(", "\"%<-mno-dpfp-lrsr%> supported only with %<-mdpfp%>\"", ")", ";", "if", "(", "(", "TARGET_DPFP_FAST_SET", "&&", "TARGET_DPFP_COMPACT_SET", ")", "||", "(", "TARGET_SPFP_FAST_SET", "&&", "TARGET_SPFP_COMPACT_SET", ")", ")", "error", "(", "\"FPX fast and compact options cannot be specified together\"", ")", ";", "if", "(", "TARGET_SPFP_FAST_SET", "&&", "TARGET_ARC600_FAMILY", ")", "error", "(", "\"%<-mspfp_fast%> not available on ARC600 or ARC601\"", ")", ";", "if", "(", "(", "TARGET_DPFP_FAST_SET", "||", "TARGET_DPFP_COMPACT_SET", "||", "TARGET_SPFP", ")", "&&", "TARGET_HARD_FLOAT", ")", "error", "(", "\"no FPX/FPU mixing allowed\"", ")", ";", "if", "(", "flag_pic", "&&", "TARGET_ARC600_FAMILY", ")", "{", "warning", "(", "0", ",", "\"PIC is not supported for %qs\"", ",", "arc_cpu_string", ")", ";", "flag_pic", "=", "0", ";", "}", "arc_init_reg_tables", "(", ")", ";", "memset", "(", "arc_punct_chars", ",", "0", ",", "sizeof", "(", "arc_punct_chars", ")", ")", ";", "arc_punct_chars", "[", "'#'", "]", "=", "1", ";", "arc_punct_chars", "[", "'*'", "]", "=", "1", ";", "arc_punct_chars", "[", "'?'", "]", "=", "1", ";", "arc_punct_chars", "[", "'!'", "]", "=", "1", ";", "arc_punct_chars", "[", "'^'", "]", "=", "1", ";", "arc_punct_chars", "[", "'&'", "]", "=", "1", ";", "arc_punct_chars", "[", "'+'", "]", "=", "1", ";", "arc_punct_chars", "[", "'_'", "]", "=", "1", ";", "if", "(", "optimize", ">", "1", "&&", "!", "TARGET_NO_COND_EXEC", ")", "{", "opt_pass", "*", "pass_arc_ifcvt_4", "=", "make_pass_arc_ifcvt", "(", "g", ")", ";", "struct", "register_pass_info", "arc_ifcvt4_info", "=", "{", "pass_arc_ifcvt_4", ",", "\"dbr\"", ",", "1", ",", "PASS_POS_INSERT_AFTER", "}", ";", "struct", "register_pass_info", "arc_ifcvt5_info", "=", "{", "pass_arc_ifcvt_4", "->", "clone", "(", ")", ",", "\"shorten\"", ",", "1", ",", "PASS_POS_INSERT_BEFORE", "}", ";", "register_pass", "(", "&", "arc_ifcvt4_info", ")", ";", "register_pass", "(", "&", "arc_ifcvt5_info", ")", ";", "}", "if", "(", "flag_delayed_branch", ")", "{", "opt_pass", "*", "pass_arc_predicate_delay_insns", "=", "make_pass_arc_predicate_delay_insns", "(", "g", ")", ";", "struct", "register_pass_info", "arc_predicate_delay_info", "=", "{", "pass_arc_predicate_delay_insns", ",", "\"dbr\"", ",", "1", ",", "PASS_POS_INSERT_AFTER", "}", ";", "register_pass", "(", "&", "arc_predicate_delay_info", ")", ";", "}", "}", "</s>"], "natrual_language": ["Called", "by", "OVERRIDE_OPTIONS", "to", "initialize", "various", "things", "."], "TS_V_token": ["arc", "1", "0", "4", "30", "3", "30", "4", "30", "\"%<-mno-mpy%> supported only for ARC700 or ARCv2\"", "\"%<-mno-dpfp-lrsr%> supported only with %<-mdpfp%>\"", "\"FPX fast and compact options cannot be specified together\"", "\"%<-mspfp_fast%> not available on ARC600 or ARC601\"", "\"no FPX/FPU mixing allowed\"", "0", "\"PIC is not supported for %qs\"", "0", "0", "1", "1", "1", "1", "1", "1", "1", "1", "1", "\"dbr\"", "1", "\"shorten\"", "1", "\"dbr\"", "1"], "File": "arc8", "Func": "arc_init", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33621, "Length": 376}
{"ground_truth": ["<s>", "bool", "arc_is_uncached_mem_p", "(", "rtx", "pat", ")", "{", "tree", "attrs", "=", "NULL_TREE", ";", "tree", "addr", ";", "if", "(", "!", "MEM_P", "(", "pat", ")", ")", "return", "false", ";", "addr", "=", "MEM_EXPR", "(", "pat", ")", ";", "if", "(", "!", "addr", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "addr", ")", "==", "MEM_REF", ")", "{", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "addr", ")", ")", ";", "if", "(", "lookup_attribute", "(", "\"uncached\"", ",", "attrs", ")", ")", "return", "true", ";", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "TREE_OPERAND", "(", "addr", ",", "0", ")", ")", ")", ";", "if", "(", "lookup_attribute", "(", "\"uncached\"", ",", "attrs", ")", ")", "return", "true", ";", "}", "if", "(", "TREE_CODE", "(", "addr", ")", "==", "COMPONENT_REF", ")", "{", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "TREE_OPERAND", "(", "addr", ",", "1", ")", ")", ")", ";", "if", "(", "lookup_attribute", "(", "\"uncached\"", ",", "attrs", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Return", "TRUE", "if", "PAT", "is", "a", "memory", "addressing", "an", "uncached", "data", "."], "TS_V_token": ["arc", "\"uncached\"", "0", "\"uncached\"", "1", "\"uncached\""], "File": "arc8", "Func": "arc_is_uncached_mem_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33622, "Length": 143}
{"ground_truth": ["<s>", "static", "bool", "arc_must_save_register", "(", "int", "regno", ",", "struct", "function", "*", "func", ")", "{", "unsigned", "int", "fn_type", "=", "arc_compute_function_type", "(", "func", ")", ";", "bool", "irq_auto_save_p", "=", "(", "(", "irq_ctrl_saved", ".", "irq_save_last_reg", ">=", "regno", ")", "&&", "ARC_AUTO_IRQ_P", "(", "fn_type", ")", ")", ";", "bool", "firq_auto_save_p", "=", "ARC_FAST_INTERRUPT_P", "(", "fn_type", ")", ";", "switch", "(", "rgf_banked_register_count", ")", "{", "case", "4", ":", "firq_auto_save_p", "&=", "(", "regno", "<", "4", ")", ";", "break", ";", "case", "8", ":", "firq_auto_save_p", "&=", "(", "(", "regno", "<", "4", ")", "||", "(", "(", "regno", ">", "11", ")", "&&", "(", "regno", "<", "16", ")", ")", ")", ";", "break", ";", "case", "16", ":", "firq_auto_save_p", "&=", "(", "(", "regno", "<", "4", ")", "||", "(", "(", "regno", ">", "9", ")", "&&", "(", "regno", "<", "16", ")", ")", "||", "(", "(", "regno", ">", "25", ")", "&&", "(", "regno", "<", "29", ")", ")", "||", "(", "(", "regno", ">", "29", ")", "&&", "(", "regno", "<", "32", ")", ")", ")", ";", "break", ";", "case", "32", ":", "firq_auto_save_p", "&=", "(", "regno", "!=", "29", ")", "&&", "(", "regno", "<", "32", ")", ";", "break", ";", "default", ":", "firq_auto_save_p", "=", "false", ";", "break", ";", "}", "switch", "(", "regno", ")", "{", "case", "RETURN_ADDR_REGNUM", ":", "case", "STACK_POINTER_REGNUM", ":", "return", "false", ";", "case", "HARD_FRAME_POINTER_REGNUM", ":", "if", "(", "arc_frame_pointer_needed", "(", ")", ")", "return", "false", ";", "default", ":", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "(", "!", "call_used_regs", "[", "regno", "]", "||", "ARC_INTERRUPT_P", "(", "fn_type", ")", ")", "&&", "!", "irq_auto_save_p", "&&", "!", "firq_auto_save_p", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Tell", "prologue", "and", "epilogue", "if", "register", "REGNO", "should", "be", "saved", "/", "restored", ".", "The", "return", "address", ",", "stack", "pointer", "and", "frame", "pointer", "are", "treated", "separately", ".", "Do", "n't", "consider", "them", "here", ".", "Addition", "for", "pic", ":", "The", "gp", "register", "needs", "to", "be", "saved", "if", "the", "current", "function", "changes", "it", "to", "access", "gotoff", "variables", ".", "FIXME", ":", "This", "will", "not", "be", "needed", "if", "we", "used", "some", "arbitrary", "register", "instead", "of", "r26", "."], "TS_V_token": ["arc", "4", "4", "8", "4", "11", "16", "16", "4", "9", "16", "25", "29", "29", "32", "32", "29", "32"], "File": "arc8", "Func": "arc_must_save_register", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33623, "Length": 242}
{"ground_truth": ["<s>", "static", "int", "arc_restore_callee_saves", "(", "unsigned", "int", "gmask", ",", "bool", "restore_blink", ",", "bool", "restore_fp", ",", "HOST_WIDE_INT", "offset", ",", "HOST_WIDE_INT", "allocated", ")", "{", "rtx", "reg", ";", "int", "frame_deallocated", "=", "0", ";", "HOST_WIDE_INT", "offs", "=", "cfun", "->", "machine", "->", "frame_info", ".", "reg_size", ";", "bool", "early_blink_restore", ";", "if", "(", "arc_frame_pointer_needed", "(", ")", "&&", "offset", ")", "{", "frame_move", "(", "stack_pointer_rtx", ",", "hard_frame_pointer_rtx", ")", ";", "frame_deallocated", "+=", "offset", ";", "offset", "=", "0", ";", "}", "if", "(", "restore_fp", ")", "{", "gcc_assert", "(", "offset", "==", "0", ")", ";", "frame_deallocated", "+=", "frame_restore_reg", "(", "hard_frame_pointer_rtx", ",", "0", ")", ";", "}", "if", "(", "offset", ")", "{", "frame_stack_add", "(", "offset", ")", ";", "frame_deallocated", "+=", "offset", ";", "offset", "=", "0", ";", "}", "early_blink_restore", "=", "restore_blink", "&&", "!", "optimize_size", "&&", "offs", ";", "if", "(", "early_blink_restore", ")", "{", "rtx", "addr", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offs", ")", ";", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ";", "rtx", "insn", "=", "frame_move_inc", "(", "reg", ",", "gen_frame_mem", "(", "Pmode", ",", "addr", ")", ",", "stack_pointer_rtx", ",", "NULL_RTX", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "reg", ")", ";", "restore_blink", "=", "false", ";", "}", "if", "(", "gmask", ")", "for", "(", "int", "i", "=", "0", ";", "i", "<=", "GMASK_LEN", ";", "i", "++", ")", "{", "machine_mode", "restore_mode", "=", "SImode", ";", "if", "(", "TARGET_LL64", "&&", "(", "(", "i", "%", "2", ")", "==", "0", ")", "&&", "(", "(", "gmask", "&", "(", "1L", "<<", "i", ")", ")", "!=", "0", ")", "&&", "(", "(", "gmask", "&", "(", "1L", "<<", "(", "i", "+", "1", ")", ")", ")", "!=", "0", ")", ")", "restore_mode", "=", "DImode", ";", "else", "if", "(", "(", "gmask", "&", "(", "1L", "<<", "i", ")", ")", "==", "0", ")", "continue", ";", "reg", "=", "gen_rtx_REG", "(", "restore_mode", ",", "i", ")", ";", "offs", "=", "0", ";", "switch", "(", "restore_mode", ")", "{", "case", "E_DImode", ":", "if", "(", "(", "GMASK_LEN", "-", "__builtin_clz", "(", "gmask", ")", ")", "==", "(", "i", "+", "1", ")", "&&", "early_blink_restore", ")", "offs", "=", "4", ";", "break", ";", "case", "E_SImode", ":", "if", "(", "(", "GMASK_LEN", "-", "__builtin_clz", "(", "gmask", ")", ")", "==", "i", "&&", "early_blink_restore", ")", "offs", "=", "4", ";", "break", ";", "default", ":", "offs", "=", "0", ";", "}", "frame_deallocated", "+=", "frame_restore_reg", "(", "reg", ",", "offs", ")", ";", "offset", "=", "0", ";", "if", "(", "restore_mode", "==", "DImode", ")", "i", "++", ";", "}", "if", "(", "restore_blink", ")", "{", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ";", "frame_deallocated", "+=", "frame_restore_reg", "(", "reg", ",", "allocated", "-", "frame_deallocated", "-", "UNITS_PER_WORD", ")", ";", "}", "return", "frame_deallocated", ";", "}", "</s>"], "natrual_language": ["ARC", "'s", "epilogue", ",", "restore", "any", "required", "call-saved", "regs", "(", "and", "call-used", "if", "it", "is", "for", "an", "interrupt", "handler", ")", "using", "LD/LDD", "instructions", "."], "TS_V_token": ["arc", "0", "0", "0", "0", "0", "0", "2", "0", "1L", "0", "1L", "1", "0", "1L", "0", "0", "1", "4", "4", "0", "0"], "File": "arc8", "Func": "arc_restore_callee_saves", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33624, "Length": 400}
{"ground_truth": ["<s>", "int", "arc_return_address_register", "(", "unsigned", "int", "fn_type", ")", "{", "int", "regno", "=", "0", ";", "if", "(", "ARC_INTERRUPT_P", "(", "fn_type", ")", ")", "{", "if", "(", "(", "fn_type", "&", "(", "ARC_FUNCTION_ILINK1", "|", "ARC_FUNCTION_FIRQ", ")", ")", "!=", "0", ")", "regno", "=", "ILINK1_REG", ";", "else", "if", "(", "(", "fn_type", "&", "ARC_FUNCTION_ILINK2", ")", "!=", "0", ")", "regno", "=", "ILINK2_REG", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "ARC_NORMAL_P", "(", "fn_type", ")", "||", "ARC_NAKED_P", "(", "fn_type", ")", ")", "regno", "=", "RETURN_ADDR_REGNUM", ";", "gcc_assert", "(", "regno", "!=", "0", ")", ";", "return", "regno", ";", "}", "</s>"], "natrual_language": ["Return", "the", "register", "number", "of", "the", "register", "holding", "the", "return", "address", "for", "a", "function", "of", "type", "TYPE", "."], "TS_V_token": ["arc", "0", "0", "0", "0"], "File": "arc8", "Func": "arc_return_address_register", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33625, "Length": 88}
{"ground_truth": ["<s>", "static", "int", "arc_save_callee_enter", "(", "unsigned", "int", "gmask", ",", "bool", "save_blink", ",", "bool", "save_fp", ",", "HOST_WIDE_INT", "offset", ")", "{", "int", "start_reg", "=", "ENTER_LEAVE_START_REG", ";", "int", "end_reg", "=", "ENTER_LEAVE_END_REG", ";", "int", "regno", ",", "indx", ",", "off", ",", "nregs", ";", "rtx", "insn", ",", "reg", ",", "mem", ";", "int", "frame_allocated", "=", "0", ";", "for", "(", "regno", "=", "start_reg", ";", "regno", "<=", "end_reg", "&&", "(", "gmask", "&", "(", "1L", "<<", "regno", ")", ")", ";", ")", "regno", "++", ";", "end_reg", "=", "regno", "-", "1", ";", "nregs", "=", "end_reg", "-", "start_reg", "+", "1", ";", "nregs", "+=", "save_blink", "?", "1", ":", "0", ";", "nregs", "+=", "save_fp", "?", "1", ":", "0", ";", "if", "(", "offset", ")", "frame_stack_add", "(", "offset", ")", ";", "insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "nregs", "+", "(", "save_fp", "?", "1", ":", "0", ")", "+", "1", ")", ")", ";", "indx", "=", "0", ";", "reg", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "nregs", "*", "UNITS_PER_WORD", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "reg", ")", "=", "1", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", "++", ")", "=", "reg", ";", "off", "=", "nregs", "*", "UNITS_PER_WORD", ";", "if", "(", "save_blink", ")", "{", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ";", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "off", ")", ")", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "insn", ",", "0", ",", "indx", "++", ")", ")", "=", "1", ";", "off", "-=", "UNITS_PER_WORD", ";", "save_blink", "=", "false", ";", "}", "for", "(", "regno", "=", "start_reg", ";", "regno", "<=", "end_reg", ";", "regno", "++", ",", "indx", "++", ",", "off", "-=", "UNITS_PER_WORD", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "off", ")", ")", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", ")", "=", "1", ";", "gmask", "=", "gmask", "&", "~", "(", "1L", "<<", "regno", ")", ";", "}", "if", "(", "save_fp", ")", "{", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "off", ")", ")", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", "=", "gen_rtx_SET", "(", "mem", ",", "hard_frame_pointer_rtx", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "insn", ",", "0", ",", "indx", "++", ")", ")", "=", "1", ";", "off", "-=", "UNITS_PER_WORD", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", "=", "gen_rtx_SET", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "insn", ",", "0", ",", "indx", "++", ")", ")", "=", "1", ";", "save_fp", "=", "false", ";", "}", "gcc_assert", "(", "off", "==", "0", ")", ";", "insn", "=", "frame_insn", "(", "insn", ")", ";", "add_reg_note", "(", "insn", ",", "REG_INC", ",", "stack_pointer_rtx", ")", ";", "frame_allocated", "=", "nregs", "*", "UNITS_PER_WORD", ";", "return", "frame_allocated", "-", "offset", ";", "}", "</s>"], "natrual_language": ["ARC", "prologue", ",", "save", "the", "registers", "using", "enter", "instruction", ".", "Leave", "instruction", "can", "also", "save", "$", "blink", "(", "SAVE_BLINK", ")", "and", "$", "fp", "(", "SAVE_FP", ")", "register", "."], "TS_V_token": ["arc", "0", "1L", "1", "1", "1", "0", "1", "0", "1", "0", "1", "0", "1", "0", "0", "0", "1", "0", "0", "1", "1L", "0", "0", "1", "0", "0", "1", "0"], "File": "arc8", "Func": "arc_save_callee_enter", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33626, "Length": 467}
{"ground_truth": ["<s>", "static", "int", "arc_save_callee_milli", "(", "unsigned", "int", "gmask", ",", "bool", "save_blink", ",", "bool", "save_fp", ",", "HOST_WIDE_INT", "offset", ",", "HOST_WIDE_INT", "reg_size", ")", "{", "int", "start_reg", "=", "13", ";", "int", "end_reg", "=", "25", ";", "int", "regno", ",", "indx", ",", "off", ",", "nregs", ";", "rtx", "insn", ",", "reg", ",", "mem", ";", "int", "frame_allocated", "=", "0", ";", "for", "(", "regno", "=", "start_reg", ";", "regno", "<=", "end_reg", "&&", "(", "gmask", "&", "(", "1L", "<<", "regno", ")", ")", ";", ")", "regno", "++", ";", "end_reg", "=", "regno", "-", "1", ";", "nregs", "=", "end_reg", "-", "start_reg", "+", "1", ";", "gcc_assert", "(", "end_reg", ">", "14", ")", ";", "if", "(", "save_blink", ")", "{", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ";", "frame_allocated", "+=", "frame_save_reg", "(", "reg", ",", "offset", ")", ";", "offset", "=", "0", ";", "}", "if", "(", "reg_size", "||", "offset", ")", "{", "frame_stack_add", "(", "offset", "-", "reg_size", ")", ";", "frame_allocated", "+=", "nregs", "*", "UNITS_PER_WORD", "-", "offset", ";", "offset", "=", "0", ";", "}", "insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "nregs", "+", "1", ")", ")", ";", "indx", "=", "0", ";", "XVECEXP", "(", "insn", ",", "0", ",", "nregs", ")", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ")", ";", "for", "(", "regno", "=", "start_reg", ",", "indx", "=", "0", ",", "off", "=", "0", ";", "regno", "<=", "end_reg", ";", "regno", "++", ",", "indx", "++", ",", "off", "+=", "UNITS_PER_WORD", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "off", ")", ")", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", ")", "=", "1", ";", "gmask", "=", "gmask", "&", "~", "(", "1L", "<<", "regno", ")", ";", "}", "insn", "=", "frame_insn", "(", "insn", ")", ";", "for", "(", "regno", "=", "start_reg", ",", "off", "=", "0", ";", "regno", "<=", "end_reg", ";", "regno", "++", ",", "off", "+=", "UNITS_PER_WORD", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "off", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_OFFSET", ",", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ")", ";", "}", "if", "(", "arc_must_save_return_addr", "(", "cfun", ")", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ",", "gen_rtx_MEM", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "reg_size", ")", ")", ")", ")", ";", "}", "for", "(", "regno", "=", "0", ";", "regno", "<=", "31", ";", "regno", "++", ")", "{", "if", "(", "(", "gmask", "&", "(", "1L", "<<", "regno", ")", ")", "==", "0", ")", "continue", ";", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "off", ")", ")", ";", "frame_move_inc", "(", "mem", ",", "reg", ",", "stack_pointer_rtx", ",", "0", ")", ";", "frame_allocated", "+=", "UNITS_PER_WORD", ";", "off", "+=", "UNITS_PER_WORD", ";", "}", "if", "(", "save_fp", ")", "frame_allocated", "+=", "frame_save_reg", "(", "hard_frame_pointer_rtx", ",", "offset", ")", ";", "if", "(", "arc_frame_pointer_needed", "(", ")", ")", "frame_move", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ";", "return", "frame_allocated", ";", "}", "</s>"], "natrual_language": ["Millicode", "thunks", "implementation", ":", "Generates", "calls", "to", "millicodes", "for", "registers", "starting", "from", "r13", "to", "r25", "Present", "Limitations", ":", "-", "Only", "one", "range", "supported", ".", "The", "remaining", "regs", "will", "have", "the", "ordinary", "st", "and", "ld", "instructions", "for", "store", "and", "loads", ".", "Hence", "a", "gmask", "asking", "to", "store", "r13-14", ",", "r16-r25", "will", "only", "generate", "calls", "to", "store", "and", "load", "r13", "to", "r14", "while", "store", "and", "load", "insns", "will", "be", "generated", "for", "r16", "to", "r25", "in", "the", "prologue", "and", "epilogue", "respectively", ".", "-", "Presently", "library", "only", "supports", "register", "ranges", "starting", "from", "r13", "."], "TS_V_token": ["arc", "13", "25", "0", "1L", "1", "1", "14", "0", "0", "1", "0", "0", "0", "0", "0", "0", "1", "1L", "0", "0", "31", "1L", "0", "0"], "File": "arc8", "Func": "arc_save_callee_milli", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33627, "Length": 497}
{"ground_truth": ["<s>", "static", "int", "arc_save_callee_saves", "(", "unsigned", "int", "gmask", ",", "bool", "save_blink", ",", "bool", "save_fp", ",", "HOST_WIDE_INT", "offset", ")", "{", "rtx", "reg", ";", "int", "frame_allocated", "=", "0", ";", "if", "(", "save_blink", ")", "{", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ";", "frame_allocated", "+=", "frame_save_reg", "(", "reg", ",", "offset", ")", ";", "offset", "=", "0", ";", "}", "if", "(", "gmask", ")", "for", "(", "int", "i", "=", "31", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "machine_mode", "save_mode", "=", "SImode", ";", "if", "(", "TARGET_LL64", "&&", "(", "(", "i", "-", "1", ")", "%", "2", "==", "0", ")", "&&", "(", "(", "gmask", "&", "(", "1L", "<<", "i", ")", ")", "!=", "0", ")", "&&", "(", "(", "gmask", "&", "(", "1L", "<<", "(", "i", "-", "1", ")", ")", ")", "!=", "0", ")", ")", "{", "save_mode", "=", "DImode", ";", "--", "i", ";", "}", "else", "if", "(", "(", "gmask", "&", "(", "1L", "<<", "i", ")", ")", "==", "0", ")", "continue", ";", "reg", "=", "gen_rtx_REG", "(", "save_mode", ",", "i", ")", ";", "frame_allocated", "+=", "frame_save_reg", "(", "reg", ",", "offset", ")", ";", "offset", "=", "0", ";", "}", "if", "(", "save_fp", ")", "{", "frame_allocated", "+=", "frame_save_reg", "(", "hard_frame_pointer_rtx", ",", "offset", ")", ";", "offset", "=", "0", ";", "}", "if", "(", "arc_frame_pointer_needed", "(", ")", ")", "frame_move", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ";", "return", "frame_allocated", ";", "}", "</s>"], "natrual_language": ["ARC", "'s", "prologue", ",", "save", "any", "needed", "call-saved", "regs", "(", "and", "call-used", "if", "this", "is", "an", "interrupt", "handler", ")", "for", "ARCompact", "ISA", ",", "using", "ST/STD", "instructions", "."], "TS_V_token": ["arc", "0", "0", "31", "0", "1", "2", "0", "1L", "0", "1L", "1", "0", "1L", "0", "0", "0"], "File": "arc8", "Func": "arc_save_callee_saves", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33628, "Length": 211}
{"ground_truth": ["<s>", "bool", "compact_sda_memory_operand", "(", "rtx", "op", ",", "machine_mode", "mode", ",", "bool", "short_p", ")", "{", "rtx", "addr", ";", "int", "size", ";", "int", "align", "=", "0", ";", "int", "mask", "=", "0", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "false", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "GET_MODE", "(", "op", ")", ";", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "size", ">", "UNITS_PER_WORD", ")", "return", "false", ";", "addr", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "!", "legitimate_small_data_address_p", "(", "addr", ")", ")", "return", "false", ";", "if", "(", "!", "short_p", "||", "size", "==", "1", ")", "return", "true", ";", "align", "=", "get_symbol_alignment", "(", "addr", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_HImode", ":", "mask", "=", "1", ";", "break", ";", "default", ":", "mask", "=", "3", ";", "break", ";", "}", "if", "(", "align", "&&", "(", "(", "align", "&", "mask", ")", "==", "0", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["volatile", "cache", "option", "still", "to", "be", "handled", "."], "TS_V_token": ["arc", "0", "0", "0", "1", "1", "3", "0"], "File": "arc8", "Func": "compact_sda_memory_operand", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33629, "Length": 153}
{"ground_truth": ["<s>", "static", "bool", "legitimate_scaled_address_p", "(", "machine_mode", "mode", ",", "rtx", "op", ",", "bool", "strict", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "!=", "PLUS", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "!=", "MULT", ")", "return", "false", ";", "if", "(", "!", "RTX_OK_FOR_INDEX_P", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "0", ")", ",", "strict", ")", ")", "return", "false", ";", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ")", ")", "return", "false", ";", "switch", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", "{", "case", "2", ":", "if", "(", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ")", "!=", "2", ")", "return", "false", ";", "break", ";", "case", "8", ":", "if", "(", "!", "TARGET_LL64", ")", "return", "false", ";", "case", "4", ":", "if", "(", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ")", "!=", "4", ")", "return", "false", ";", "default", ":", "return", "false", ";", "}", "if", "(", "RTX_OK_FOR_BASE_P", "(", "XEXP", "(", "op", ",", "1", ")", ",", "(", "strict", ")", ")", ")", "return", "true", ";", "if", "(", "flag_pic", ")", "{", "if", "(", "CONST_INT_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "if", "(", "legitimate_small_data_address_p", "(", "op", ")", ")", "return", "false", ";", "if", "(", "CONSTANT_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["TRUE", "if", "op", "is", "an", "scaled", "address", "."], "TS_V_token": ["arc", "0", "0", "0", "0", "1", "2", "0", "1", "2", "8", "4", "0", "1", "4", "1", "1", "1"], "File": "arc8", "Func": "legitimate_scaled_address_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33630, "Length": 236}
{"ground_truth": ["<s>", "static", "bool", "legitimate_small_data_address_p", "(", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST", ":", "return", "legitimate_small_data_address_p", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "case", "SYMBOL_REF", ":", "return", "SYMBOL_REF_SMALL_P", "(", "x", ")", ";", "case", "PLUS", ":", "{", "bool", "p0", "=", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", "&&", "SYMBOL_REF_SMALL_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "bool", "p1", "=", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "<=", "g_switch_value", ")", ";", "return", "p0", "&&", "p1", ";", "}", "default", ":", "return", "false", ";", "}", "}", "</s>"], "natrual_language": ["Return", "true", "if", "x", "is", "ok", "to", "be", "used", "as", "a", "small", "data", "address", "."], "TS_V_token": ["arc", "0", "0", "0", "1", "1"], "File": "arc8", "Func": "legitimate_small_data_address_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33631, "Length": 110}
{"ground_truth": ["<s>", "static", "rtx_insn", "*", "apply_GEN_FCN", "(", "enum", "insn_code", "icode", ",", "rtx", "*", "arg", ")", "{", "switch", "(", "insn_data", "[", "icode", "]", ".", "n_generator_args", ")", "{", "case", "0", ":", "return", "GEN_FCN", "(", "icode", ")", "(", ")", ";", "case", "1", ":", "return", "GEN_FCN", "(", "icode", ")", "(", "arg", "[", "0", "]", ")", ";", "case", "2", ":", "return", "GEN_FCN", "(", "icode", ")", "(", "arg", "[", "0", "]", ",", "arg", "[", "1", "]", ")", ";", "case", "3", ":", "return", "GEN_FCN", "(", "icode", ")", "(", "arg", "[", "0", "]", ",", "arg", "[", "1", "]", ",", "arg", "[", "2", "]", ")", ";", "case", "4", ":", "return", "GEN_FCN", "(", "icode", ")", "(", "arg", "[", "0", "]", ",", "arg", "[", "1", "]", ",", "arg", "[", "2", "]", ",", "arg", "[", "3", "]", ")", ";", "case", "5", ":", "return", "GEN_FCN", "(", "icode", ")", "(", "arg", "[", "0", "]", ",", "arg", "[", "1", "]", ",", "arg", "[", "2", "]", ",", "arg", "[", "3", "]", ",", "arg", "[", "4", "]", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Helper", "arc_expand_builtin", ",", "generates", "a", "pattern", "for", "the", "given", "icode", "and", "arguments", "."], "TS_V_token": ["arc", "0", "1", "0", "2", "0", "1", "3", "0", "1", "2", "4", "0", "1", "2", "3", "5", "0", "1", "2", "3", "4"], "File": "arc", "Func": "apply_GEN_FCN", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33632, "Length": 168}
{"ground_truth": ["<s>", "static", "int", "arc600_corereg_hazard", "(", "rtx_insn", "*", "pred", ",", "rtx_insn", "*", "succ", ")", "{", "if", "(", "!", "TARGET_ARC600", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "pred", ")", ")", "==", "SEQUENCE", ")", "pred", "=", "as_a", "<", "rtx_sequence", "*", ">", "(", "PATTERN", "(", "pred", ")", ")", "->", "insn", "(", "1", ")", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "succ", ")", ")", "==", "SEQUENCE", ")", "succ", "=", "as_a", "<", "rtx_sequence", "*", ">", "(", "PATTERN", "(", "succ", ")", ")", "->", "insn", "(", "0", ")", ";", "if", "(", "recog_memoized", "(", "pred", ")", "==", "CODE_FOR_mulsi_600", "||", "recog_memoized", "(", "pred", ")", "==", "CODE_FOR_umul_600", "||", "recog_memoized", "(", "pred", ")", "==", "CODE_FOR_mac_600", "||", "recog_memoized", "(", "pred", ")", "==", "CODE_FOR_mul64_600", "||", "recog_memoized", "(", "pred", ")", "==", "CODE_FOR_mac64_600", "||", "recog_memoized", "(", "pred", ")", "==", "CODE_FOR_umul64_600", "||", "recog_memoized", "(", "pred", ")", "==", "CODE_FOR_umac64_600", ")", "return", "0", ";", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "PATTERN", "(", "pred", ")", ",", "NONCONST", ")", "{", "const_rtx", "x", "=", "*", "iter", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "SET", ":", "case", "POST_INC", ":", "case", "POST_DEC", ":", "case", "PRE_INC", ":", "case", "PRE_DEC", ":", "break", ";", "default", ":", "continue", ";", "}", "rtx", "dest", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "REG_P", "(", "dest", ")", "&&", "REGNO", "(", "dest", ")", ">=", "32", "&&", "REGNO", "(", "dest", ")", "<", "61", "&&", "(", "refers_to_regno_p", "(", "REGNO", "(", "dest", ")", ",", "REGNO", "(", "dest", ")", "+", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "dest", ")", ")", "+", "3", ")", "/", "4U", ",", "PATTERN", "(", "succ", ")", ",", "0", ")", ")", ")", "return", "4", ";", "}", "return", "0", ";", "}", "</s>"], "natrual_language": ["Return", "length", "adjustment", "for", "INSN", ".", "For", "ARC600", ":", "A", "write", "to", "a", "core", "reg", "greater", "or", "equal", "to", "32", "must", "not", "be", "immediately", "followed", "by", "a", "use", ".", "Anticipate", "the", "length", "requirement", "to", "insert", "a", "nop", "between", "PRED", "and", "SUCC", "to", "prevent", "a", "hazard", "."], "TS_V_token": ["arc", "0", "1", "0", "0", "0", "32", "61", "3", "4U", "0", "4", "0"], "File": "arc", "Func": "arc600_corereg_hazard", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33633, "Length": 267}
{"ground_truth": ["<s>", "static", "rtx_insn", "*", "arc_active_insn", "(", "rtx_insn", "*", "insn", ")", "{", "while", "(", "insn", ")", "{", "insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "if", "(", "insn", "==", "0", "||", "(", "active_insn_p", "(", "insn", ")", "&&", "NONDEBUG_INSN_P", "(", "insn", ")", "&&", "!", "NOTE_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "UNSPEC_VOLATILE", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "PARALLEL", ")", ")", "break", ";", "}", "return", "insn", ";", "}", "</s>"], "natrual_language": ["Return", "the", "next", "active", "insn", ",", "skiping", "the", "inline", "assembly", "code", "."], "TS_V_token": ["arc", "0"], "File": "arc", "Func": "arc_active_insn", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33634, "Length": 73}
{"ground_truth": ["<s>", "static", "int", "arc_address_cost", "(", "rtx", "addr", ",", "machine_mode", ",", "addr_space_t", ",", "bool", "speed", ")", "{", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "return", "speed", "||", "satisfies_constraint_Rcq", "(", "addr", ")", "?", "0", ":", "1", ";", "case", "PRE_INC", ":", "case", "PRE_DEC", ":", "case", "POST_INC", ":", "case", "POST_DEC", ":", "case", "PRE_MODIFY", ":", "case", "POST_MODIFY", ":", "return", "!", "speed", ";", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "case", "CONST", ":", "if", "(", "TARGET_NPS_CMEM", "&&", "cmem_address", "(", "addr", ",", "SImode", ")", ")", "return", "0", ";", "return", "COSTS_N_INSNS", "(", "1", ")", ";", "case", "PLUS", ":", "{", "rtx", "plus0", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "rtx", "plus1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "plus0", ")", "!=", "REG", "&&", "(", "GET_CODE", "(", "plus0", ")", "!=", "MULT", "||", "!", "CONST_INT_P", "(", "XEXP", "(", "plus0", ",", "1", ")", ")", "||", "(", "INTVAL", "(", "XEXP", "(", "plus0", ",", "1", ")", ")", "!=", "2", "&&", "INTVAL", "(", "XEXP", "(", "plus0", ",", "1", ")", ")", "!=", "4", ")", ")", ")", "break", ";", "switch", "(", "GET_CODE", "(", "plus1", ")", ")", "{", "case", "CONST_INT", ":", "return", "(", "!", "RTX_OK_FOR_OFFSET_P", "(", "SImode", ",", "plus1", ")", "?", "COSTS_N_INSNS", "(", "1", ")", ":", "speed", "?", "0", ":", "(", "satisfies_constraint_Rcq", "(", "plus0", ")", "&&", "satisfies_constraint_O", "(", "plus1", ")", ")", "?", "0", ":", "1", ")", ";", "case", "REG", ":", "return", "(", "speed", "<", "1", "?", "0", ":", "(", "satisfies_constraint_Rcq", "(", "plus0", ")", "&&", "satisfies_constraint_Rcq", "(", "plus1", ")", ")", "?", "0", ":", "1", ")", ";", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "return", "COSTS_N_INSNS", "(", "1", ")", ";", "default", ":", "break", ";", "}", "break", ";", "}", "default", ":", "break", ";", "}", "return", "4", ";", "}", "</s>"], "natrual_language": ["Provide", "the", "costs", "of", "an", "addressing", "mode", "that", "contains", "ADDR", ".", "If", "ADDR", "is", "not", "a", "valid", "address", ",", "its", "cost", "is", "irrelevant", "."], "TS_V_token": ["arc", "0", "1", "0", "1", "0", "1", "1", "1", "2", "1", "4", "1", "0", "0", "1", "1", "0", "0", "1", "1", "4"], "File": "arc", "Func": "arc_address_cost", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33635, "Length": 277}
{"ground_truth": ["<s>", "static", "void", "arc_add_jli_section", "(", "rtx", "pat", ")", "{", "const", "char", "*", "name", ";", "tree", "attrs", ";", "arc_jli_section", "*", "sec", "=", "arc_jli_sections", ",", "*", "new_section", ";", "tree", "decl", "=", "SYMBOL_REF_DECL", "(", "pat", ")", ";", "if", "(", "!", "pat", ")", "return", ";", "if", "(", "decl", ")", "{", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "if", "(", "lookup_attribute", "(", "\"jli_fixed\"", ",", "attrs", ")", ")", "return", ";", "}", "name", "=", "XSTR", "(", "pat", ",", "0", ")", ";", "while", "(", "sec", "!=", "NULL", ")", "{", "if", "(", "strcmp", "(", "name", ",", "sec", "->", "name", ")", "==", "0", ")", "return", ";", "sec", "=", "sec", "->", "next", ";", "}", "new_section", "=", "(", "arc_jli_section", "*", ")", "xmalloc", "(", "sizeof", "(", "arc_jli_section", ")", ")", ";", "gcc_assert", "(", "new_section", "!=", "NULL", ")", ";", "new_section", "->", "name", "=", "name", ";", "new_section", "->", "next", "=", "arc_jli_sections", ";", "arc_jli_sections", "=", "new_section", ";", "}", "</s>"], "natrual_language": ["Add", "the", "given", "function", "declaration", "to", "emit", "code", "in", "JLI", "section", "."], "TS_V_token": ["arc", "\"jli_fixed\"", "0", "0"], "File": "arc", "Func": "arc_add_jli_section", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33636, "Length": 143}
{"ground_truth": ["<s>", "int", "arc_adjust_insn_length", "(", "rtx_insn", "*", "insn", ",", "int", "len", ",", "bool", ")", "{", "if", "(", "!", "INSN_P", "(", "insn", ")", ")", "return", "len", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SEQUENCE", ")", "return", "len", ";", "if", "(", "TARGET_PAD_RETURN", "&&", "JUMP_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ADDR_VEC", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ADDR_DIFF_VEC", "&&", "get_attr_type", "(", "insn", ")", "==", "TYPE_RETURN", ")", "{", "rtx_insn", "*", "prev", "=", "prev_active_insn", "(", "insn", ")", ";", "if", "(", "!", "prev", "||", "!", "(", "prev", "=", "prev_active_insn", "(", "prev", ")", ")", "||", "(", "(", "NONJUMP_INSN_P", "(", "prev", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "prev", ")", ")", "==", "SEQUENCE", ")", "?", "CALL_ATTR", "(", "as_a", "<", "rtx_sequence", "*", ">", "(", "PATTERN", "(", "prev", ")", ")", "->", "insn", "(", "0", ")", ",", "NON_SIBCALL", ")", ":", "CALL_ATTR", "(", "prev", ",", "NON_SIBCALL", ")", ")", ")", "return", "len", "+", "4", ";", "}", "if", "(", "TARGET_ARC600", ")", "{", "rtx_insn", "*", "succ", "=", "next_real_insn", "(", "insn", ")", ";", "if", "(", "succ", "&&", "INSN_P", "(", "succ", ")", ")", "len", "+=", "arc600_corereg_hazard", "(", "insn", ",", "succ", ")", ";", "}", "extract_constrain_insn_cached", "(", "insn", ")", ";", "return", "len", ";", "}", "</s>"], "natrual_language": ["Return", "length", "adjustment", "for", "INSN", "."], "TS_V_token": ["arc", "0", "4"], "File": "arc", "Func": "arc_adjust_insn_length", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33637, "Length": 196}
{"ground_truth": ["<s>", "void", "arc_adjust_reg_alloc_order", "(", "void", ")", "{", "const", "int", "arc_default_alloc_order", "[", "]", "=", "REG_ALLOC_ORDER", ";", "memcpy", "(", "reg_alloc_order", ",", "arc_default_alloc_order", ",", "sizeof", "(", "reg_alloc_order", ")", ")", ";", "if", "(", "optimize_size", ")", "memcpy", "(", "reg_alloc_order", ",", "size_alloc_order", ",", "sizeof", "(", "size_alloc_order", ")", ")", ";", "}", "</s>"], "natrual_language": ["Adjust", "register", "allocation", "order", "when", "compiling", "for", "size", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_adjust_reg_alloc_order", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33638, "Length": 43}
{"ground_truth": ["<s>", "static", "bool", "arc_allocate_stack_slots_for_args", "(", "void", ")", "{", "unsigned", "int", "fn_type", "=", "arc_compute_function_type", "(", "cfun", ")", ";", "return", "!", "ARC_NAKED_P", "(", "fn_type", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_ALLOCATE_STACK_SLOTS_FOR_ARGS", "'"], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_allocate_stack_slots_for_args", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33639, "Length": 24}
{"ground_truth": ["<s>", "static", "int", "arc_arg_partial_bytes", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "bytes", "=", "arg", ".", "promoted_size_in_bytes", "(", ")", ";", "int", "words", "=", "(", "bytes", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "int", "arg_num", "=", "*", "cum", ";", "int", "ret", ";", "arg_num", "=", "ROUND_ADVANCE_CUM", "(", "arg_num", ",", "arg", ".", "mode", ",", "arg", ".", "type", ")", ";", "ret", "=", "GPR_REST_ARG_REGS", "(", "arg_num", ")", ";", "ret", "=", "(", "ret", ">=", "words", "?", "0", ":", "ret", "*", "UNITS_PER_WORD", ")", ";", "return", "ret", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_ARG_PARTIAL_BYTES", "."], "TS_V_token": ["arc", "1", "0"], "File": "arc", "Func": "arc_arg_partial_bytes", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33640, "Length": 93}
{"ground_truth": ["<s>", "static", "int", "arc_asm_insn_p", "(", "rtx", "x", ")", "{", "int", "i", ",", "j", ";", "if", "(", "x", "==", "0", ")", "return", "0", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "ASM_OPERANDS", ":", "case", "ASM_INPUT", ":", "return", "1", ";", "case", "SET", ":", "return", "arc_asm_insn_p", "(", "SET_SRC", "(", "x", ")", ")", ";", "case", "PARALLEL", ":", "j", "=", "0", ";", "for", "(", "i", "=", "XVECLEN", "(", "x", ",", "0", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "j", "+=", "arc_asm_insn_p", "(", "XVECEXP", "(", "x", ",", "0", ",", "i", ")", ")", ";", "if", "(", "j", ">", "0", ")", "return", "1", ";", "break", ";", "default", ":", "break", ";", "}", "return", "0", ";", "}", "</s>"], "natrual_language": ["Given", "a", "rtx", ",", "check", "if", "it", "is", "an", "assembly", "instruction", "or", "not", "."], "TS_V_token": ["arc", "0", "0", "1", "0", "0", "1", "0", "0", "0", "1", "0"], "File": "arc", "Func": "arc_asm_insn_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33641, "Length": 112}
{"ground_truth": ["<s>", "void", "arc_asm_output_aligned_decl_local", "(", "FILE", "*", "stream", ",", "tree", "decl", ",", "const", "char", "*", "name", ",", "unsigned", "HOST_WIDE_INT", "size", ",", "unsigned", "HOST_WIDE_INT", "align", ",", "unsigned", "HOST_WIDE_INT", "globalize_p", ")", "{", "int", "in_small_data", "=", "arc_in_small_data_p", "(", "decl", ")", ";", "rtx", "mem", "=", "decl", "==", "NULL_TREE", "?", "NULL_RTX", ":", "DECL_RTL", "(", "decl", ")", ";", "if", "(", "mem", "!=", "NULL_RTX", "&&", "MEM_P", "(", "mem", ")", "&&", "SYMBOL_REF_P", "(", "XEXP", "(", "mem", ",", "0", ")", ")", "&&", "arc_is_aux_reg_p", "(", "mem", ")", ")", "return", ";", "if", "(", "in_small_data", ")", "switch_to_section", "(", "get_named_section", "(", "NULL", ",", "\".sbss\"", ",", "0", ")", ")", ";", "else", "switch_to_section", "(", "bss_section", ")", ";", "if", "(", "globalize_p", ")", "(", "*", "targetm", ".", "asm_out", ".", "globalize_label", ")", "(", "stream", ",", "name", ")", ";", "ASM_OUTPUT_ALIGN", "(", "stream", ",", "floor_log2", "(", "(", "align", ")", "/", "BITS_PER_UNIT", ")", ")", ";", "ASM_OUTPUT_TYPE_DIRECTIVE", "(", "stream", ",", "name", ",", "\"object\"", ")", ";", "ASM_OUTPUT_SIZE_DIRECTIVE", "(", "stream", ",", "name", ",", "size", ")", ";", "ASM_OUTPUT_LABEL", "(", "stream", ",", "name", ")", ";", "if", "(", "size", "!=", "0", ")", "ASM_OUTPUT_SKIP", "(", "stream", ",", "size", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "ASM_OUTPUT_ALIGNED_DECL_LOCAL", "."], "TS_V_token": ["arc", "0", "\".sbss\"", "0", "\"object\"", "0"], "File": "arc", "Func": "arc_asm_output_aligned_decl_local", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33642, "Length": 171}
{"ground_truth": ["<s>", "static", "void", "arc_asm_trampoline_template", "(", "FILE", "*", "f", ")", "{", "asm_fprintf", "(", "f", ",", "\"\\tld_s\\t%s,[pcl,8]\\n\"", ",", "ARC_TEMP_SCRATCH_REG", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\tld\\t%s,[pcl,12]\\n\"", ",", "reg_names", "[", "STATIC_CHAIN_REGNUM", "]", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\tj_s\\t[%s]\\n\"", ",", "ARC_TEMP_SCRATCH_REG", ")", ";", "assemble_aligned_integer", "(", "UNITS_PER_WORD", ",", "const0_rtx", ")", ";", "assemble_aligned_integer", "(", "UNITS_PER_WORD", ",", "const0_rtx", ")", ";", "}", "</s>"], "natrual_language": ["Output", "assembler", "code", "for", "a", "block", "containing", "the", "constant", "parts", "of", "a", "trampoline", ",", "leaving", "space", "for", "variable", "parts", ".", "A", "trampoline", "looks", "like", "this", ":", "ld_s", "r12", ",", "[", "pcl,8", "]", "ld", "r11", ",", "[", "pcl,12", "]", "j_s", "[", "r12", "]", ".word", "function", "'s", "address", ".word", "static", "chain", "value"], "TS_V_token": ["arc", "\"\\tld_s\\t%s,[pcl,8]\\n\"", "\"\\tld\\t%s,[pcl,12]\\n\"", "\"\\tj_s\\t[%s]\\n\""], "File": "arc", "Func": "arc_asm_trampoline_template", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33643, "Length": 54}
{"ground_truth": ["<s>", "static", "int", "arc_attr_type", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "NONJUMP_INSN_P", "(", "insn", ")", "?", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", ")", ":", "JUMP_P", "(", "insn", ")", "?", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "ADDR_VEC", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "ADDR_DIFF_VEC", ")", ":", "!", "CALL_P", "(", "insn", ")", ")", "return", "-", "1", ";", "return", "get_attr_type", "(", "insn", ")", ";", "}", "</s>"], "natrual_language": ["Return", "the", "integer", "value", "of", "the", "``", "type", "''", "attribute", "for", "INSN", ",", "or", "-1", "if", "INSN", "ca", "n't", "have", "attributes", "."], "TS_V_token": ["arc", "1"], "File": "arc", "Func": "arc_attr_type", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33644, "Length": 82}
{"ground_truth": ["<s>", "static", "unsigned", "int", "arc_autovectorize_vector_modes", "(", "vector_modes", "*", "modes", ",", "bool", ")", "{", "if", "(", "TARGET_PLUS_QMACW", ")", "{", "modes", "->", "quick_push", "(", "V4HImode", ")", ";", "modes", "->", "quick_push", "(", "V2HImode", ")", ";", "}", "return", "0", ";", "}", "</s>"], "natrual_language": ["Implements", "target", "hook", "TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES", "."], "TS_V_token": ["arc", "0"], "File": "arc", "Func": "arc_autovectorize_vector_modes", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33645, "Length": 36}
{"ground_truth": ["<s>", "bool", "arc_branch_size_unknown_p", "(", "void", ")", "{", "return", "!", "optimize_size", "&&", "arc_reorg_in_progress", ";", "}", "</s>"], "natrual_language": ["When", "estimating", "sizes", "during", "arc_reorg", ",", "when", "optimizing", "for", "speed", ",", "there", "are", "three", "reasons", "why", "we", "need", "to", "consider", "branches", "to", "be", "length", "6", ":", "-", "annull-false", "delay", "slot", "insns", "are", "implemented", "using", "conditional", "execution", ",", "thus", "preventing", "short", "insn", "formation", "where", "used", ".", "-", "for", "ARC600", ":", "annul-true", "delay", "slot", "insns", "are", "implemented", "where", "possible", "using", "conditional", "execution", ",", "preventing", "short", "insn", "formation", "where", "used", ".", "-", "for", "ARC700", ":", "likely", "or", "somewhat", "likely", "taken", "branches", "are", "made", "long", "and", "unaligned", "if", "possible", "to", "avoid", "branch", "penalty", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_branch_size_unknown_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33646, "Length": 13}
{"ground_truth": ["<s>", "static", "tree", "arc_builtin_decl", "(", "unsigned", "id", ",", "bool", "initialize_p", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "id", "<", "ARC_BUILTIN_COUNT", ")", "return", "arc_bdesc", "[", "id", "]", ".", "fndecl", ";", "return", "error_mark_node", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_BUILTIN_DECL", "'", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_builtin_decl", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33647, "Length": 30}
{"ground_truth": ["<s>", "static", "rtx", "arc_call_tls_get_addr", "(", "rtx", "ti", ")", "{", "rtx", "arg", "=", "gen_rtx_REG", "(", "Pmode", ",", "R0_REG", ")", ";", "rtx", "ret", "=", "gen_rtx_REG", "(", "Pmode", ",", "R0_REG", ")", ";", "rtx", "fn", ";", "rtx_insn", "*", "insn", ";", "if", "(", "!", "arc_tls_symbol", ")", "arc_tls_symbol", "=", "init_one_libfunc", "(", "\"__tls_get_addr\"", ")", ";", "emit_move_insn", "(", "arg", ",", "ti", ")", ";", "fn", "=", "gen_rtx_MEM", "(", "SImode", ",", "arc_tls_symbol", ")", ";", "insn", "=", "emit_call_insn", "(", "gen_call_value", "(", "ret", ",", "fn", ",", "const0_rtx", ")", ")", ";", "RTL_CONST_CALL_P", "(", "insn", ")", "=", "1", ";", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ",", "ret", ")", ";", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ",", "arg", ")", ";", "return", "ret", ";", "}", "</s>"], "natrual_language": ["Emit", "a", "call", "to", "__tls_get_addr", ".", "TI", "is", "the", "argument", "to", "this", "function", ".", "RET", "is", "an", "RTX", "for", "the", "return", "value", "location", ".", "The", "entire", "insn", "sequence", "is", "returned", "."], "TS_V_token": ["arc", "\"__tls_get_addr\"", "1"], "File": "arc", "Func": "arc_call_tls_get_addr", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33648, "Length": 110}
{"ground_truth": ["<s>", "static", "bool", "arc_cannot_force_const_mem", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "return", "!", "arc_legitimate_constant_p", "(", "mode", ",", "x", ")", ";", "}", "</s>"], "natrual_language": ["Determine", "if", "it", "'s", "legal", "to", "put", "X", "into", "the", "constant", "pool", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_cannot_force_const_mem", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33649, "Length": 21}
{"ground_truth": ["<s>", "static", "bool", "arc_cannot_substitute_mem_equiv_p", "(", "rtx", ")", "{", "return", "true", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "SUBST", "ca", "n't", "safely", "replace", "its", "equivalent", "during", "RA", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_cannot_substitute_mem_equiv_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33650, "Length": 11}
{"ground_truth": ["<s>", "static", "bool", "arc_can_eliminate", "(", "const", "int", "from", "ATTRIBUTE_UNUSED", ",", "const", "int", "to", ")", "{", "return", "(", "(", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", "||", "(", "to", "==", "STACK_POINTER_REGNUM", ")", ")", ";", "}", "</s>"], "natrual_language": ["Given", "FROM", "and", "TO", "register", "numbers", ",", "say", "whether", "this", "elimination", "is", "allowed", ".", "Frame", "pointer", "elimination", "is", "automatically", "handled", ".", "All", "eliminations", "are", "permissible", ".", "If", "we", "need", "a", "frame", "pointer", ",", "we", "must", "eliminate", "ARG_POINTER_REGNUM", "into", "FRAME_POINTER_REGNUM", "and", "not", "into", "STACK_POINTER_REGNUM", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_can_eliminate", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33651, "Length": 30}
{"ground_truth": ["<s>", "static", "bool", "arc_can_follow_jump", "(", "const", "rtx_insn", "*", "follower", ",", "const", "rtx_insn", "*", "followee", ")", "{", "union", "{", "const", "rtx_insn", "*", "c", ";", "rtx_insn", "*", "r", ";", "}", "u", ";", "u", ".", "c", "=", "follower", ";", "if", "(", "CROSSING_JUMP_P", "(", "followee", ")", ")", "switch", "(", "get_attr_type", "(", "u", ".", "r", ")", ")", "{", "case", "TYPE_BRANCH", ":", "if", "(", "get_attr_length", "(", "u", ".", "r", ")", "!=", "2", ")", "break", ";", "case", "TYPE_BRCC", ":", "case", "TYPE_BRCC_NO_DELAY_SLOT", ":", "return", "false", ";", "default", ":", "return", "true", ";", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["Without", "this", ",", "gcc.dg/tree-prof/bb-reorg.c", "fails", "to", "assemble", "when", "compiling", "with", "-O2", "-freorder-blocks-and-partition", "-fprofile-use", "-D_PROFILE_USE", ";", "delay", "branch", "scheduling", "then", "follows", "a", "crossing", "jump", "to", "redirect", "two", "breqs", "."], "TS_V_token": ["arc", "2"], "File": "arc", "Func": "arc_can_follow_jump", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33652, "Length": 87}
{"ground_truth": ["<s>", "static", "bool", "arc_can_use_doloop_p", "(", "const", "widest_int", "&", ",", "const", "widest_int", "&", "iterations_max", ",", "unsigned", "int", "loop_depth", ",", "bool", "entered_at_top", ")", "{", "if", "(", "loop_depth", ">", "1", "||", "!", "entered_at_top", ")", "return", "false", ";", "if", "(", "arc_lpcwidth", "!=", "32", "&&", "(", "wi", "::", "gtu_p", "(", "iterations_max", ",", "(", "(", "1", "<<", "arc_lpcwidth", ")", "-", "1", ")", ")", "||", "wi", "::", "eq_p", "(", "iterations_max", ",", "0", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_CAN_USE_DOLOOP_P", "."], "TS_V_token": ["arc", "1", "32", "1", "1", "0"], "File": "arc", "Func": "arc_can_use_doloop_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33653, "Length": 74}
{"ground_truth": ["<s>", "bool", "arc_can_use_return_insn", "(", "void", ")", "{", "return", "(", "reload_completed", "&&", "cfun", "->", "machine", "->", "frame_info", ".", "total_size", "==", "0", "&&", "!", "ARC_INTERRUPT_P", "(", "arc_compute_function_type", "(", "cfun", ")", ")", ")", ";", "}", "</s>"], "natrual_language": ["Return", "nonzero", "if", "this", "function", "is", "known", "to", "have", "a", "null", "epilogue", ".", "This", "allows", "the", "optimizer", "to", "omit", "jumps", "to", "jumps", "if", "no", "stack", "was", "created", "."], "TS_V_token": ["arc", "0"], "File": "arc", "Func": "arc_can_use_return_insn", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33654, "Length": 31}
{"ground_truth": ["<s>", "static", "void", "arc_ccfsm_at_label", "(", "const", "char", "*", "prefix", ",", "int", "num", ",", "struct", "arc_ccfsm", "*", "state", ")", "{", "if", "(", "state", "->", "state", "==", "3", "&&", "state", "->", "target_label", "==", "num", "&&", "!", "strcmp", "(", "prefix", ",", "\"L\"", ")", ")", "{", "state", "->", "state", "=", "0", ";", "state", "->", "target_insn", "=", "NULL", ";", "}", "}", "</s>"], "natrual_language": ["Record", "that", "we", "are", "currently", "outputting", "label", "NUM", "with", "prefix", "PREFIX", ".", "It", "it", "'s", "the", "label", "we", "'re", "looking", "for", ",", "reset", "the", "ccfsm", "machinery", ".", "Called", "from", "(", "*", "targetm.asm_out.internal_label", ")", "."], "TS_V_token": ["arc", "3", "\"L\"", "0"], "File": "arc", "Func": "arc_ccfsm_at_label", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33655, "Length": 55}
{"ground_truth": ["<s>", "bool", "arc_ccfsm_branch_deleted_p", "(", "void", ")", "{", "return", "ARC_CCFSM_BRANCH_DELETED_P", "(", "&", "arc_ccfsm_current", ")", ";", "}", "</s>"], "natrual_language": ["See", "if", "the", "current", "insn", ",", "which", "is", "a", "conditional", "branch", ",", "is", "to", "be", "deleted", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_ccfsm_branch_deleted_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33656, "Length": 14}
{"ground_truth": ["<s>", "bool", "arc_ccfsm_cond_exec_p", "(", "void", ")", "{", "return", "(", "cfun", "->", "machine", "->", "prescan_initialized", "&&", "ARC_CCFSM_COND_EXEC_P", "(", "&", "arc_ccfsm_current", ")", ")", ";", "}", "</s>"], "natrual_language": ["During", "insn", "output", ",", "indicate", "if", "the", "current", "insn", "is", "predicated", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_ccfsm_cond_exec_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33657, "Length": 22}
{"ground_truth": ["<s>", "static", "void", "arc_ccfsm_post_advance", "(", "rtx_insn", "*", "insn", ",", "struct", "arc_ccfsm", "*", "state", ")", "{", "enum", "attr_type", "type", ";", "if", "(", "LABEL_P", "(", "insn", ")", ")", "arc_ccfsm_at_label", "(", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "insn", ")", ",", "state", ")", ";", "else", "if", "(", "JUMP_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ADDR_VEC", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ADDR_DIFF_VEC", "&&", "(", "(", "type", "=", "get_attr_type", "(", "insn", ")", ")", "==", "TYPE_BRANCH", "||", "(", "(", "type", "==", "TYPE_UNCOND_BRANCH", "||", "type", "==", "TYPE_RETURN", ")", "&&", "ARC_CCFSM_BRANCH_DELETED_P", "(", "state", ")", ")", ")", ")", "{", "if", "(", "ARC_CCFSM_BRANCH_DELETED_P", "(", "state", ")", ")", "ARC_CCFSM_RECORD_BRANCH_DELETED", "(", "state", ")", ";", "else", "{", "rtx", "src", "=", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ";", "arc_ccfsm_record_condition", "(", "XEXP", "(", "src", ",", "0", ")", ",", "XEXP", "(", "src", ",", "1", ")", "==", "pc_rtx", ",", "insn", ",", "state", ")", ";", "}", "}", "else", "if", "(", "arc_ccfsm_current", ".", "state", "==", "5", ")", "arc_ccfsm_current", ".", "state", "=", "0", ";", "}", "</s>"], "natrual_language": ["Update", "*", "STATE", "as", "we", "would", "when", "we", "emit", "INSN", "."], "TS_V_token": ["arc", "\"L\"", "0", "1", "5", "0"], "File": "arc", "Func": "arc_ccfsm_post_advance", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33658, "Length": 162}
{"ground_truth": ["<s>", "void", "arc_ccfsm_record_branch_deleted", "(", "void", ")", "{", "ARC_CCFSM_RECORD_BRANCH_DELETED", "(", "&", "arc_ccfsm_current", ")", ";", "}", "</s>"], "natrual_language": ["Record", "a", "branch", "is", "n't", "output", "because", "subsequent", "insns", "can", "be", "conditionalized", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_ccfsm_record_branch_deleted", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33659, "Length": 13}
{"ground_truth": ["<s>", "void", "arc_ccfsm_record_condition", "(", "rtx", "cond", ",", "bool", "reverse", ",", "rtx_insn", "*", "jump", ",", "struct", "arc_ccfsm", "*", "state", ")", "{", "rtx_insn", "*", "seq_insn", "=", "NEXT_INSN", "(", "PREV_INSN", "(", "jump", ")", ")", ";", "if", "(", "!", "state", ")", "state", "=", "&", "arc_ccfsm_current", ";", "gcc_assert", "(", "state", "->", "state", "==", "0", ")", ";", "if", "(", "seq_insn", "!=", "jump", ")", "{", "rtx", "insn", "=", "XVECEXP", "(", "PATTERN", "(", "seq_insn", ")", ",", "0", ",", "1", ")", ";", "if", "(", "!", "as_a", "<", "rtx_insn", "*", ">", "(", "insn", ")", "->", "deleted", "(", ")", "&&", "INSN_ANNULLED_BRANCH_P", "(", "jump", ")", "&&", "(", "TARGET_AT_DBR_CONDEXEC", "||", "INSN_FROM_TARGET_P", "(", "insn", ")", ")", ")", "{", "state", "->", "cond", "=", "cond", ";", "state", "->", "cc", "=", "get_arc_condition_code", "(", "cond", ")", ";", "if", "(", "!", "reverse", ")", "arc_ccfsm_current", ".", "cc", "=", "ARC_INVERSE_CONDITION_CODE", "(", "state", "->", "cc", ")", ";", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "COND_EXEC", ")", "gcc_assert", "(", "(", "INSN_FROM_TARGET_P", "(", "insn", ")", "?", "ARC_INVERSE_CONDITION_CODE", "(", "state", "->", "cc", ")", ":", "state", "->", "cc", ")", "==", "get_arc_condition_code", "(", "XEXP", "(", "pat", ",", "0", ")", ")", ")", ";", "else", "state", "->", "state", "=", "5", ";", "}", "}", "}", "</s>"], "natrual_language": ["We", "are", "considering", "a", "conditional", "branch", "with", "the", "condition", "COND", ".", "Check", "if", "we", "want", "to", "conditionalize", "a", "delay", "slot", "insn", ",", "and", "if", "so", "modify", "the", "ccfsm", "state", "accordingly", ".", "REVERSE", "says", "branch", "will", "branch", "when", "the", "condition", "is", "false", "."], "TS_V_token": ["arc", "0", "0", "1", "0", "5"], "File": "arc", "Func": "arc_ccfsm_record_condition", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33660, "Length": 192}
{"ground_truth": ["<s>", "bool", "arc_check_ior_const", "(", "HOST_WIDE_INT", "ival", ")", "{", "unsigned", "int", "mask", "=", "(", "unsigned", "int", ")", "(", "ival", "&", "0xffffffff", ")", ";", "if", "(", "UNSIGNED_INT6", "(", "ival", ")", "||", "IS_POWEROF2_P", "(", "mask", ")", ")", "return", "false", ";", "if", "(", "__builtin_popcount", "(", "mask", ")", "<=", "3", ")", "return", "true", ";", "if", "(", "__builtin_popcount", "(", "mask", "&", "~", "0x3f", ")", "<=", "1", ")", "return", "true", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Helper", "to", "check", "C0x", "constraint", "."], "TS_V_token": ["arc", "0xffffffff", "3", "0x3f", "1"], "File": "arc", "Func": "arc_check_ior_const", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33661, "Length": 67}
{"ground_truth": ["<s>", "int", "arc_check_millicode", "(", "rtx", "op", ",", "int", "offset", ",", "int", "load_p", ")", "{", "int", "len", "=", "XVECLEN", "(", "op", ",", "0", ")", "-", "offset", ";", "int", "i", ";", "if", "(", "load_p", "==", "2", ")", "{", "if", "(", "len", "<", "2", "||", "len", ">", "13", ")", "return", "0", ";", "load_p", "=", "1", ";", "}", "else", "{", "rtx", "elt", "=", "XVECEXP", "(", "op", ",", "0", ",", "--", "len", ")", ";", "if", "(", "GET_CODE", "(", "elt", ")", "!=", "CLOBBER", "||", "!", "REG_P", "(", "XEXP", "(", "elt", ",", "0", ")", ")", "||", "REGNO", "(", "XEXP", "(", "elt", ",", "0", ")", ")", "!=", "RETURN_ADDR_REGNUM", "||", "len", "<", "3", "||", "len", ">", "13", ")", "return", "0", ";", "}", "for", "(", "i", "=", "1", ";", "i", "<", "len", ";", "i", "++", ")", "{", "rtx", "elt", "=", "XVECEXP", "(", "op", ",", "0", ",", "i", "+", "offset", ")", ";", "rtx", "reg", ",", "mem", ",", "addr", ";", "if", "(", "GET_CODE", "(", "elt", ")", "!=", "SET", ")", "return", "0", ";", "mem", "=", "XEXP", "(", "elt", ",", "load_p", ")", ";", "reg", "=", "XEXP", "(", "elt", ",", "1", "-", "load_p", ")", ";", "if", "(", "!", "REG_P", "(", "reg", ")", "||", "REGNO", "(", "reg", ")", "!=", "13U", "+", "i", "||", "!", "MEM_P", "(", "mem", ")", ")", "return", "0", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "PLUS", "||", "!", "rtx_equal_p", "(", "stack_pointer_rtx", ",", "XEXP", "(", "addr", ",", "0", ")", ")", "||", "!", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "||", "INTVAL", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "!=", "i", "*", "4", ")", "return", "0", ";", "}", "return", "1", ";", "}", "</s>"], "natrual_language": ["Check", "if", "OP", "is", "a", "proper", "parallel", "of", "a", "millicode", "call", "pattern", ".", "OFFSET", "indicates", "a", "number", "of", "elements", "to", "ignore", "-", "that", "allows", "to", "have", "a", "sibcall", "pattern", "that", "starts", "with", "(", "return", ")", ".", "LOAD_P", "is", "zero", "for", "store", "multiple", "(", "for", "prologues", ")", ",", "and", "one", "for", "load", "multiples", "(", "for", "epilogues", ")", ",", "and", "two", "for", "load", "multiples", "where", "no", "final", "clobber", "of", "blink", "is", "required", ".", "We", "also", "skip", "the", "first", "load", "/", "store", "element", "since", "this", "is", "supposed", "to", "be", "checked", "in", "the", "instruction", "pattern", "."], "TS_V_token": ["arc", "0", "2", "2", "13", "0", "1", "0", "0", "0", "3", "13", "0", "1", "0", "0", "1", "13U", "0", "0", "0", "1", "1", "4", "0", "1"], "File": "arc", "Func": "arc_check_millicode", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33662, "Length": 269}
{"ground_truth": ["<s>", "bool", "arc_check_mov_const", "(", "HOST_WIDE_INT", "ival", ")", "{", "ival", "=", "ival", "&", "0xffffffff", ";", "if", "(", "SIGNED_INT12", "(", "ival", ")", ")", "return", "false", ";", "if", "(", "(", "ival", "&", "~", "0x8000001f", ")", "==", "0", ")", "return", "true", ";", "if", "(", "IS_POWEROF2_P", "(", "ival", "+", "1", ")", ")", "return", "true", ";", "if", "(", "!", "TARGET_BARREL_SHIFTER", ")", "return", "false", ";", "if", "(", "(", "(", "ival", ">>", "(", "__builtin_ffs", "(", "ival", ")", "-", "1", ")", ")", "&", "0xffffff00", ")", "==", "0", ")", "return", "true", ";", "if", "(", "(", "ival", "&", "~", "0x3f00", ")", "==", "0", ")", "return", "true", ";", "if", "(", "(", "ival", "&", "~", "0x3f0000", ")", "==", "0", ")", "return", "true", ";", "if", "(", "(", "ival", "&", "~", "0x3f000000", ")", "==", "0", ")", "return", "true", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Helper", "to", "check", "Cax", "constraint", "."], "TS_V_token": ["arc", "0xffffffff", "0x8000001f", "0", "1", "1", "0xffffff00", "0", "0x3f00", "0", "0x3f0000", "0", "0x3f000000", "0"], "File": "arc", "Func": "arc_check_mov_const", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33663, "Length": 127}
{"ground_truth": ["<s>", "bool", "arc_check_multi", "(", "rtx", "op", ",", "bool", "push_p", ")", "{", "HOST_WIDE_INT", "len", "=", "XVECLEN", "(", "op", ",", "0", ")", ";", "unsigned", "int", "regno", ",", "i", ",", "start", ";", "unsigned", "int", "memp", "=", "push_p", "?", "0", ":", "1", ";", "rtx", "elt", ";", "if", "(", "len", "<=", "1", ")", "return", "false", ";", "start", "=", "1", ";", "elt", "=", "XVECEXP", "(", "op", ",", "0", ",", "0", ")", ";", "if", "(", "!", "push_p", "&&", "GET_CODE", "(", "elt", ")", "==", "RETURN", ")", "start", "=", "2", ";", "for", "(", "i", "=", "start", ",", "regno", "=", "ENTER_LEAVE_START_REG", ";", "i", "<", "len", ";", "i", "++", ",", "regno", "++", ")", "{", "rtx", "elt", "=", "XVECEXP", "(", "op", ",", "0", ",", "i", ")", ";", "rtx", "reg", ",", "mem", ",", "addr", ";", "if", "(", "GET_CODE", "(", "elt", ")", "!=", "SET", ")", "return", "false", ";", "mem", "=", "XEXP", "(", "elt", ",", "memp", ")", ";", "reg", "=", "XEXP", "(", "elt", ",", "1", "-", "memp", ")", ";", "if", "(", "!", "REG_P", "(", "reg", ")", "||", "!", "MEM_P", "(", "mem", ")", ")", "return", "false", ";", "if", "(", "REGNO", "(", "reg", ")", "==", "RETURN_ADDR_REGNUM", "&&", "i", "==", "start", ")", "regno", "=", "12", ";", "else", "if", "(", "REGNO", "(", "reg", ")", "==", "HARD_FRAME_POINTER_REGNUM", ")", "++", "i", ";", "else", "if", "(", "REGNO", "(", "reg", ")", "!=", "regno", ")", "return", "false", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "stack_pointer_rtx", ",", "XEXP", "(", "addr", ",", "0", ")", ")", "||", "!", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ")", "return", "false", ";", "}", "else", "{", "if", "(", "!", "rtx_equal_p", "(", "stack_pointer_rtx", ",", "addr", ")", ")", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["Helper", "for", "{", "push/pop", "}", "_multi_operand", ":", "check", "if", "rtx", "OP", "is", "a", "suitable", "construct", "to", "match", "either", "enter", "or", "leave", "instruction", ".", "Which", "one", "which", "is", "selected", "by", "PUSH_P", "argument", "."], "TS_V_token": ["arc", "0", "0", "1", "1", "1", "0", "0", "2", "0", "1", "12", "0", "0", "1"], "File": "arc", "Func": "arc_check_multi", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33664, "Length": 283}
{"ground_truth": ["<s>", "void", "arc_clear_unalign", "(", "void", ")", "{", "if", "(", "cfun", ")", "cfun", "->", "machine", "->", "unalign", "=", "0", ";", "}", "</s>"], "natrual_language": ["Accessor", "functions", "for", "cfun-", ">", "machine-", ">", "unalign", "."], "TS_V_token": ["arc", "0"], "File": "arc", "Func": "arc_clear_unalign", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33665, "Length": 19}
{"ground_truth": ["<s>", "static", "unsigned", "int", "arc_compute_frame_size", "(", "void", ")", "{", "int", "regno", ";", "unsigned", "int", "total_size", ",", "var_size", ",", "args_size", ",", "pretend_size", ",", "extra_size", ";", "unsigned", "int", "reg_size", ";", "uint64_t", "gmask", ";", "struct", "arc_frame_info", "*", "frame_info", ";", "int", "size", ";", "unsigned", "int", "extra_plus_reg_size", ";", "unsigned", "int", "extra_plus_reg_size_aligned", ";", "unsigned", "int", "fn_type", "=", "arc_compute_function_type", "(", "cfun", ")", ";", "if", "(", "cfun", "->", "machine", "->", "frame_info", ".", "initialized", ")", "return", "cfun", "->", "machine", "->", "frame_info", ".", "total_size", ";", "frame_info", "=", "&", "cfun", "->", "machine", "->", "frame_info", ";", "size", "=", "ARC_STACK_ALIGN", "(", "get_frame_size", "(", ")", ")", ";", "var_size", "=", "size", ";", "args_size", "=", "crtl", "->", "outgoing_args_size", ";", "reg_size", "=", "0", ";", "gmask", "=", "0", ";", "for", "(", "regno", "=", "0", ";", "regno", "<=", "(", "GMASK_LEN", "-", "4", ")", ";", "regno", "++", ")", "{", "if", "(", "arc_must_save_register", "(", "regno", ",", "cfun", ",", "false", ")", ")", "{", "reg_size", "+=", "UNITS_PER_WORD", ";", "gmask", "|=", "1ULL", "<<", "regno", ";", "}", "}", "if", "(", "crtl", "->", "calls_eh_return", ")", "for", "(", "regno", "=", "0", ";", "EH_RETURN_DATA_REGNO", "(", "regno", ")", "!=", "INVALID_REGNUM", ";", "regno", "++", ")", "{", "reg_size", "+=", "UNITS_PER_WORD", ";", "gmask", "|=", "1ULL", "<<", "regno", ";", "}", "frame_info", "->", "save_return_addr", "=", "(", "!", "crtl", "->", "is_leaf", "||", "df_regs_ever_live_p", "(", "RETURN_ADDR_REGNUM", ")", "||", "crtl", "->", "calls_eh_return", ")", ";", "if", "(", "TARGET_MILLICODE_THUNK_SET", "&&", "!", "ARC_INTERRUPT_P", "(", "fn_type", ")", "&&", "!", "crtl", "->", "calls_eh_return", ")", "{", "if", "(", "arc_compute_millicode_save_restore_regs", "(", "gmask", ",", "frame_info", ")", ")", "frame_info", "->", "save_return_addr", "=", "true", ";", "}", "if", "(", "arc_lpcwidth", "!=", "0", "&&", "arc_must_save_register", "(", "LP_COUNT", ",", "cfun", ",", "true", ")", ")", "reg_size", "+=", "UNITS_PER_WORD", "*", "3", ";", "if", "(", "arc_must_save_register", "(", "TARGET_BIG_ENDIAN", "?", "R41_REG", ":", "R40_REG", ",", "cfun", ",", "TARGET_DPFP", ")", ")", "reg_size", "+=", "UNITS_PER_WORD", "*", "2", ";", "if", "(", "arc_must_save_register", "(", "TARGET_BIG_ENDIAN", "?", "R43_REG", ":", "R42_REG", ",", "cfun", ",", "TARGET_DPFP", ")", ")", "reg_size", "+=", "UNITS_PER_WORD", "*", "2", ";", "if", "(", "arc_must_save_register", "(", "R58_REG", ",", "cfun", ",", "true", ")", ")", "reg_size", "+=", "UNITS_PER_WORD", "*", "2", ";", "extra_size", "=", "0", ";", "if", "(", "arc_must_save_return_addr", "(", "cfun", ")", ")", "extra_size", "=", "4", ";", "if", "(", "arc_frame_pointer_needed", "(", ")", "&&", "!", "ARC_AUTOFP_IRQ_P", "(", "fn_type", ")", ")", "extra_size", "+=", "4", ";", "pretend_size", "=", "crtl", "->", "args", ".", "pretend_args_size", ";", "extra_plus_reg_size", "=", "extra_size", "+", "reg_size", ";", "extra_plus_reg_size_aligned", "=", "ARC_STACK_ALIGN", "(", "extra_plus_reg_size", ")", ";", "reg_size", "=", "extra_plus_reg_size_aligned", "-", "extra_size", ";", "total_size", "=", "var_size", "+", "args_size", "+", "extra_size", "+", "pretend_size", "+", "reg_size", ";", "gcc_assert", "(", "total_size", "==", "ARC_STACK_ALIGN", "(", "total_size", ")", ")", ";", "frame_info", "->", "total_size", "=", "total_size", ";", "frame_info", "->", "extra_size", "=", "extra_size", ";", "frame_info", "->", "pretend_size", "=", "pretend_size", ";", "frame_info", "->", "var_size", "=", "var_size", ";", "frame_info", "->", "args_size", "=", "args_size", ";", "frame_info", "->", "reg_size", "=", "reg_size", ";", "frame_info", "->", "gmask", "=", "gmask", ";", "frame_info", "->", "initialized", "=", "reload_completed", ";", "return", "total_size", ";", "}", "</s>"], "natrual_language": ["Return", "the", "bytes", "needed", "to", "compute", "the", "frame", "pointer", "from", "the", "current", "stack", "pointer", ".", "SIZE", "is", "the", "size", "needed", "for", "local", "variables", "."], "TS_V_token": ["arc", "0", "0", "0", "4", "1ULL", "0", "1ULL", "0", "3", "2", "2", "2", "0", "4", "4"], "File": "arc", "Func": "arc_compute_frame_size", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33666, "Length": 450}
{"ground_truth": ["<s>", "static", "unsigned", "int", "arc_compute_function_type", "(", "struct", "function", "*", "fun", ")", "{", "tree", "attr", ",", "decl", "=", "fun", "->", "decl", ";", "unsigned", "int", "fn_type", "=", "fun", "->", "machine", "->", "fn_type", ";", "if", "(", "fn_type", "!=", "ARC_FUNCTION_UNKNOWN", ")", "return", "fn_type", ";", "if", "(", "lookup_attribute", "(", "\"naked\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", "!=", "NULL_TREE", ")", "fn_type", "|=", "ARC_FUNCTION_NAKED", ";", "else", "fn_type", "|=", "ARC_FUNCTION_NORMAL", ";", "attr", "=", "lookup_attribute", "(", "\"interrupt\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ";", "if", "(", "attr", "!=", "NULL_TREE", ")", "{", "tree", "value", ",", "args", "=", "TREE_VALUE", "(", "attr", ")", ";", "gcc_assert", "(", "list_length", "(", "args", ")", "==", "1", ")", ";", "value", "=", "TREE_VALUE", "(", "args", ")", ";", "gcc_assert", "(", "TREE_CODE", "(", "value", ")", "==", "STRING_CST", ")", ";", "if", "(", "!", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink1\"", ")", "||", "!", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink\"", ")", ")", "fn_type", "|=", "ARC_FUNCTION_ILINK1", ";", "else", "if", "(", "!", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink2\"", ")", ")", "fn_type", "|=", "ARC_FUNCTION_ILINK2", ";", "else", "if", "(", "!", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"firq\"", ")", ")", "fn_type", "|=", "ARC_FUNCTION_FIRQ", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "return", "fun", "->", "machine", "->", "fn_type", "=", "fn_type", ";", "}", "</s>"], "natrual_language": ["Type", "of", "function", "DECL", ".", "The", "result", "is", "cached", ".", "To", "reset", "the", "cache", "at", "the", "end", "of", "a", "function", ",", "call", "with", "DECL", "=", "NULL_TREE", "."], "TS_V_token": ["arc", "\"naked\"", "\"interrupt\"", "1", "\"ilink1\"", "\"ilink\"", "\"ilink2\"", "\"firq\""], "File": "arc", "Func": "arc_compute_function_type", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33667, "Length": 198}
{"ground_truth": ["<s>", "static", "int", "arc_compute_millicode_save_restore_regs", "(", "uint64_t", "gmask", ",", "struct", "arc_frame_info", "*", "frame", ")", "{", "int", "regno", ";", "int", "start_reg", "=", "13", ",", "end_reg", "=", "25", ";", "for", "(", "regno", "=", "start_reg", ";", "regno", "<=", "end_reg", "&&", "(", "gmask", "&", "(", "1ULL", "<<", "regno", ")", ")", ";", ")", "regno", "++", ";", "end_reg", "=", "regno", "-", "1", ";", "if", "(", "regno", "-", "start_reg", ">=", "3", "-", "(", "crtl", "->", "is_leaf", "==", "0", ")", ")", "{", "frame", "->", "millicode_start_reg", "=", "13", ";", "frame", "->", "millicode_end_reg", "=", "regno", "-", "1", ";", "return", "1", ";", "}", "return", "0", ";", "}", "</s>"], "natrual_language": ["Return", "non-zero", "if", "there", "are", "registers", "to", "be", "saved", "or", "loaded", "using", "millicode", "thunks", ".", "We", "can", "only", "use", "consecutive", "sequences", "starting", "with", "r13", ",", "and", "not", "going", "beyond", "r25", ".", "GMASK", "is", "a", "bitmask", "of", "registers", "to", "save", ".", "This", "function", "sets", "FRAME-", ">", "millicod_start_reg", "..", "FRAME-", ">", "millicode_end_reg", "to", "the", "range", "of", "registers", "to", "be", "saved", "/", "restored", "with", "a", "millicode", "call", "."], "TS_V_token": ["arc", "13", "25", "1ULL", "1", "3", "0", "13", "1", "1", "0"], "File": "arc", "Func": "arc_compute_millicode_save_restore_regs", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33668, "Length": 94}
{"ground_truth": ["<s>", "static", "int", "arc_comp_type_attributes", "(", "const_tree", "type1", ",", "const_tree", "type2", ")", "{", "int", "l1", ",", "l2", ",", "m1", ",", "m2", ",", "s1", ",", "s2", ";", "if", "(", "TREE_CODE", "(", "type1", ")", "!=", "FUNCTION_TYPE", ")", "return", "1", ";", "l1", "=", "lookup_attribute", "(", "\"long_call\"", ",", "TYPE_ATTRIBUTES", "(", "type1", ")", ")", "!=", "NULL", ";", "l2", "=", "lookup_attribute", "(", "\"long_call\"", ",", "TYPE_ATTRIBUTES", "(", "type2", ")", ")", "!=", "NULL", ";", "m1", "=", "lookup_attribute", "(", "\"medium_call\"", ",", "TYPE_ATTRIBUTES", "(", "type1", ")", ")", "!=", "NULL", ";", "m2", "=", "lookup_attribute", "(", "\"medium_call\"", ",", "TYPE_ATTRIBUTES", "(", "type2", ")", ")", "!=", "NULL", ";", "s1", "=", "lookup_attribute", "(", "\"short_call\"", ",", "TYPE_ATTRIBUTES", "(", "type1", ")", ")", "!=", "NULL", ";", "s2", "=", "lookup_attribute", "(", "\"short_call\"", ",", "TYPE_ATTRIBUTES", "(", "type2", ")", ")", "!=", "NULL", ";", "if", "(", "l1", "|", "l2", "|", "m1", "|", "m2", "|", "s1", "|", "s2", ")", "{", "if", "(", "(", "l1", "!=", "l2", ")", "||", "(", "m1", "!=", "m2", ")", "||", "(", "s1", "!=", "s2", ")", ")", "return", "0", ";", "if", "(", "l1", "+", "m1", "+", "s1", ">", "1", ")", "return", "0", ";", "}", "return", "1", ";", "}", "</s>"], "natrual_language": ["Return", "zero", "if", "TYPE1", "and", "TYPE", "are", "incompatible", ",", "one", "if", "they", "are", "compatible", ",", "and", "two", "if", "they", "are", "nearly", "compatible", "(", "which", "causes", "a", "warning", "to", "be", "generated", ")", "."], "TS_V_token": ["arc", "1", "\"long_call\"", "\"long_call\"", "\"medium_call\"", "\"medium_call\"", "\"short_call\"", "\"short_call\"", "0", "1", "0", "1"], "File": "arc", "Func": "arc_comp_type_attributes", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33669, "Length": 176}
{"ground_truth": ["<s>", "bool", "arc_double_limm_p", "(", "rtx", "value", ")", "{", "HOST_WIDE_INT", "low", ",", "high", ";", "gcc_assert", "(", "GET_CODE", "(", "value", ")", "==", "CONST_DOUBLE", ")", ";", "if", "(", "TARGET_DPFP", ")", "return", "true", ";", "low", "=", "CONST_DOUBLE_LOW", "(", "value", ")", ";", "high", "=", "CONST_DOUBLE_HIGH", "(", "value", ")", ";", "if", "(", "low", "&", "0x80000000", ")", "{", "return", "(", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "low", "<=", "0xffffffff", "&&", "high", "==", "0", ")", "||", "(", "(", "(", "low", "&", "-", "(", "unsigned", "HOST_WIDE_INT", ")", "0x80000000", ")", "==", "-", "(", "unsigned", "HOST_WIDE_INT", ")", "0x80000000", ")", "&&", "high", "==", "-", "1", ")", ")", ";", "}", "else", "{", "return", "(", "unsigned", "HOST_WIDE_INT", ")", "low", "<=", "0x7fffffff", "&&", "high", "==", "0", ";", "}", "}", "</s>"], "natrual_language": ["Return", "1", "if", "VALUE", ",", "a", "const_double", ",", "will", "fit", "in", "a", "limm", "(", "4", "byte", "number", ")", ".", "We", "assume", "the", "value", "can", "be", "either", "signed", "or", "unsigned", "."], "TS_V_token": ["arc", "0x80000000", "0xffffffff", "0", "0x80000000", "0x80000000", "1", "0x7fffffff", "0"], "File": "arc", "Func": "arc_double_limm_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33670, "Length": 112}
{"ground_truth": ["<s>", "static", "void", "arc_dwarf_emit_irq_save_regs", "(", "void", ")", "{", "rtx", "tmp", ",", "par", ",", "insn", ",", "reg", ";", "int", "i", ",", "offset", ",", "j", ";", "par", "=", "gen_rtx_SEQUENCE", "(", "VOIDmode", ",", "rtvec_alloc", "(", "irq_ctrl_saved", ".", "irq_save_last_reg", "+", "1", "+", "irq_ctrl_saved", ".", "irq_save_blink", "+", "irq_ctrl_saved", ".", "irq_save_lpcount", "+", "1", ")", ")", ";", "j", "=", "0", ";", "offset", "=", "UNITS_PER_WORD", "*", "(", "irq_ctrl_saved", ".", "irq_save_last_reg", "+", "1", "+", "irq_ctrl_saved", ".", "irq_save_blink", "+", "irq_ctrl_saved", ".", "irq_save_lpcount", ")", ";", "tmp", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "1", "*", "offset", ")", ";", "tmp", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "tmp", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "par", ",", "0", ",", "j", "++", ")", "=", "tmp", ";", "offset", "-=", "UNITS_PER_WORD", ";", "if", "(", "irq_ctrl_saved", ".", "irq_save_lpcount", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "60", ")", ";", "tmp", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ";", "tmp", "=", "gen_frame_mem", "(", "SImode", ",", "tmp", ")", ";", "tmp", "=", "gen_rtx_SET", "(", "tmp", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "par", ",", "0", ",", "j", "++", ")", "=", "tmp", ";", "offset", "-=", "UNITS_PER_WORD", ";", "}", "if", "(", "irq_ctrl_saved", ".", "irq_save_blink", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "31", ")", ";", "tmp", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ";", "tmp", "=", "gen_frame_mem", "(", "SImode", ",", "tmp", ")", ";", "tmp", "=", "gen_rtx_SET", "(", "tmp", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "par", ",", "0", ",", "j", "++", ")", "=", "tmp", ";", "offset", "-=", "UNITS_PER_WORD", ";", "}", "for", "(", "i", "=", "irq_ctrl_saved", ".", "irq_save_last_reg", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "i", ")", ";", "tmp", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ";", "tmp", "=", "gen_frame_mem", "(", "SImode", ",", "tmp", ")", ";", "tmp", "=", "gen_rtx_SET", "(", "tmp", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "par", ",", "0", ",", "j", "++", ")", "=", "tmp", ";", "offset", "-=", "UNITS_PER_WORD", ";", "}", "insn", "=", "emit_insn", "(", "gen_stack_irq_dwarf", "(", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "par", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "</s>"], "natrual_language": ["Build", "dwarf", "information", "when", "the", "context", "is", "saved", "via", "AUX_IRQ_CTRL", "mechanism", "."], "TS_V_token": ["arc", "1", "1", "0", "1", "1", "1", "0", "60", "1", "0", "31", "1", "0", "0", "1", "0", "1"], "File": "arc", "Func": "arc_dwarf_emit_irq_save_regs", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33671, "Length": 361}
{"ground_truth": ["<s>", "static", "rtx", "arc_dwarf_register_span", "(", "rtx", "rtl", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "rtl", ")", ";", "unsigned", "regno", ";", "rtx", "p", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "!=", "8", ")", "return", "NULL_RTX", ";", "p", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "2", ")", ")", ";", "regno", "=", "REGNO", "(", "rtl", ")", ";", "XVECEXP", "(", "p", ",", "0", ",", "0", ")", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "XVECEXP", "(", "p", ",", "0", ",", "1", ")", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", "+", "1", ")", ";", "return", "p", ";", "}", "</s>"], "natrual_language": ["Return", "a", "parallel", "of", "registers", "to", "represent", "where", "to", "find", "the", "register", "pieces", "if", "required", ",", "otherwise", "NULL_RTX", "."], "TS_V_token": ["arc", "8", "2", "0", "0", "0", "1", "1"], "File": "arc", "Func": "arc_dwarf_register_span", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33672, "Length": 91}
{"ground_truth": ["<s>", "void", "arc_eh_return_address_location", "(", "rtx", "source", ")", "{", "rtx", "mem", ";", "int", "offset", ";", "struct", "arc_frame_info", "*", "afi", ";", "arc_compute_frame_size", "(", ")", ";", "afi", "=", "&", "cfun", "->", "machine", "->", "frame_info", ";", "gcc_assert", "(", "crtl", "->", "calls_eh_return", ")", ";", "gcc_assert", "(", "afi", "->", "save_return_addr", ")", ";", "gcc_assert", "(", "afi", "->", "extra_size", ">=", "4", ")", ";", "offset", "=", "afi", "->", "reg_size", "+", "afi", "->", "extra_size", "-", "4", ";", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "hard_frame_pointer_rtx", ",", "offset", ")", ")", ";", "MEM_VOLATILE_P", "(", "mem", ")", "=", "true", ";", "emit_move_insn", "(", "mem", ",", "source", ")", ";", "}", "</s>"], "natrual_language": ["Return", "rtx", "for", "the", "location", "of", "the", "return", "address", "on", "the", "stack", ",", "suitable", "for", "use", "in", "__builtin_eh_return", ".", "The", "new", "return", "address", "will", "be", "written", "to", "this", "location", "in", "order", "to", "redirect", "the", "return", "to", "the", "exception", "handler", "."], "TS_V_token": ["arc", "4", "4"], "File": "arc", "Func": "arc_eh_return_address_location", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33673, "Length": 97}
{"ground_truth": ["<s>", "bool", "arc_eh_uses", "(", "int", "regno", ")", "{", "if", "(", "regno", "==", "arc_tp_regno", ")", "return", "true", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Helper", "for", "EH_USES", "macro", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_eh_uses", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33674, "Length": 20}
{"ground_truth": ["<s>", "static", "void", "arc_encode_section_info", "(", "tree", "decl", ",", "rtx", "rtl", ",", "int", "first", ")", "{", "default_encode_section_info", "(", "decl", ",", "rtl", ",", "first", ")", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "{", "rtx", "symbol", "=", "XEXP", "(", "rtl", ",", "0", ")", ";", "int", "flags", "=", "SYMBOL_REF_FLAGS", "(", "symbol", ")", ";", "tree", "attr", "=", "(", "TREE_TYPE", "(", "decl", ")", "!=", "error_mark_node", "?", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "decl", ")", ")", ":", "NULL_TREE", ")", ";", "tree", "long_call_attr", "=", "lookup_attribute", "(", "\"long_call\"", ",", "attr", ")", ";", "tree", "medium_call_attr", "=", "lookup_attribute", "(", "\"medium_call\"", ",", "attr", ")", ";", "tree", "short_call_attr", "=", "lookup_attribute", "(", "\"short_call\"", ",", "attr", ")", ";", "if", "(", "long_call_attr", "!=", "NULL_TREE", ")", "flags", "|=", "SYMBOL_FLAG_LONG_CALL", ";", "else", "if", "(", "medium_call_attr", "!=", "NULL_TREE", ")", "flags", "|=", "SYMBOL_FLAG_MEDIUM_CALL", ";", "else", "if", "(", "short_call_attr", "!=", "NULL_TREE", ")", "flags", "|=", "SYMBOL_FLAG_SHORT_CALL", ";", "SYMBOL_REF_FLAGS", "(", "symbol", ")", "=", "flags", ";", "}", "else", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", ")", "{", "rtx", "symbol", "=", "XEXP", "(", "rtl", ",", "0", ")", ";", "tree", "attr", "=", "(", "TREE_TYPE", "(", "decl", ")", "!=", "error_mark_node", "?", "DECL_ATTRIBUTES", "(", "decl", ")", ":", "NULL_TREE", ")", ";", "tree", "sec_attr", "=", "lookup_attribute", "(", "\"section\"", ",", "attr", ")", ";", "if", "(", "sec_attr", ")", "{", "const", "char", "*", "sec_name", "=", "TREE_STRING_POINTER", "(", "TREE_VALUE", "(", "TREE_VALUE", "(", "sec_attr", ")", ")", ")", ";", "if", "(", "strcmp", "(", "sec_name", ",", "\".cmem\"", ")", "==", "0", "||", "strcmp", "(", "sec_name", ",", "\".cmem_shared\"", ")", "==", "0", "||", "strcmp", "(", "sec_name", ",", "\".cmem_private\"", ")", "==", "0", ")", "SYMBOL_REF_FLAGS", "(", "symbol", ")", "|=", "SYMBOL_FLAG_CMEM", ";", "}", "}", "}", "</s>"], "natrual_language": ["Implement", "TARGET_ENCODE_SECTION_INFO", "hook", "."], "TS_V_token": ["arc", "0", "\"long_call\"", "\"medium_call\"", "\"short_call\"", "0", "\"section\"", "\".cmem\"", "0", "\".cmem_shared\"", "0", "\".cmem_private\"", "0"], "File": "arc", "Func": "arc_encode_section_info", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33675, "Length": 253}
{"ground_truth": ["<s>", "static", "bool", "arc_enter_leave_p", "(", "uint64_t", "gmask", ")", "{", "int", "regno", ";", "unsigned", "int", "rmask", "=", "0", ";", "if", "(", "!", "gmask", ")", "return", "false", ";", "for", "(", "regno", "=", "ENTER_LEAVE_START_REG", ";", "regno", "<=", "ENTER_LEAVE_END_REG", "&&", "(", "gmask", "&", "(", "1ULL", "<<", "regno", ")", ")", ";", "regno", "++", ")", "rmask", "|=", "1ULL", "<<", "regno", ";", "if", "(", "rmask", "^", "gmask", ")", "return", "false", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Check", "if", "we", "have", "a", "continous", "range", "to", "be", "save/restored", "with", "the", "help", "of", "enter/leave", "instructions", ".", "A", "vaild", "register", "range", "starts", "from", "$", "r13", "and", "is", "up", "to", "(", "including", ")", "$", "r26", "."], "TS_V_token": ["arc", "0", "1ULL", "1ULL"], "File": "arc", "Func": "arc_enter_leave_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33676, "Length": 67}
{"ground_truth": ["<s>", "bool", "arc_epilogue_uses", "(", "int", "regno", ")", "{", "unsigned", "int", "fn_type", ";", "fn_type", "=", "arc_compute_function_type", "(", "cfun", ")", ";", "if", "(", "regno", "==", "arc_tp_regno", ")", "return", "true", ";", "if", "(", "regno", "==", "RETURN_ADDR_REGNUM", ")", "return", "true", ";", "if", "(", "regno", "==", "arc_return_address_register", "(", "fn_type", ")", ")", "return", "true", ";", "if", "(", "epilogue_completed", "&&", "ARC_INTERRUPT_P", "(", "fn_type", ")", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "||", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Implement", "EPILOGUE__USES", ".", "Return", "true", "if", "REGNO", "should", "be", "added", "to", "the", "deemed", "uses", "of", "the", "epilogue", ".", "We", "use", "the", "return", "address", "arc_return_address_regs", "[", "arc_compute_function_type", "(", "cfun", ")", "]", ".", "But", "also", ",", "we", "have", "to", "make", "sure", "all", "the", "register", "restore", "instructions", "are", "known", "to", "be", "live", "in", "interrupt", "functions", ",", "plus", "the", "blink", "register", "if", "it", "is", "clobbered", "by", "the", "isr", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_epilogue_uses", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33677, "Length": 78}
{"ground_truth": ["<s>", "void", "arc_expand_atomic_op", "(", "enum", "rtx_code", "code", ",", "rtx", "mem", ",", "rtx", "val", ",", "rtx", "orig_before", ",", "rtx", "orig_after", ",", "rtx", "model_rtx", ")", "{", "enum", "memmodel", "model", "=", "(", "enum", "memmodel", ")", "INTVAL", "(", "model_rtx", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "rtx", "label", ",", "x", ",", "cond", ";", "rtx", "before", "=", "orig_before", ",", "after", "=", "orig_after", ";", "gcc_assert", "(", "mode", "==", "SImode", ")", ";", "arc_pre_atomic_barrier", "(", "model", ")", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label", ")", ";", "label", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "label", ")", ";", "if", "(", "before", "==", "NULL_RTX", ")", "before", "=", "gen_reg_rtx", "(", "mode", ")", ";", "if", "(", "after", "==", "NULL_RTX", ")", "after", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_arc_load_exclusivesi", "(", "before", ",", "mem", ")", ")", ";", "switch", "(", "code", ")", "{", "case", "NOT", ":", "x", "=", "gen_rtx_AND", "(", "mode", ",", "before", ",", "val", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "after", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_NOT", "(", "mode", ",", "after", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "after", ",", "x", ")", ")", ";", "break", ";", "case", "MINUS", ":", "if", "(", "CONST_INT_P", "(", "val", ")", ")", "{", "val", "=", "GEN_INT", "(", "-", "INTVAL", "(", "val", ")", ")", ";", "code", "=", "PLUS", ";", "}", "default", ":", "x", "=", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "before", ",", "val", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "after", ",", "x", ")", ")", ";", "break", ";", "}", "emit_insn", "(", "gen_arc_store_exclusivesi", "(", "mem", ",", "after", ")", ")", ";", "cond", "=", "gen_rtx_REG", "(", "CC_Zmode", ",", "CC_REG", ")", ";", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "cond", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "x", ",", "label", ",", "pc_rtx", ")", ";", "emit_unlikely_jump", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "x", ")", ")", ";", "arc_post_atomic_barrier", "(", "model", ")", ";", "}", "</s>"], "natrual_language": ["Expand", "an", "atomic", "fetch-and-operate", "pattern", ".", "CODE", "is", "the", "binary", "operation", "to", "perform", ".", "MEM", "is", "the", "memory", "on", "which", "to", "operate", ".", "VAL", "is", "the", "second", "operand", "of", "the", "binary", "operator", ".", "BEFORE", "and", "AFTER", "are", "optional", "locations", "to", "return", "the", "value", "of", "MEM", "either", "before", "of", "after", "the", "operation", ".", "MODEL_RTX", "is", "a", "CONST_INT", "containing", "the", "memory", "model", "to", "use", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_expand_atomic_op", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33678, "Length": 292}
{"ground_truth": ["<s>", "static", "rtx", "arc_expand_builtin_aligned", "(", "tree", "exp", ")", "{", "tree", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "tree", "arg1", "=", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ";", "fold", "(", "arg1", ")", ";", "rtx", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "rtx", "op1", "=", "expand_expr", "(", "arg1", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "op1", ")", ")", "{", "if", "(", "optimize", ")", "warning", "(", "0", ",", "\"%<__builtin_arc_aligned%> with non-constant alignment\"", ")", ";", "}", "else", "{", "HOST_WIDE_INT", "alignTest", "=", "INTVAL", "(", "op1", ")", ";", "if", "(", "alignTest", "<=", "0", "||", "alignTest", "!=", "(", "alignTest", "&", "-", "alignTest", ")", ")", "{", "error", "(", "\"invalid alignment value for %<__builtin_arc_aligned%>\"", ")", ";", "return", "NULL_RTX", ";", "}", "if", "(", "CONST_INT_P", "(", "op0", ")", ")", "{", "HOST_WIDE_INT", "pnt", "=", "INTVAL", "(", "op0", ")", ";", "if", "(", "(", "pnt", "&", "(", "alignTest", "-", "1", ")", ")", "==", "0", ")", "return", "const1_rtx", ";", "}", "else", "{", "unsigned", "align", "=", "get_pointer_alignment", "(", "arg0", ")", ";", "unsigned", "numBits", "=", "alignTest", "*", "BITS_PER_UNIT", ";", "if", "(", "align", "&&", "align", ">=", "numBits", ")", "return", "const1_rtx", ";", "if", "(", "POINTER_TYPE_P", "(", "TREE_TYPE", "(", "arg0", ")", ")", "&&", "TYPE_ALIGN", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "arg0", ")", ")", ")", ">=", "numBits", ")", "return", "const1_rtx", ";", "}", "}", "return", "const0_rtx", ";", "}", "</s>"], "natrual_language": ["Helper", "to", "expand", "__builtin_arc_aligned", "(", "void", "*", "val", ",", "int", "alignval", ")", "."], "TS_V_token": ["arc", "0", "1", "0", "\"%<__builtin_arc_aligned%> with non-constant alignment\"", "0", "\"invalid alignment value for %<__builtin_arc_aligned%>\"", "1", "0"], "File": "arc", "Func": "arc_expand_builtin_aligned", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33679, "Length": 211}
{"ground_truth": ["<s>", "void", "arc_expand_compare_and_swap", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "bval", ",", "rval", ",", "mem", ",", "oldval", ",", "newval", ",", "is_weak", ",", "mod_s", ",", "mod_f", ",", "x", ";", "machine_mode", "mode", ";", "bval", "=", "operands", "[", "0", "]", ";", "rval", "=", "operands", "[", "1", "]", ";", "mem", "=", "operands", "[", "2", "]", ";", "oldval", "=", "operands", "[", "3", "]", ";", "newval", "=", "operands", "[", "4", "]", ";", "is_weak", "=", "operands", "[", "5", "]", ";", "mod_s", "=", "operands", "[", "6", "]", ";", "mod_f", "=", "operands", "[", "7", "]", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "if", "(", "reg_overlap_mentioned_p", "(", "rval", ",", "oldval", ")", ")", "oldval", "=", "copy_to_reg", "(", "oldval", ")", ";", "if", "(", "mode", "==", "SImode", ")", "{", "emit_insn", "(", "gen_atomic_compare_and_swapsi_1", "(", "rval", ",", "mem", ",", "oldval", ",", "newval", ",", "is_weak", ",", "mod_s", ",", "mod_f", ")", ")", ";", "x", "=", "gen_rtx_REG", "(", "CC_Zmode", ",", "CC_REG", ")", ";", "x", "=", "gen_rtx_EQ", "(", "SImode", ",", "x", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "bval", ",", "x", ")", ")", ";", "}", "else", "{", "arc_expand_compare_and_swap_qh", "(", "bval", ",", "rval", ",", "mem", ",", "oldval", ",", "newval", ",", "is_weak", ",", "mod_s", ",", "mod_f", ")", ";", "}", "}", "</s>"], "natrual_language": ["Helper", "function", "used", "by", "``", "atomic_compare_and_swap", "''", "expand", "pattern", "."], "TS_V_token": ["arc", "0", "1", "2", "3", "4", "5", "6", "7"], "File": "arc", "Func": "arc_expand_compare_and_swap", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33680, "Length": 191}
{"ground_truth": ["<s>", "static", "void", "arc_file_start", "(", "void", ")", "{", "default_file_start", "(", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.cpu %s\\n\"", ",", "arc_cpu_string", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.arc_attribute Tag_ARC_PCS_config, %d\\n\"", ",", "ATTRIBUTE_PCS", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.arc_attribute Tag_ARC_ABI_rf16, %d\\n\"", ",", "TARGET_RF16", "?", "1", ":", "0", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.arc_attribute Tag_ARC_ABI_pic, %d\\n\"", ",", "flag_pic", "?", "2", ":", "0", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.arc_attribute Tag_ARC_ABI_tls, %d\\n\"", ",", "(", "arc_tp_regno", "!=", "-", "1", ")", "?", "1", ":", "0", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.arc_attribute Tag_ARC_ABI_sda, %d\\n\"", ",", "TARGET_NO_SDATA_SET", "?", "0", ":", "2", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.arc_attribute Tag_ARC_ABI_exceptions, %d\\n\"", ",", "TARGET_OPTFPE", "?", "1", ":", "0", ")", ";", "if", "(", "TARGET_V2", ")", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.arc_attribute Tag_ARC_CPU_variation, %d\\n\"", ",", "(", "arc_tune", "<", "ARC_TUNE_CORE_3", ")", "?", "2", ":", "(", "arc_tune", "==", "ARC_TUNE_CORE_3", "?", "3", ":", "4", ")", ")", ";", "}", "</s>"], "natrual_language": ["Set", "the", "cpu", "type", "and", "print", "out", "other", "fancy", "things", ",", "at", "the", "top", "of", "the", "file", "."], "TS_V_token": ["arc", "\"\\t.cpu %s\\n\"", "\"\\t.arc_attribute Tag_ARC_PCS_config, %d\\n\"", "\"\\t.arc_attribute Tag_ARC_ABI_rf16, %d\\n\"", "1", "0", "\"\\t.arc_attribute Tag_ARC_ABI_pic, %d\\n\"", "2", "0", "\"\\t.arc_attribute Tag_ARC_ABI_tls, %d\\n\"", "1", "1", "0", "\"\\t.arc_attribute Tag_ARC_ABI_sda, %d\\n\"", "0", "2", "\"\\t.arc_attribute Tag_ARC_ABI_exceptions, %d\\n\"", "1", "0", "\"\\t.arc_attribute Tag_ARC_CPU_variation, %d\\n\"", "2", "3", "4"], "File": "arc", "Func": "arc_file_start", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33681, "Length": 129}
{"ground_truth": ["<s>", "void", "arc_final_prescan_insn", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "opvec", "ATTRIBUTE_UNUSED", ",", "int", "noperands", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_DUMPISIZE", ")", "fprintf", "(", "asm_out_file", ",", "\"\\n; at %04x\\n\"", ",", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", ")", ";", "if", "(", "!", "cfun", "->", "machine", "->", "prescan_initialized", ")", "{", "memset", "(", "&", "arc_ccfsm_current", ",", "0", ",", "sizeof", "arc_ccfsm_current", ")", ";", "cfun", "->", "machine", "->", "prescan_initialized", "=", "1", ";", "}", "arc_ccfsm_advance", "(", "insn", ",", "&", "arc_ccfsm_current", ")", ";", "}", "</s>"], "natrual_language": ["The", "state", "of", "the", "fsm", "controlling", "condition", "codes", "are", ":", "0", ":", "normal", ",", "do", "nothing", "special", "1", ":", "do", "n't", "output", "this", "insn", "2", ":", "do", "n't", "output", "this", "insn", "3", ":", "make", "insns", "conditional", "4", ":", "make", "insns", "conditional", "State", "transitions", "(", "state-", ">", "state", "by", "whom", ",", "under", "what", "condition", ")", ":", "0", "-", ">", "1", "final_prescan_insn", ",", "if", "insn", "is", "conditional", "branch", "0", "-", ">", "2", "final_prescan_insn", ",", "if", "the", "`", "target", "'", "is", "an", "unconditional", "branch", "1", "-", ">", "3", "branch", "patterns", ",", "after", "having", "not", "output", "the", "conditional", "branch", "2", "-", ">", "4", "branch", "patterns", ",", "after", "having", "not", "output", "the", "conditional", "branch", "3", "-", ">", "0", "(", "*", "targetm.asm_out.internal_label", ")", ",", "if", "the", "`", "target", "'", "label", "is", "reached", "(", "the", "target", "label", "has", "CODE_LABEL_NUMBER", "equal", "to", "arc_ccfsm_target_label", ")", ".", "4", "-", ">", "0", "final_prescan_insn", ",", "if", "`", "target", "'", "unconditional", "branch", "is", "reached", "If", "the", "jump", "clobbers", "the", "conditions", "then", "we", "use", "states", "2", "and", "4", ".", "A", "similar", "thing", "can", "be", "done", "with", "conditional", "return", "insns", ".", "We", "also", "handle", "separating", "branches", "from", "sets", "of", "the", "condition", "code", ".", "This", "is", "done", "here", "because", "knowledge", "of", "the", "ccfsm", "state", "is", "required", ",", "we", "may", "not", "be", "outputting", "the", "branch", "."], "TS_V_token": ["arc", "\"\\n; at %04x\\n\"", "0", "1"], "File": "arc", "Func": "arc_final_prescan_insn", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33682, "Length": 75}
{"ground_truth": ["<s>", "static", "rtx", "arc_function_arg", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "arg_num", "=", "*", "cum", ";", "rtx", "ret", ";", "const", "char", "*", "debstr", "ATTRIBUTE_UNUSED", ";", "arg_num", "=", "ROUND_ADVANCE_CUM", "(", "arg_num", ",", "arg", ".", "mode", ",", "arg", ".", "type", ")", ";", "if", "(", "arg", ".", "end_marker_p", "(", ")", ")", "{", "ret", "=", "const0_rtx", ";", "debstr", "=", "\"<0>\"", ";", "}", "else", "if", "(", "GPR_REST_ARG_REGS", "(", "arg_num", ")", ">", "0", ")", "{", "ret", "=", "gen_rtx_REG", "(", "arg", ".", "mode", ",", "arg_num", ")", ";", "debstr", "=", "reg_names", "[", "arg_num", "]", ";", "}", "else", "{", "ret", "=", "NULL_RTX", ";", "debstr", "=", "\"memory\"", ";", "}", "return", "ret", ";", "}", "</s>"], "natrual_language": ["On", "the", "ARC", "the", "first", "MAX_ARC_PARM_REGS", "args", "are", "normally", "in", "registers", "and", "the", "rest", "are", "pushed", "."], "TS_V_token": ["arc", "\"<0>\"", "0", "\"memory\""], "File": "arc", "Func": "arc_function_arg", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33683, "Length": 115}
{"ground_truth": ["<s>", "static", "void", "arc_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "bytes", "=", "arg", ".", "promoted_size_in_bytes", "(", ")", ";", "int", "words", "=", "(", "bytes", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "int", "i", ";", "if", "(", "words", ")", "*", "cum", "=", "ROUND_ADVANCE_CUM", "(", "*", "cum", ",", "arg", ".", "mode", ",", "arg", ".", "type", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "words", ";", "i", "++", ")", "*", "cum", "=", "ARC_NEXT_ARG_REG", "(", "*", "cum", ")", ";", "}", "</s>"], "natrual_language": ["For", "the", "ARC", ":", "the", "cum", "set", "here", "is", "passed", "on", "to", "function_arg", "where", "we", "look", "at", "its", "value", "and", "say", "which", "reg", "to", "use", ".", "Strategy", ":", "advance", "the", "regnumber", "here", "till", "we", "run", "out", "of", "arg", "regs", ",", "then", "set", "*", "cum", "to", "last", "reg", ".", "In", "function_arg", ",", "since", "*", "cum", ">", "last", "arg", "reg", "we", "would", "return", "0", "and", "thus", "the", "arg", "will", "end", "up", "on", "the", "stack", ".", "For", "straddling", "args", "of", "course", "function_arg_partial_nregs", "will", "come", "into", "play", "."], "TS_V_token": ["arc", "1", "0"], "File": "arc", "Func": "arc_function_arg_advance", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33684, "Length": 91}
{"ground_truth": ["<s>", "static", "bool", "arc_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", "ATTRIBUTE_UNUSED", ")", "{", "tree", "attrs", "=", "NULL_TREE", ";", "if", "(", "ARC_INTERRUPT_P", "(", "arc_compute_function_type", "(", "cfun", ")", ")", ")", "return", "false", ";", "if", "(", "decl", ")", "{", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "if", "(", "lookup_attribute", "(", "\"jli_always\"", ",", "attrs", ")", ")", "return", "false", ";", "if", "(", "lookup_attribute", "(", "\"jli_fixed\"", ",", "attrs", ")", ")", "return", "false", ";", "if", "(", "lookup_attribute", "(", "\"secure_call\"", ",", "attrs", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "it", "is", "ok", "to", "make", "a", "tail-call", "to", "DECL", "."], "TS_V_token": ["arc", "\"jli_always\"", "\"jli_fixed\"", "\"secure_call\""], "File": "arc", "Func": "arc_function_ok_for_sibcall", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33685, "Length": 86}
{"ground_truth": ["<s>", "static", "rtx", "arc_function_value", "(", "const_tree", "valtype", ",", "const_tree", "fn_decl_or_type", "ATTRIBUTE_UNUSED", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "machine_mode", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "int", "unsignedp", "ATTRIBUTE_UNUSED", ";", "unsignedp", "=", "TYPE_UNSIGNED", "(", "valtype", ")", ";", "if", "(", "INTEGRAL_TYPE_P", "(", "valtype", ")", "||", "TREE_CODE", "(", "valtype", ")", "==", "OFFSET_TYPE", ")", "PROMOTE_MODE", "(", "mode", ",", "unsignedp", ",", "valtype", ")", ";", "return", "gen_rtx_REG", "(", "mode", ",", "0", ")", ";", "}", "</s>"], "natrual_language": ["Define", "how", "to", "find", "the", "value", "returned", "by", "a", "function", ".", "VALTYPE", "is", "the", "data", "type", "of", "the", "value", "(", "as", "a", "tree", ")", ".", "If", "the", "precise", "function", "being", "called", "is", "known", ",", "FN_DECL_OR_TYPE", "is", "its", "FUNCTION_DECL", ";", "otherwise", ",", "FN_DECL_OR_TYPE", "is", "its", "type", "."], "TS_V_token": ["arc", "0"], "File": "arc", "Func": "arc_function_value", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33686, "Length": 67}
{"ground_truth": ["<s>", "static", "rtx", "arc_get_ccfsm_cond", "(", "struct", "arc_ccfsm", "*", "statep", ",", "bool", "reverse", ")", "{", "rtx", "cond", "=", "statep", "->", "cond", ";", "int", "raw_cc", "=", "get_arc_condition_code", "(", "cond", ")", ";", "if", "(", "reverse", ")", "raw_cc", "=", "ARC_INVERSE_CONDITION_CODE", "(", "raw_cc", ")", ";", "if", "(", "statep", "->", "cc", "==", "raw_cc", ")", "return", "copy_rtx", "(", "cond", ")", ";", "gcc_assert", "(", "ARC_INVERSE_CONDITION_CODE", "(", "raw_cc", ")", "==", "statep", "->", "cc", ")", ";", "machine_mode", "ccm", "=", "GET_MODE", "(", "XEXP", "(", "cond", ",", "0", ")", ")", ";", "enum", "rtx_code", "code", "=", "reverse_condition", "(", "GET_CODE", "(", "cond", ")", ")", ";", "if", "(", "code", "==", "UNKNOWN", "||", "ccm", "==", "CC_FP_GTmode", "||", "ccm", "==", "CC_FP_GEmode", ")", "code", "=", "reverse_condition_maybe_unordered", "(", "GET_CODE", "(", "cond", ")", ")", ";", "return", "gen_rtx_fmt_ee", "(", "code", ",", "GET_MODE", "(", "cond", ")", ",", "copy_rtx", "(", "XEXP", "(", "cond", ",", "0", ")", ")", ",", "copy_rtx", "(", "XEXP", "(", "cond", ",", "1", ")", ")", ")", ";", "}", "</s>"], "natrual_language": ["Return", "a", "copy", "of", "COND", "from", "*", "STATEP", ",", "inverted", "if", "that", "is", "indicated", "by", "the", "CC", "field", "of", "*", "STATEP", "."], "TS_V_token": ["arc", "0", "0", "1"], "File": "arc", "Func": "arc_get_ccfsm_cond", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33687, "Length": 146}
{"ground_truth": ["<s>", "static", "tree", "arc_handle_aux_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", ",", "int", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "DECL_P", "(", "*", "node", ")", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "VAR_DECL", ")", "{", "error", "(", "\"%qE attribute only applies to variables\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "args", ")", "{", "if", "(", "TREE_CODE", "(", "TREE_VALUE", "(", "args", ")", ")", "==", "NON_LVALUE_EXPR", ")", "TREE_VALUE", "(", "args", ")", "=", "TREE_OPERAND", "(", "TREE_VALUE", "(", "args", ")", ",", "0", ")", ";", "tree", "arg", "=", "TREE_VALUE", "(", "args", ")", ";", "if", "(", "TREE_CODE", "(", "arg", ")", "!=", "INTEGER_CST", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute allows only an integer \"", "\"constant argument\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "}", "if", "(", "TREE_CODE", "(", "*", "node", ")", "==", "VAR_DECL", ")", "{", "tree", "fntype", "=", "TREE_TYPE", "(", "*", "node", ")", ";", "if", "(", "fntype", "&&", "TREE_CODE", "(", "fntype", ")", "==", "POINTER_TYPE", ")", "{", "tree", "attrs", "=", "tree_cons", "(", "get_identifier", "(", "\"aux\"", ")", ",", "NULL_TREE", ",", "TYPE_ATTRIBUTES", "(", "fntype", ")", ")", ";", "TYPE_ATTRIBUTES", "(", "fntype", ")", "=", "attrs", ";", "}", "}", "}", "return", "NULL_TREE", ";", "}", "</s>"], "natrual_language": ["Handle", "aux", "attribute", ".", "The", "auxiliary", "registers", "are", "addressed", "using", "special", "instructions", "lr", "and", "sr", ".", "The", "attribute", "'aux", "'", "indicates", "if", "a", "variable", "refers", "to", "the", "aux-regs", "and", "what", "is", "the", "register", "number", "desired", "."], "TS_V_token": ["arc", "\"%qE attribute only applies to variables\"", "0", "\"%qE attribute allows only an integer \"", "\"constant argument\"", "\"aux\""], "File": "arc", "Func": "arc_handle_aux_attribute", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33688, "Length": 186}
{"ground_truth": ["<s>", "static", "tree", "arc_handle_interrupt_attribute", "(", "tree", "*", ",", "tree", "name", ",", "tree", "args", ",", "int", ",", "bool", "*", "no_add_attrs", ")", "{", "gcc_assert", "(", "args", ")", ";", "tree", "value", "=", "TREE_VALUE", "(", "args", ")", ";", "if", "(", "TREE_CODE", "(", "value", ")", "!=", "STRING_CST", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"argument of %qE attribute is not a string constant\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "!", "TARGET_V2", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink1\"", ")", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink2\"", ")", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"argument of %qE attribute is not \\\"ilink1\\\" or \\\"ilink2\\\"\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "TARGET_V2", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink\"", ")", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"firq\"", ")", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"argument of %qE attribute is not \\\"ilink\\\" or \\\"firq\\\"\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>"], "natrual_language": ["Handle", "an", "``", "interrupt", "''", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "."], "TS_V_token": ["arc", "\"argument of %qE attribute is not a string constant\"", "\"ilink1\"", "\"ilink2\"", "\"argument of %qE attribute is not \\\"ilink1\\\" or \\\"ilink2\\\"\"", "\"ilink\"", "\"firq\"", "\"argument of %qE attribute is not \\\"ilink\\\" or \\\"firq\\\"\""], "File": "arc", "Func": "arc_handle_interrupt_attribute", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33689, "Length": 145}
{"ground_truth": ["<s>", "static", "tree", "arc_handle_uncached_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "DECL_P", "(", "*", "node", ")", "&&", "TREE_CODE", "(", "*", "node", ")", "!=", "TYPE_DECL", ")", "{", "error", "(", "\"%qE attribute only applies to types\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "args", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"argument of %qE attribute ignored\"", ",", "name", ")", ";", "}", "return", "NULL_TREE", ";", "}", "</s>"], "natrual_language": ["Handle", "``", "uncached", "''", "qualifier", "."], "TS_V_token": ["arc", "\"%qE attribute only applies to types\"", "\"argument of %qE attribute ignored\""], "File": "arc", "Func": "arc_handle_uncached_attribute", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33690, "Length": 73}
{"ground_truth": ["<s>", "static", "bool", "arc_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "return", "(", "arc_hard_regno_modes", "[", "regno", "]", "&", "arc_mode_class", "[", "mode", "]", ")", "!=", "0", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_HARD_REGNO_MODE_OK", "."], "TS_V_token": ["arc", "0"], "File": "arc", "Func": "arc_hard_regno_mode_ok", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33691, "Length": 28}
{"ground_truth": ["<s>", "static", "unsigned", "int", "arc_hard_regno_nregs", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "16", "&&", "regno", ">=", "ARC_FIRST_SIMD_VR_REG", "&&", "regno", "<=", "ARC_LAST_SIMD_VR_REG", ")", "return", "1", ";", "return", "CEIL", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "UNITS_PER_WORD", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_HARD_REGNO_NREGS", "."], "TS_V_token": ["arc", "16", "1"], "File": "arc", "Func": "arc_hard_regno_nregs", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33692, "Length": 45}
{"ground_truth": ["<s>", "int", "arc_hazard", "(", "rtx_insn", "*", "pred", ",", "rtx_insn", "*", "succ", ")", "{", "if", "(", "!", "pred", "||", "!", "INSN_P", "(", "pred", ")", "||", "!", "succ", "||", "!", "INSN_P", "(", "succ", ")", ")", "return", "0", ";", "if", "(", "TARGET_ARC600", ")", "return", "arc600_corereg_hazard", "(", "pred", ",", "succ", ")", ";", "return", "0", ";", "}", "</s>"], "natrual_language": ["For", "ARC600", ":", "A", "write", "to", "a", "core", "reg", "greater", "or", "equal", "to", "32", "must", "not", "be", "immediately", "followed", "by", "a", "use", ".", "Anticipate", "the", "length", "requirement", "to", "insert", "a", "nop", "between", "PRED", "and", "SUCC", "to", "prevent", "a", "hazard", "."], "TS_V_token": ["arc", "0", "0"], "File": "arc", "Func": "arc_hazard", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33693, "Length": 51}
{"ground_truth": ["<s>", "static", "void", "arc_init", "(", "void", ")", "{", "if", "(", "TARGET_V2", ")", "{", "if", "(", "TARGET_MPYW", "||", "TARGET_MULTI", ")", "arc_multcost", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "}", "if", "(", "arc_multcost", "<", "0", ")", "switch", "(", "arc_tune", ")", "{", "case", "ARC_TUNE_ARC700_4_2_STD", ":", "arc_multcost", "=", "COSTS_N_INSNS", "(", "4", ")", ";", "if", "(", "TARGET_NOMPY_SET", ")", "arc_multcost", "=", "COSTS_N_INSNS", "(", "30", ")", ";", "break", ";", "case", "ARC_TUNE_ARC700_4_2_XMAC", ":", "arc_multcost", "=", "COSTS_N_INSNS", "(", "3", ")", ";", "if", "(", "TARGET_NOMPY_SET", ")", "arc_multcost", "=", "COSTS_N_INSNS", "(", "30", ")", ";", "break", ";", "case", "ARC_TUNE_ARC600", ":", "if", "(", "TARGET_MUL64_SET", ")", "{", "arc_multcost", "=", "COSTS_N_INSNS", "(", "4", ")", ";", "break", ";", "}", "default", ":", "arc_multcost", "=", "COSTS_N_INSNS", "(", "30", ")", ";", "break", ";", "}", "if", "(", "TARGET_NOMPY_SET", "&&", "TARGET_ARC600_FAMILY", ")", "error", "(", "\"%<-mno-mpy%> supported only for ARC700 or ARCv2\"", ")", ";", "if", "(", "!", "TARGET_DPFP", "&&", "TARGET_DPFP_DISABLE_LRSR", ")", "error", "(", "\"%<-mno-dpfp-lrsr%> supported only with %<-mdpfp%>\"", ")", ";", "if", "(", "(", "TARGET_DPFP_FAST_SET", "&&", "TARGET_DPFP_COMPACT_SET", ")", "||", "(", "TARGET_SPFP_FAST_SET", "&&", "TARGET_SPFP_COMPACT_SET", ")", ")", "error", "(", "\"FPX fast and compact options cannot be specified together\"", ")", ";", "if", "(", "TARGET_SPFP_FAST_SET", "&&", "TARGET_ARC600_FAMILY", ")", "error", "(", "\"%<-mspfp_fast%> not available on ARC600 or ARC601\"", ")", ";", "if", "(", "(", "TARGET_DPFP_FAST_SET", "||", "TARGET_DPFP_COMPACT_SET", "||", "TARGET_SPFP", ")", "&&", "TARGET_HARD_FLOAT", ")", "error", "(", "\"no FPX/FPU mixing allowed\"", ")", ";", "if", "(", "flag_pic", "&&", "TARGET_ARC600_FAMILY", ")", "{", "warning", "(", "0", ",", "\"PIC is not supported for %qs\"", ",", "arc_cpu_string", ")", ";", "flag_pic", "=", "0", ";", "}", "arc_init_reg_tables", "(", ")", ";", "memset", "(", "arc_punct_chars", ",", "0", ",", "sizeof", "(", "arc_punct_chars", ")", ")", ";", "arc_punct_chars", "[", "'#'", "]", "=", "1", ";", "arc_punct_chars", "[", "'*'", "]", "=", "1", ";", "arc_punct_chars", "[", "'?'", "]", "=", "1", ";", "arc_punct_chars", "[", "'!'", "]", "=", "1", ";", "arc_punct_chars", "[", "'^'", "]", "=", "1", ";", "arc_punct_chars", "[", "'&'", "]", "=", "1", ";", "arc_punct_chars", "[", "'+'", "]", "=", "1", ";", "arc_punct_chars", "[", "'_'", "]", "=", "1", ";", "}", "</s>"], "natrual_language": ["Called", "by", "OVERRIDE_OPTIONS", "to", "initialize", "various", "things", "."], "TS_V_token": ["arc", "1", "0", "4", "30", "3", "30", "4", "30", "\"%<-mno-mpy%> supported only for ARC700 or ARCv2\"", "\"%<-mno-dpfp-lrsr%> supported only with %<-mdpfp%>\"", "\"FPX fast and compact options cannot be specified together\"", "\"%<-mspfp_fast%> not available on ARC600 or ARC601\"", "\"no FPX/FPU mixing allowed\"", "0", "\"PIC is not supported for %qs\"", "0", "0", "1", "1", "1", "1", "1", "1", "1", "1"], "File": "arc", "Func": "arc_init", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33694, "Length": 277}
{"ground_truth": ["<s>", "static", "void", "arc_initialize_trampoline", "(", "rtx", "tramp", ",", "tree", "fndecl", ",", "rtx", "cxt", ")", "{", "rtx", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "emit_block_move", "(", "tramp", ",", "assemble_trampoline_template", "(", ")", ",", "GEN_INT", "(", "TRAMPOLINE_SIZE", ")", ",", "BLOCK_OP_NORMAL", ")", ";", "emit_move_insn", "(", "adjust_address", "(", "tramp", ",", "SImode", ",", "8", ")", ",", "fnaddr", ")", ";", "emit_move_insn", "(", "adjust_address", "(", "tramp", ",", "SImode", ",", "12", ")", ",", "cxt", ")", ";", "maybe_emit_call_builtin___clear_cache", "(", "XEXP", "(", "tramp", ",", "0", ")", ",", "plus_constant", "(", "Pmode", ",", "XEXP", "(", "tramp", ",", "0", ")", ",", "TRAMPOLINE_SIZE", ")", ")", ";", "}", "</s>"], "natrual_language": ["With", "potentially", "multiple", "shared", "objects", "loaded", ",", "and", "multiple", "stacks", "present", "for", "multiple", "thereds", "where", "trampolines", "might", "reside", ",", "a", "simple", "range", "check", "will", "likely", "not", "suffice", "for", "the", "profiler", "to", "tell", "if", "a", "callee", "is", "a", "trampoline", ".", "We", "a", "speedier", "check", "by", "making", "the", "trampoline", "start", "at", "an", "address", "that", "is", "not", "4-byte", "aligned", ".", "A", "trampoline", "looks", "like", "this", ":", "nop_s", "0x78e0entry", ":", "ld_s", "r12", ",", "[", "pcl,12", "]", "0xd403", "ld", "r11", ",", "[", "pcl,12", "]", "0x170c", "700b", "j_s", "[", "r12", "]", "0x7c00", "nop_s", "0x78e0", "The", "fastest", "trampoline", "to", "execute", "for", "trampolines", "within", "+-8KB", "of", "CTX", "would", "be", ":", "add2", "r11", ",", "pcl", ",", "s12", "j", "[", "limm", "]", "0x20200f80", "limm", "and", "that", "would", "also", "be", "faster", "to", "write", "to", "the", "stack", "by", "computing", "the", "offset", "from", "CTX", "to", "TRAMP", "at", "compile", "time", ".", "However", ",", "it", "would", "really", "be", "better", "to", "get", "rid", "of", "the", "high", "cost", "of", "cache", "invalidation", "when", "generating", "trampolines", ",", "which", "requires", "that", "the", "code", "part", "of", "trampolines", "stays", "constant", ",", "and", "additionally", "either", "-", "making", "sure", "that", "no", "executable", "code", "but", "trampolines", "is", "on", "the", "stack", ",", "no", "icache", "entries", "linger", "for", "the", "area", "of", "the", "stack", "from", "when", "before", "the", "stack", "was", "allocated", ",", "and", "allocating", "trampolines", "in", "trampoline-only", "cache", "lines", "or", "-", "allocate", "trampolines", "fram", "a", "special", "pool", "of", "pre-allocated", "trampolines", "."], "TS_V_token": ["arc", "0", "8", "12", "0", "0"], "File": "arc", "Func": "arc_initialize_trampoline", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33695, "Length": 96}
{"ground_truth": ["<s>", "int", "arc_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "if", "(", "!", "cfun", "->", "machine", "->", "frame_info", ".", "initialized", ")", "arc_compute_frame_size", "(", ")", ";", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", "{", "return", "(", "cfun", "->", "machine", "->", "frame_info", ".", "extra_size", "+", "cfun", "->", "machine", "->", "frame_info", ".", "reg_size", ")", ";", "}", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "{", "return", "(", "cfun", "->", "machine", "->", "frame_info", ".", "total_size", "-", "cfun", "->", "machine", "->", "frame_info", ".", "pretend_size", ")", ";", "}", "if", "(", "(", "from", "==", "FRAME_POINTER_REGNUM", ")", "&&", "(", "to", "==", "STACK_POINTER_REGNUM", ")", ")", "{", "return", "(", "cfun", "->", "machine", "->", "frame_info", ".", "total_size", "-", "(", "cfun", "->", "machine", "->", "frame_info", ".", "pretend_size", "+", "cfun", "->", "machine", "->", "frame_info", ".", "extra_size", "+", "cfun", "->", "machine", "->", "frame_info", ".", "reg_size", ")", ")", ";", "}", "if", "(", "(", "from", "==", "FRAME_POINTER_REGNUM", ")", "&&", "(", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", ")", "return", "0", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>"], "natrual_language": ["Define", "the", "offset", "between", "two", "registers", ",", "one", "to", "be", "eliminated", ",", "and", "the", "other", "its", "replacement", ",", "at", "the", "start", "of", "a", "routine", "."], "TS_V_token": ["arc", "0"], "File": "arc", "Func": "arc_initial_elimination_offset", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33696, "Length": 162}
{"ground_truth": ["<s>", "void", "arc_init_expanders", "(", "void", ")", "{", "init_machine_status", "=", "arc_init_machine_status", ";", "}", "</s>"], "natrual_language": ["Implements", "INIT_EXPANDERS", ".", "We", "just", "set", "up", "to", "call", "the", "above", "function", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_init_expanders", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33697, "Length": 11}
{"ground_truth": ["<s>", "static", "struct", "machine_function", "*", "arc_init_machine_status", "(", "void", ")", "{", "struct", "machine_function", "*", "machine", ";", "machine", "=", "ggc_cleared_alloc", "<", "machine_function", ">", "(", ")", ";", "machine", "->", "fn_type", "=", "ARC_FUNCTION_UNKNOWN", ";", "return", "machine", ";", "}", "</s>"], "natrual_language": ["The", "usual", ";", "we", "set", "up", "our", "machine_function", "data", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_init_machine_status", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33698, "Length": 33}
{"ground_truth": ["<s>", "static", "void", "arc_init_reg_tables", "(", "void", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "NUM_MACHINE_MODES", ";", "i", "++", ")", "{", "machine_mode", "m", "=", "(", "machine_mode", ")", "i", ";", "switch", "(", "GET_MODE_CLASS", "(", "m", ")", ")", "{", "case", "MODE_INT", ":", "case", "MODE_PARTIAL_INT", ":", "case", "MODE_COMPLEX_INT", ":", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "<=", "4", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "S_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "8", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "D_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "16", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "T_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "32", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "O_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "case", "MODE_FLOAT", ":", "case", "MODE_COMPLEX_FLOAT", ":", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "<=", "4", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "SF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "8", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "DF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "16", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "TF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "32", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "OF_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "case", "MODE_VECTOR_INT", ":", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "4", ")", "arc_mode_class", "[", "i", "]", "=", "(", "1", "<<", "(", "int", ")", "S_MODE", ")", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "m", ")", "==", "8", ")", "arc_mode_class", "[", "i", "]", "=", "(", "1", "<<", "(", "int", ")", "D_MODE", ")", ";", "else", "arc_mode_class", "[", "i", "]", "=", "(", "1", "<<", "(", "int", ")", "V_MODE", ")", ";", "break", ";", "case", "MODE_CC", ":", "default", ":", "if", "(", "i", "==", "(", "int", ")", "CCmode", "||", "i", "==", "(", "int", ")", "CC_ZNmode", "||", "i", "==", "(", "int", ")", "CC_Zmode", "||", "i", "==", "(", "int", ")", "CC_Cmode", "||", "i", "==", "CC_FP_GTmode", "||", "i", "==", "CC_FP_GEmode", "||", "i", "==", "CC_FP_ORDmode", "||", "i", "==", "CC_FPUmode", "||", "i", "==", "CC_FPUEmode", "||", "i", "==", "CC_FPU_UNEQmode", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "C_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "}", "}", "}", "</s>"], "natrual_language": ["Initialize", "the", "arc_mode_class", "array", "."], "TS_V_token": ["arc", "0", "4", "1", "8", "1", "16", "1", "32", "1", "0", "4", "1", "8", "1", "16", "1", "32", "1", "0", "4", "1", "8", "1", "1", "1", "0"], "File": "arc", "Func": "arc_init_reg_tables", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33699, "Length": 400}
{"ground_truth": ["<s>", "static", "int", "arc_insn_cost", "(", "rtx_insn", "*", "insn", ",", "bool", "speed", ")", "{", "int", "cost", ";", "if", "(", "recog_memoized", "(", "insn", ")", "<", "0", ")", "return", "0", ";", "if", "(", "!", "speed", ")", "return", "get_attr_length", "(", "insn", ")", ";", "cost", "=", "get_attr_cost", "(", "insn", ")", ";", "if", "(", "cost", ">", "0", ")", "return", "cost", ";", "enum", "attr_type", "type", "=", "get_attr_type", "(", "insn", ")", ";", "switch", "(", "type", ")", "{", "case", "TYPE_LOAD", ":", "case", "TYPE_STORE", ":", "cost", "=", "COSTS_N_INSNS", "(", "2", ")", ";", "break", ";", "default", ":", "cost", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "break", ";", "}", "return", "cost", ";", "}", "</s>"], "natrual_language": ["Helper", "for", "INSN_COST", ".", "Per", "Segher", "Boessenkool", ":", "rtx_costs", "computes", "the", "cost", "for", "any", "rtx", "(", "an", "insn", ",", "a", "set", ",", "a", "set", "source", ",", "any", "random", "piece", "of", "one", ")", ".", "set_src_cost", ",", "set_rtx_cost", ",", "etc", ".", "are", "helper", "functions", "that", "use", "that", ".", "Those", "functions", "do", "not", "work", "for", "parallels", ".", "Also", ",", "costs", "are", "not", "additive", "like", "this", "simplified", "model", "assumes", ".", "Also", ",", "more", "complex", "backends", "tend", "to", "miss", "many", "cases", "in", "their", "rtx_costs", "function", ".", "Many", "passes", "that", "want", "costs", "want", "to", "know", "the", "cost", "of", "a", "full", "insn", ".", "Like", "combine", ".", "That", "'s", "why", "I", "created", "insn_cost", ":", "it", "solves", "all", "of", "the", "above", "problems", "."], "TS_V_token": ["arc", "0", "0", "0", "2", "1"], "File": "arc", "Func": "arc_insn_cost", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33700, "Length": 99}
{"ground_truth": ["<s>", "static", "void", "arc_internal_label", "(", "FILE", "*", "stream", ",", "const", "char", "*", "prefix", ",", "unsigned", "long", "labelno", ")", "{", "if", "(", "cfun", ")", "arc_ccfsm_at_label", "(", "prefix", ",", "labelno", ",", "&", "arc_ccfsm_current", ")", ";", "default_internal_label", "(", "stream", ",", "prefix", ",", "labelno", ")", ";", "}", "</s>"], "natrual_language": ["This", "is", "how", "to", "output", "a", "definition", "of", "an", "internal", "numbered", "label", "where", "PREFIX", "is", "the", "class", "of", "label", "and", "NUM", "is", "the", "number", "within", "the", "class", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_internal_label", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33701, "Length": 42}
{"ground_truth": ["<s>", "static", "const", "char", "*", "arc_invalid_within_doloop", "(", "const", "rtx_insn", "*", "insn", ")", "{", "if", "(", "CALL_P", "(", "insn", ")", ")", "return", "\"Function call in the loop.\"", ";", "return", "NULL", ";", "}", "</s>"], "natrual_language": ["NULL", "if", "INSN", "insn", "is", "valid", "within", "a", "low-overhead", "loop", ".", "Otherwise", "return", "why", "doloop", "can", "not", "be", "applied", "."], "TS_V_token": ["arc", "\"Function call in the loop.\""], "File": "arc", "Func": "arc_invalid_within_doloop", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33702, "Length": 26}
{"ground_truth": ["<s>", "static", "bool", "arc_in_small_data_p", "(", "const_tree", "decl", ")", "{", "HOST_WIDE_INT", "size", ";", "tree", "attr", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "!=", "VAR_DECL", ")", "return", "false", ";", "if", "(", "TARGET_NO_SDATA_SET", ")", "return", "false", ";", "if", "(", "DECL_WEAK", "(", "decl", ")", ")", "return", "false", ";", "if", "(", "TREE_READONLY", "(", "decl", ")", ")", "return", "false", ";", "if", "(", "!", "TARGET_VOLATILE_CACHE_SET", "&&", "TREE_THIS_VOLATILE", "(", "decl", ")", ")", "return", "false", ";", "attr", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "if", "(", "lookup_attribute", "(", "\"uncached\"", ",", "attr", ")", ")", "return", "false", ";", "attr", "=", "DECL_ATTRIBUTES", "(", "decl", ")", ";", "if", "(", "lookup_attribute", "(", "\"aux\"", ",", "attr", ")", ")", "return", "false", ";", "if", "(", "DECL_SECTION_NAME", "(", "decl", ")", "!=", "0", ")", "{", "const", "char", "*", "name", "=", "DECL_SECTION_NAME", "(", "decl", ")", ";", "if", "(", "strcmp", "(", "name", ",", "\".sdata\"", ")", "==", "0", "||", "strcmp", "(", "name", ",", "\".sbss\"", ")", "==", "0", ")", "return", "true", ";", "}", "else", "if", "(", "TREE_PUBLIC", "(", "decl", ")", ")", "{", "size", "=", "int_size_in_bytes", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "return", "(", "size", ">", "0", "&&", "size", "<=", "g_switch_value", ")", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_IN_SMALL_DATA_P", ".", "Return", "true", "if", "it", "would", "be", "safe", "to", "access", "DECL", "using", "%", "gp_rel", "(", "...", ")", "(", "$", "gp", ")", "."], "TS_V_token": ["arc", "\"uncached\"", "\"aux\"", "0", "\".sdata\"", "0", "\".sbss\"", "0", "0"], "File": "arc", "Func": "arc_in_small_data_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33703, "Length": 186}
{"ground_truth": ["<s>", "static", "bool", "arc_is_aux_reg_p", "(", "rtx", "pat", ")", "{", "tree", "attrs", "=", "NULL_TREE", ";", "tree", "addr", ";", "if", "(", "!", "MEM_P", "(", "pat", ")", ")", "return", "false", ";", "addr", "=", "MEM_EXPR", "(", "pat", ")", ";", "if", "(", "!", "addr", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "addr", ")", "==", "VAR_DECL", ")", "attrs", "=", "DECL_ATTRIBUTES", "(", "addr", ")", ";", "else", "if", "(", "TREE_CODE", "(", "addr", ")", "==", "MEM_REF", ")", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "TREE_OPERAND", "(", "addr", ",", "0", ")", ")", ")", ";", "else", "return", "false", ";", "if", "(", "lookup_attribute", "(", "\"aux\"", ",", "attrs", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Return", "TRUE", "if", "PAT", "is", "accessing", "an", "aux-reg", "."], "TS_V_token": ["arc", "0", "\"aux\""], "File": "arc", "Func": "arc_is_aux_reg_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33704, "Length": 103}
{"ground_truth": ["<s>", "bool", "arc_is_jli_call_p", "(", "rtx", "pat", ")", "{", "tree", "attrs", ";", "tree", "decl", "=", "SYMBOL_REF_DECL", "(", "pat", ")", ";", "if", "(", "!", "decl", "||", "!", "SYMBOL_REF_FUNCTION_P", "(", "pat", ")", "||", "!", "TREE_PUBLIC", "(", "decl", ")", ")", "return", "false", ";", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "if", "(", "lookup_attribute", "(", "\"jli_always\"", ",", "attrs", ")", ")", "return", "true", ";", "if", "(", "lookup_attribute", "(", "\"jli_fixed\"", ",", "attrs", ")", ")", "return", "true", ";", "return", "TARGET_JLI_ALWAYS", ";", "}", "</s>"], "natrual_language": ["Return", "nonzero", "if", "a", "jli", "call", "should", "be", "generated", "for", "a", "call", "from", "the", "current", "function", "to", "DECL", "."], "TS_V_token": ["arc", "\"jli_always\"", "\"jli_fixed\""], "File": "arc", "Func": "arc_is_jli_call_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33705, "Length": 76}
{"ground_truth": ["<s>", "bool", "arc_is_longcall_p", "(", "rtx", "sym_ref", ")", "{", "if", "(", "GET_CODE", "(", "sym_ref", ")", "!=", "SYMBOL_REF", ")", "return", "false", ";", "return", "(", "SYMBOL_REF_LONG_CALL_P", "(", "sym_ref", ")", "||", "(", "TARGET_LONG_CALLS_SET", "&&", "!", "SYMBOL_REF_SHORT_CALL_P", "(", "sym_ref", ")", "&&", "!", "SYMBOL_REF_MEDIUM_CALL_P", "(", "sym_ref", ")", ")", ")", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "a", "32", "bit", "``", "long_call", "''", "should", "be", "generated", "for", "this", "calling", "SYM_REF", ".", "We", "generate", "a", "long_call", "if", "the", "function", ":", "a.", "has", "an", "__attribute__", "(", "(", "long", "call", ")", ")", "or", "b.", "the", "-mlong-calls", "command", "line", "switch", "has", "been", "specified", "However", "we", "do", "not", "generate", "a", "long", "call", "if", "the", "function", "has", "an", "__attribute__", "(", "(", "short_call", ")", ")", "or", "__attribute__", "(", "(", "medium_call", ")", ")", "This", "function", "will", "be", "called", "by", "C", "fragments", "contained", "in", "the", "machine", "description", "file", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_is_longcall_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33706, "Length": 44}
{"ground_truth": ["<s>", "bool", "arc_is_secure_call_p", "(", "rtx", "pat", ")", "{", "tree", "attrs", ";", "tree", "decl", "=", "SYMBOL_REF_DECL", "(", "pat", ")", ";", "if", "(", "!", "decl", ")", "return", "false", ";", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "if", "(", "lookup_attribute", "(", "\"secure_call\"", ",", "attrs", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Return", "nonzero", "if", "the", "symbol", "is", "a", "secure", "function", "."], "TS_V_token": ["arc", "\"secure_call\""], "File": "arc", "Func": "arc_is_secure_call_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33707, "Length": 52}
{"ground_truth": ["<s>", "bool", "arc_is_shortcall_p", "(", "rtx", "sym_ref", ")", "{", "if", "(", "GET_CODE", "(", "sym_ref", ")", "!=", "SYMBOL_REF", ")", "return", "false", ";", "return", "(", "SYMBOL_REF_SHORT_CALL_P", "(", "sym_ref", ")", "||", "(", "!", "TARGET_LONG_CALLS_SET", "&&", "!", "TARGET_MEDIUM_CALLS", "&&", "!", "SYMBOL_REF_LONG_CALL_P", "(", "sym_ref", ")", "&&", "!", "SYMBOL_REF_MEDIUM_CALL_P", "(", "sym_ref", ")", ")", ")", ";", "}", "</s>"], "natrual_language": ["Likewise", "for", "short", "calls", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_is_shortcall_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33708, "Length": 48}
{"ground_truth": ["<s>", "bool", "arc_is_uncached_mem_p", "(", "rtx", "pat", ")", "{", "tree", "attrs", "=", "NULL_TREE", ";", "tree", "addr", ";", "if", "(", "!", "MEM_P", "(", "pat", ")", ")", "return", "false", ";", "addr", "=", "MEM_EXPR", "(", "pat", ")", ";", "if", "(", "!", "addr", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "addr", ")", "==", "MEM_REF", "||", "TREE_CODE", "(", "addr", ")", "==", "VAR_DECL", ")", "{", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "addr", ")", ")", ";", "if", "(", "lookup_attribute", "(", "\"uncached\"", ",", "attrs", ")", ")", "return", "true", ";", "}", "if", "(", "TREE_CODE", "(", "addr", ")", "==", "MEM_REF", ")", "{", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "TREE_OPERAND", "(", "addr", ",", "0", ")", ")", ")", ";", "if", "(", "lookup_attribute", "(", "\"uncached\"", ",", "attrs", ")", ")", "return", "true", ";", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "TREE_OPERAND", "(", "addr", ",", "1", ")", ")", ")", ";", "if", "(", "lookup_attribute", "(", "\"uncached\"", ",", "attrs", ")", ")", "return", "true", ";", "}", "while", "(", "handled_component_p", "(", "addr", ")", ")", "{", "if", "(", "TREE_CODE", "(", "addr", ")", "==", "COMPONENT_REF", ")", "{", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "addr", ")", ")", ";", "if", "(", "lookup_attribute", "(", "\"uncached\"", ",", "attrs", ")", ")", "return", "true", ";", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "TREE_OPERAND", "(", "addr", ",", "0", ")", ")", ")", ";", "if", "(", "lookup_attribute", "(", "\"uncached\"", ",", "attrs", ")", ")", "return", "true", ";", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "TREE_OPERAND", "(", "addr", ",", "1", ")", ")", ")", ";", "if", "(", "lookup_attribute", "(", "\"uncached\"", ",", "attrs", ")", ")", "return", "true", ";", "}", "addr", "=", "TREE_OPERAND", "(", "addr", ",", "0", ")", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Return", "TRUE", "if", "PAT", "is", "a", "memory", "addressing", "an", "uncached", "data", "."], "TS_V_token": ["arc", "\"uncached\"", "0", "\"uncached\"", "1", "\"uncached\"", "\"uncached\"", "0", "\"uncached\"", "1", "\"uncached\"", "0"], "File": "arc", "Func": "arc_is_uncached_mem_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33709, "Length": 255}
{"ground_truth": ["<s>", "int", "arc_label_align", "(", "rtx_insn", "*", "label", ")", "{", "if", "(", "align_labels", ".", "levels", "[", "0", "]", ".", "log", "<", "1", ")", "{", "rtx_insn", "*", "next", "=", "next_nonnote_nondebug_insn", "(", "label", ")", ";", "if", "(", "INSN_P", "(", "next", ")", "&&", "recog_memoized", "(", "next", ")", ">=", "0", ")", "return", "1", ";", "}", "return", "align_labels", ".", "levels", "[", "0", "]", ".", "log", ";", "}", "</s>"], "natrual_language": ["Oddly", "enough", ",", "sometimes", "we", "get", "a", "zero", "overhead", "loop", "that", "branch", "shortening", "does", "n't", "think", "is", "a", "loop", "-", "observed", "with", "compile/pr24883.c", "-O3", "-fomit-frame-pointer", "-funroll-loops", ".", "Make", "sure", "to", "include", "the", "alignment", "visible", "for", "branch", "shortening", "(", "we", "actually", "align", "the", "loop", "insn", "before", "it", ",", "but", "that", "is", "equivalent", "since", "the", "loop", "insn", "is", "4", "byte", "long", ".", ")"], "TS_V_token": ["arc", "0", "1", "0", "1", "0"], "File": "arc", "Func": "arc_label_align", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33710, "Length": 60}
{"ground_truth": ["<s>", "bool", "arc_legitimate_constant_p", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST", ":", "if", "(", "flag_pic", ")", "{", "if", "(", "arc_legitimate_pic_addr_p", "(", "x", ")", ")", "return", "true", ";", "}", "return", "arc_legitimate_constant_p", "(", "mode", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "case", "SYMBOL_REF", ":", "if", "(", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ")", "return", "false", ";", "case", "LABEL_REF", ":", "if", "(", "flag_pic", ")", "return", "false", ";", "case", "CONST_INT", ":", "case", "CONST_DOUBLE", ":", "return", "true", ";", "case", "NEG", ":", "return", "arc_legitimate_constant_p", "(", "mode", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "case", "PLUS", ":", "case", "MINUS", ":", "{", "bool", "t1", "=", "arc_legitimate_constant_p", "(", "mode", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "bool", "t2", "=", "arc_legitimate_constant_p", "(", "mode", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "return", "(", "t1", "&&", "t2", ")", ";", "}", "case", "CONST_VECTOR", ":", "switch", "(", "mode", ")", "{", "case", "E_V2HImode", ":", "return", "TARGET_PLUS_DMPY", ";", "case", "E_V2SImode", ":", "case", "E_V4HImode", ":", "return", "TARGET_PLUS_QMACW", ";", "default", ":", "return", "false", ";", "}", "case", "UNSPEC", ":", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "case", "UNSPEC_TLS_GD", ":", "case", "UNSPEC_TLS_OFF", ":", "case", "UNSPEC_TLS_IE", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "default", ":", "fatal_insn", "(", "\"unrecognized supposed constant\"", ",", "x", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>"], "natrual_language": ["Determine", "if", "a", "given", "RTX", "is", "a", "valid", "constant", ".", "We", "already", "know", "this", "satisfies", "CONSTANT_P", "."], "TS_V_token": ["arc", "0", "0", "0", "1", "1", "\"unrecognized supposed constant\""], "File": "arc", "Func": "arc_legitimate_constant_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33711, "Length": 218}
{"ground_truth": ["<s>", "bool", "arc_legitimate_pic_addr_p", "(", "rtx", "addr", ")", "{", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "CONST", ")", "return", "false", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "!=", "CONST_INT", ")", "return", "false", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "UNSPEC", "||", "XVECLEN", "(", "addr", ",", "0", ")", "!=", "1", ")", "return", "false", ";", "if", "(", "XINT", "(", "addr", ",", "1", ")", "!=", "ARC_UNSPEC_GOT", "&&", "XINT", "(", "addr", ",", "1", ")", "!=", "ARC_UNSPEC_GOTOFF", "&&", "XINT", "(", "addr", ",", "1", ")", "!=", "ARC_UNSPEC_GOTOFFPC", "&&", "XINT", "(", "addr", ",", "1", ")", "!=", "UNSPEC_TLS_GD", "&&", "XINT", "(", "addr", ",", "1", ")", "!=", "UNSPEC_TLS_IE", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "XVECEXP", "(", "addr", ",", "0", ",", "0", ")", ")", "!=", "SYMBOL_REF", "&&", "GET_CODE", "(", "XVECEXP", "(", "addr", ",", "0", ",", "0", ")", ")", "!=", "LABEL_REF", ")", "return", "false", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "ADDR", "is", "a", "valid", "pic", "address", ".", "A", "valid", "pic", "address", "on", "arc", "should", "look", "like", "const", "(", "unspec", "(", "SYMBOL_REF/LABEL", ")", "(", "ARC_UNSPEC_GOTOFF/ARC_UNSPEC_GOT", ")", ")"], "TS_V_token": ["arc", "0", "1", "0", "0", "1", "1", "1", "1", "1", "1", "0", "0", "0", "0"], "File": "arc", "Func": "arc_legitimate_pic_addr_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33712, "Length": 173}
{"ground_truth": ["<s>", "static", "rtx", "arc_legitimize_address_0", "(", "rtx", "x", ",", "rtx", "oldx", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ")", "{", "rtx", "addr", ",", "inner", ";", "addr", "=", "x", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "CONST", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "&&", "(", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "SYMBOL_REF", "&&", "!", "SYMBOL_REF_FUNCTION_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", "||", "(", "REG_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "&&", "(", "INTVAL", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "&", "252", ")", ")", ")", ")", "{", "HOST_WIDE_INT", "offs", ",", "upper", ";", "int", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "offs", "=", "INTVAL", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ";", "upper", "=", "(", "offs", "+", "256", "*", "size", ")", "&", "~", "511", "*", "size", ";", "inner", "=", "plus_constant", "(", "Pmode", ",", "XEXP", "(", "addr", ",", "0", ")", ",", "upper", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "inner", "=", "gen_rtx_CONST", "(", "Pmode", ",", "inner", ")", ";", "addr", "=", "plus_constant", "(", "Pmode", ",", "force_reg", "(", "Pmode", ",", "inner", ")", ",", "offs", "-", "upper", ")", ";", "x", "=", "addr", ";", "}", "else", "if", "(", "GET_CODE", "(", "addr", ")", "==", "SYMBOL_REF", "&&", "!", "SYMBOL_REF_FUNCTION_P", "(", "addr", ")", ")", "x", "=", "force_reg", "(", "Pmode", ",", "x", ")", ";", "if", "(", "memory_address_p", "(", "(", "machine_mode", ")", "mode", ",", "x", ")", ")", "return", "x", ";", "return", "NULL_RTX", ";", "}", "</s>"], "natrual_language": ["This", "is", "like", "the", "hook", ",", "but", "returns", "NULL", "when", "it", "ca", "n't", "/", "wo", "n't", "generate", "a", "legitimate", "address", "."], "TS_V_token": ["arc", "0", "1", "0", "0", "0", "1", "252", "1", "256", "511", "0"], "File": "arc", "Func": "arc_legitimize_address_0", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33713, "Length": 256}
{"ground_truth": ["<s>", "static", "rtx", "arc_legitimize_pic_address", "(", "rtx", "addr", ")", "{", "if", "(", "!", "flag_pic", ")", "return", "addr", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "UNSPEC", ":", "switch", "(", "XINT", "(", "addr", ",", "1", ")", ")", "{", "case", "ARC_UNSPEC_GOT", ":", "case", "ARC_UNSPEC_GOTOFFPC", ":", "addr", "=", "XVECEXP", "(", "addr", ",", "0", ",", "0", ")", ";", "break", ";", "default", ":", "return", "addr", ";", "}", "case", "SYMBOL_REF", ":", "if", "(", "SYMBOL_REF_TLS_MODEL", "(", "addr", ")", ")", "return", "addr", ";", "if", "(", "!", "arc_symbol_binds_local_p", "(", "addr", ")", ")", "return", "gen_const_mem", "(", "Pmode", ",", "arc_unspec_offset", "(", "addr", ",", "ARC_UNSPEC_GOT", ")", ")", ";", "case", "LABEL_REF", ":", "return", "arc_unspec_offset", "(", "addr", ",", "ARC_UNSPEC_GOTOFFPC", ")", ";", "default", ":", "break", ";", "}", "return", "addr", ";", "}", "</s>"], "natrual_language": ["Legitimize", "a", "pic", "address", "reference", "in", "ORIG", ".", "The", "return", "value", "is", "the", "legitimated", "address", ".", "If", "OLDX", "is", "non-zero", ",", "it", "is", "the", "target", "to", "assign", "the", "address", "to", "first", "."], "TS_V_token": ["arc", "1", "0", "0"], "File": "arc", "Func": "arc_legitimize_pic_address", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33714, "Length": 116}
{"ground_truth": ["<s>", "static", "rtx", "arc_legitimize_tls_address", "(", "rtx", "addr", ",", "enum", "tls_model", "model", ")", "{", "rtx", "tmp", ";", "if", "(", "!", "flag_pic", "&&", "model", "==", "TLS_MODEL_LOCAL_DYNAMIC", ")", "model", "=", "TLS_MODEL_LOCAL_EXEC", ";", "gcc_assert", "(", "arc_tp_regno", "!=", "-", "1", ")", ";", "switch", "(", "model", ")", "{", "case", "TLS_MODEL_GLOBAL_DYNAMIC", ":", "tmp", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_move_insn", "(", "tmp", ",", "arc_unspec_offset", "(", "addr", ",", "UNSPEC_TLS_GD", ")", ")", ";", "return", "arc_call_tls_get_addr", "(", "tmp", ")", ";", "case", "TLS_MODEL_LOCAL_DYNAMIC", ":", "rtx", "base", ";", "tree", "decl", ";", "const", "char", "*", "base_name", ";", "decl", "=", "SYMBOL_REF_DECL", "(", "addr", ")", ";", "base_name", "=", "DTPOFF_ZERO_SYM", ";", "if", "(", "decl", "&&", "bss_initializer_p", "(", "decl", ")", ")", "base_name", "=", "\".tbss\"", ";", "base", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "base_name", ")", ";", "tmp", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_move_insn", "(", "tmp", ",", "arc_unspec_offset", "(", "base", ",", "UNSPEC_TLS_GD", ")", ")", ";", "base", "=", "arc_call_tls_get_addr", "(", "tmp", ")", ";", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "force_reg", "(", "Pmode", ",", "base", ")", ",", "arc_unspec_offset", "(", "addr", ",", "UNSPEC_TLS_OFF", ")", ")", ";", "case", "TLS_MODEL_INITIAL_EXEC", ":", "addr", "=", "arc_unspec_offset", "(", "addr", ",", "UNSPEC_TLS_IE", ")", ";", "addr", "=", "copy_to_mode_reg", "(", "Pmode", ",", "gen_const_mem", "(", "Pmode", ",", "addr", ")", ")", ";", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "arc_tp_regno", ")", ",", "addr", ")", ";", "case", "TLS_MODEL_LOCAL_EXEC", ":", "addr", "=", "arc_unspec_offset", "(", "addr", ",", "UNSPEC_TLS_OFF", ")", ";", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "arc_tp_regno", ")", ",", "addr", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Return", "a", "legitimized", "address", "for", "ADDR", ",", "which", "is", "a", "SYMBOL_REF", "with", "tls_model", "MODEL", "."], "TS_V_token": ["arc", "1", "\".tbss\""], "File": "arc", "Func": "arc_legitimize_tls_address", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33715, "Length": 238}
{"ground_truth": ["<s>", "bool", "arc_lra_p", "(", "void", ")", "{", "return", "arc_lra_flag", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "we", "use", "LRA", "instead", "of", "reload", "pass", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_lra_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33716, "Length": 10}
{"ground_truth": ["<s>", "static", "int", "arc_memory_move_cost", "(", "machine_mode", "mode", ",", "reg_class_t", "rclass", "ATTRIBUTE_UNUSED", ",", "bool", "in", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_WORD", ")", "||", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_WORD", "*", "2", ")", "&&", "TARGET_LL64", ")", ")", "return", "6", ";", "return", "(", "2", "*", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_MEMORY_MOVE_COST", "."], "TS_V_token": ["arc", "2", "6", "2"], "File": "arc", "Func": "arc_memory_move_cost", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33717, "Length": 56}
{"ground_truth": ["<s>", "static", "bool", "arc_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "return", "(", "GET_MODE_CLASS", "(", "mode1", ")", "==", "MODE_INT", "&&", "GET_MODE_CLASS", "(", "mode2", ")", "==", "MODE_INT", "&&", "GET_MODE_SIZE", "(", "mode1", ")", "<=", "UNITS_PER_WORD", "&&", "GET_MODE_SIZE", "(", "mode2", ")", "<=", "UNITS_PER_WORD", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_MODES_TIEABLE_P", ".", "Tie", "QI/HI/SI", "modes", "together", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_modes_tieable_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33718, "Length": 43}
{"ground_truth": ["<s>", "static", "bool", "arc_mode_dependent_address_p", "(", "const_rtx", "addr", ",", "addr_space_t", ")", "{", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "(", "addr", ")", ",", "0", ")", ")", "==", "MULT", ")", "return", "true", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Return", "true", "iff", "ADDR", "(", "a", "legitimate", "address", "expression", ")", "has", "an", "effect", "that", "depends", "on", "the", "machine", "mode", "it", "is", "used", "for", "."], "TS_V_token": ["arc", "0"], "File": "arc", "Func": "arc_mode_dependent_address_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33719, "Length": 40}
{"ground_truth": ["<s>", "static", "bool", "arc_must_save_register", "(", "int", "regno", ",", "struct", "function", "*", "func", ",", "bool", "special_p", ")", "{", "unsigned", "int", "fn_type", "=", "arc_compute_function_type", "(", "func", ")", ";", "bool", "irq_auto_save_p", "=", "(", "(", "irq_ctrl_saved", ".", "irq_save_last_reg", ">=", "regno", ")", "&&", "ARC_AUTO_IRQ_P", "(", "fn_type", ")", ")", ";", "bool", "firq_auto_save_p", "=", "ARC_FAST_INTERRUPT_P", "(", "fn_type", ")", ";", "switch", "(", "rgf_banked_register_count", ")", "{", "case", "4", ":", "firq_auto_save_p", "&=", "(", "regno", "<", "4", ")", ";", "break", ";", "case", "8", ":", "firq_auto_save_p", "&=", "(", "(", "regno", "<", "4", ")", "||", "(", "(", "regno", ">", "11", ")", "&&", "(", "regno", "<", "16", ")", ")", ")", ";", "break", ";", "case", "16", ":", "firq_auto_save_p", "&=", "(", "(", "regno", "<", "4", ")", "||", "(", "(", "regno", ">", "9", ")", "&&", "(", "regno", "<", "16", ")", ")", "||", "(", "(", "regno", ">", "25", ")", "&&", "(", "regno", "<", "29", ")", ")", "||", "(", "(", "regno", ">", "29", ")", "&&", "(", "regno", "<", "32", ")", ")", ")", ";", "break", ";", "case", "32", ":", "firq_auto_save_p", "&=", "(", "regno", "!=", "29", ")", "&&", "(", "regno", "<", "32", ")", ";", "break", ";", "default", ":", "firq_auto_save_p", "=", "false", ";", "break", ";", "}", "switch", "(", "regno", ")", "{", "case", "ILINK1_REG", ":", "case", "RETURN_ADDR_REGNUM", ":", "case", "STACK_POINTER_REGNUM", ":", "return", "false", ";", "case", "R30_REG", ":", "if", "(", "!", "TARGET_V2", ")", "return", "false", ";", "break", ";", "case", "R40_REG", ":", "case", "R41_REG", ":", "case", "R42_REG", ":", "case", "R43_REG", ":", "case", "R44_REG", ":", "if", "(", "TARGET_DPFP", "&&", "!", "special_p", ")", "return", "false", ";", "case", "R32_REG", ":", "case", "R33_REG", ":", "case", "R34_REG", ":", "case", "R35_REG", ":", "case", "R36_REG", ":", "case", "R37_REG", ":", "case", "R38_REG", ":", "case", "R39_REG", ":", "case", "R45_REG", ":", "case", "R46_REG", ":", "case", "R47_REG", ":", "case", "R48_REG", ":", "case", "R49_REG", ":", "case", "R50_REG", ":", "case", "R51_REG", ":", "case", "R52_REG", ":", "case", "R53_REG", ":", "case", "R54_REG", ":", "case", "R55_REG", ":", "case", "R56_REG", ":", "case", "R57_REG", ":", "if", "(", "ARC_INTERRUPT_P", "(", "fn_type", ")", "&&", "(", "df_regs_ever_live_p", "(", "RETURN_ADDR_REGNUM", ")", "||", "df_regs_ever_live_p", "(", "regno", ")", ")", "&&", "!", "fixed_regs", "[", "regno", "]", ")", "return", "true", ";", "return", "false", ";", "case", "R58_REG", ":", "case", "R59_REG", ":", "if", "(", "ARC_INTERRUPT_P", "(", "fn_type", ")", "&&", "(", "df_regs_ever_live_p", "(", "RETURN_ADDR_REGNUM", ")", "||", "df_regs_ever_live_p", "(", "regno", ")", ")", "&&", "(", "(", "!", "fixed_regs", "[", "regno", "]", "&&", "!", "special_p", ")", "||", "(", "TARGET_MUL64_SET", "&&", "special_p", ")", ")", ")", "return", "true", ";", "return", "false", ";", "case", "61", ":", "case", "62", ":", "case", "63", ":", "return", "false", ";", "case", "HARD_FRAME_POINTER_REGNUM", ":", "if", "(", "arc_frame_pointer_needed", "(", ")", ")", "return", "false", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "(", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", "||", "(", "ARC_INTERRUPT_P", "(", "fn_type", ")", "&&", "(", "df_regs_ever_live_p", "(", "RETURN_ADDR_REGNUM", ")", "||", "df_regs_ever_live_p", "(", "regno", ")", ")", ")", ")", "&&", "!", "irq_auto_save_p", "&&", "!", "firq_auto_save_p", ")", "return", "true", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Tell", "prologue", "and", "epilogue", "if", "register", "REGNO", "should", "be", "saved", "/", "restored", ".", "The", "return", "address", ",", "stack", "pointer", "and", "frame", "pointer", "are", "treated", "separately", ".", "Do", "n't", "consider", "them", "here", ".", "Addition", "for", "pic", ":", "The", "gp", "register", "needs", "to", "be", "saved", "if", "the", "current", "function", "changes", "it", "to", "access", "gotoff", "variables", ".", "FIXME", ":", "This", "will", "not", "be", "needed", "if", "we", "used", "some", "arbitrary", "register", "instead", "of", "r26", "."], "TS_V_token": ["arc", "4", "4", "8", "4", "11", "16", "16", "4", "9", "16", "25", "29", "29", "32", "32", "29", "32", "61", "62", "63"], "File": "arc", "Func": "arc_must_save_register", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33720, "Length": 462}
{"ground_truth": ["<s>", "static", "bool", "arc_must_save_return_addr", "(", "struct", "function", "*", "func", ")", "{", "if", "(", "func", "->", "machine", "->", "frame_info", ".", "save_return_addr", ")", "return", "true", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "the", "return", "address", "must", "be", "saved", "in", "the", "current", "function", ",", "otherwise", "return", "false", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_must_save_return_addr", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33721, "Length": 27}
{"ground_truth": ["<s>", "bool", "arc_need_delay", "(", "rtx_insn", "*", "insn", ")", "{", "rtx_insn", "*", "next", ";", "if", "(", "!", "flag_delayed_branch", ")", "return", "false", ";", "if", "(", "NONJUMP_INSN_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", "&&", "(", "!", "(", "next", "=", "next_active_insn", "(", "insn", ")", ")", "||", "(", "(", "!", "NONJUMP_INSN_P", "(", "next", ")", "||", "GET_CODE", "(", "PATTERN", "(", "next", ")", ")", "!=", "SEQUENCE", ")", "&&", "arc_attr_type", "(", "next", ")", "==", "TYPE_RETURN", ")", ")", "&&", "(", "!", "TARGET_PAD_RETURN", "||", "(", "prev_active_insn", "(", "insn", ")", "&&", "prev_active_insn", "(", "prev_active_insn", "(", "insn", ")", ")", "&&", "prev_active_insn", "(", "prev_active_insn", "(", "prev_active_insn", "(", "insn", ")", ")", ")", ")", ")", ")", "return", "true", ";", "if", "(", "NONJUMP_INSN_P", "(", "insn", ")", "?", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SEQUENCE", ")", ":", "JUMP_P", "(", "insn", ")", "?", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "ADDR_VEC", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "ADDR_DIFF_VEC", ")", ":", "!", "CALL_P", "(", "insn", ")", ")", "return", "false", ";", "return", "num_delay_slots", "(", "insn", ")", "!=", "0", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "INSN", "is", "an", "instruction", "with", "a", "delay", "slot", "we", "may", "want", "to", "fill", "."], "TS_V_token": ["arc", "0"], "File": "arc", "Func": "arc_need_delay", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33722, "Length": 194}
{"ground_truth": ["<s>", "static", "bool", "arc_no_speculation_in_delay_slots_p", "(", ")", "{", "return", "true", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_NO_SPECULATION_IN_DELAY_SLOTS_P", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_no_speculation_in_delay_slots_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33723, "Length": 10}
{"ground_truth": ["<s>", "int", "arc_output_addsi", "(", "rtx", "*", "operands", ",", "bool", "cond_p", ",", "bool", "output_p", ")", "{", "char", "format", "[", "35", "]", ";", "int", "match", "=", "operands_match_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "int", "match2", "=", "operands_match_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ")", ";", "int", "intval", "=", "(", "REG_P", "(", "operands", "[", "2", "]", ")", "?", "1", ":", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", "?", "INTVAL", "(", "operands", "[", "2", "]", ")", ":", "0xbadc057", ")", ";", "int", "neg_intval", "=", "-", "intval", ";", "int", "short_0", "=", "satisfies_constraint_Rcq", "(", "operands", "[", "0", "]", ")", ";", "int", "short_p", "=", "(", "!", "cond_p", "&&", "short_0", "&&", "satisfies_constraint_Rcq", "(", "operands", "[", "1", "]", ")", ")", ";", "int", "ret", "=", "0", ";", "&&", "REGNO", "(", "OP", ")", "!=", "30", ")", "\\", "||", "!", "TARGET_V2", ")", ")", "if", "(", "output_p", ")", "\\", "output_asm_insn", "(", "FORMAT", ",", "operands", ")", ";", "\\", "return", "ret", ";", "\\", "}", "</s>"], "natrual_language": ["Emit", "code", "for", "an", "addsi3", "instruction", "with", "OPERANDS", ".", "COND_P", "indicates", "if", "this", "will", "use", "conditional", "execution", ".", "Return", "the", "length", "of", "the", "instruction", ".", "If", "OUTPUT_P", "is", "false", ",", "do", "n't", "actually", "output", "the", "instruction", ",", "just", "return", "its", "length", "."], "TS_V_token": ["arc", "35", "0", "1", "0", "2", "2", "1", "2", "2", "0xbadc057", "0", "1", "0", "30"], "File": "arc", "Func": "arc_output_addsi", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33724, "Length": 157}
{"ground_truth": ["<s>", "const", "char", "*", "arc_output_libcall", "(", "const", "char", "*", "fname", ")", "{", "unsigned", "len", "=", "strlen", "(", "fname", ")", ";", "static", "char", "buf", "[", "64", "]", ";", "gcc_assert", "(", "len", "<", "sizeof", "buf", "-", "35", ")", ";", "if", "(", "TARGET_LONG_CALLS_SET", "||", "(", "TARGET_MEDIUM_CALLS", "&&", "arc_ccfsm_cond_exec_p", "(", ")", ")", ")", "{", "if", "(", "flag_pic", ")", "sprintf", "(", "buf", ",", "\"add r12,pcl,@%s@pcl\\n\\tjl%%!%%* [r12]\"", ",", "fname", ")", ";", "else", "sprintf", "(", "buf", ",", "\"jl%%! @%s\"", ",", "fname", ")", ";", "}", "else", "sprintf", "(", "buf", ",", "\"bl%%!%%* @%s\"", ",", "fname", ")", ";", "return", "buf", ";", "}", "</s>"], "natrual_language": ["Output", "a", "library", "call", "to", "a", "function", "called", "FNAME", "that", "has", "been", "arranged", "to", "be", "local", "to", "any", "dso", "."], "TS_V_token": ["arc", "64", "35", "\"add r12,pcl,@%s@pcl\\n\\tjl%%!%%* [r12]\"", "\"jl%%! @%s\"", "\"bl%%!%%* @%s\""], "File": "arc", "Func": "arc_output_libcall", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33725, "Length": 87}
{"ground_truth": ["<s>", "static", "void", "arc_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", "thunk", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "const", "char", "*", "fnname", "=", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "thunk", ")", ")", ";", "int", "mi_delta", "=", "delta", ";", "const", "char", "*", "const", "mi_op", "=", "mi_delta", "<", "0", "?", "\"sub\"", ":", "\"add\"", ";", "int", "shift", "=", "0", ";", "int", "this_regno", "=", "aggregate_value_p", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "function", ")", ")", ",", "function", ")", "?", "1", ":", "0", ";", "rtx", "fnaddr", ";", "assemble_start_function", "(", "thunk", ",", "fnname", ")", ";", "if", "(", "mi_delta", "<", "0", ")", "mi_delta", "=", "-", "mi_delta", ";", "while", "(", "mi_delta", "!=", "0", ")", "{", "if", "(", "(", "mi_delta", "&", "(", "3", "<<", "shift", ")", ")", "==", "0", ")", "shift", "+=", "2", ";", "else", "{", "asm_fprintf", "(", "file", ",", "\"\\t%s\\t%s, %s, %d\\n\"", ",", "mi_op", ",", "reg_names", "[", "this_regno", "]", ",", "reg_names", "[", "this_regno", "]", ",", "mi_delta", "&", "(", "0xff", "<<", "shift", ")", ")", ";", "mi_delta", "&=", "~", "(", "0xff", "<<", "shift", ")", ";", "shift", "+=", "8", ";", "}", "}", "if", "(", "vcall_offset", "!=", "0", ")", "{", "asm_fprintf", "(", "file", ",", "\"\\tld\\t%s, [%s]\\n\"", ",", "ARC_TEMP_SCRATCH_REG", ",", "reg_names", "[", "this_regno", "]", ")", ";", "asm_fprintf", "(", "file", ",", "\"\\tadd\\t%s, %s, \"", "HOST_WIDE_INT_PRINT_DEC", "\"\\n\"", ",", "ARC_TEMP_SCRATCH_REG", ",", "ARC_TEMP_SCRATCH_REG", ",", "vcall_offset", ")", ";", "asm_fprintf", "(", "file", ",", "\"\\tld\\t%s, [%s]\\n\"", ",", "ARC_TEMP_SCRATCH_REG", ",", "ARC_TEMP_SCRATCH_REG", ")", ";", "asm_fprintf", "(", "file", ",", "\"\\tadd\\t%s, %s, %s\\n\"", ",", "reg_names", "[", "this_regno", "]", ",", "reg_names", "[", "this_regno", "]", ",", "ARC_TEMP_SCRATCH_REG", ")", ";", "}", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ";", "if", "(", "arc_is_longcall_p", "(", "fnaddr", ")", ")", "{", "if", "(", "flag_pic", ")", "{", "asm_fprintf", "(", "file", ",", "\"\\tld\\t%s, [pcl, @\"", ",", "ARC_TEMP_SCRATCH_REG", ")", ";", "assemble_name", "(", "file", ",", "XSTR", "(", "fnaddr", ",", "0", ")", ")", ";", "fputs", "(", "\"@gotpc]\\n\"", ",", "file", ")", ";", "asm_fprintf", "(", "file", ",", "\"\\tj\\t[%s]\"", ",", "ARC_TEMP_SCRATCH_REG", ")", ";", "}", "else", "{", "fputs", "(", "\"\\tj\\t@\"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "XSTR", "(", "fnaddr", ",", "0", ")", ")", ";", "}", "}", "else", "{", "fputs", "(", "\"\\tb\\t@\"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "XSTR", "(", "fnaddr", ",", "0", ")", ")", ";", "if", "(", "flag_pic", ")", "fputs", "(", "\"@plt\\n\"", ",", "file", ")", ";", "}", "fputc", "(", "'\\n'", ",", "file", ")", ";", "assemble_end_function", "(", "thunk", ",", "fnname", ")", ";", "}", "</s>"], "natrual_language": ["Output", "code", "to", "add", "DELTA", "to", "the", "first", "argument", ",", "and", "then", "jump", "to", "FUNCTION", ".", "Used", "for", "C++", "multiple", "inheritance", "."], "TS_V_token": ["arc", "0", "\"sub\"", "\"add\"", "0", "1", "0", "0", "0", "3", "0", "2", "\"\\t%s\\t%s, %s, %d\\n\"", "0xff", "0xff", "8", "0", "\"\\tld\\t%s, [%s]\\n\"", "\"\\tadd\\t%s, %s, \"", "\"\\n\"", "\"\\tld\\t%s, [%s]\\n\"", "\"\\tadd\\t%s, %s, %s\\n\"", "0", "\"\\tld\\t%s, [pcl, @\"", "0", "\"@gotpc]\\n\"", "\"\\tj\\t[%s]\"", "\"\\tj\\t@\"", "0", "\"\\tb\\t@\"", "0", "\"@plt\\n\""], "File": "arc", "Func": "arc_output_mi_thunk", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33726, "Length": 370}
{"ground_truth": ["<s>", "static", "bool", "arc_pass_by_reference", "(", "cumulative_args_t", ",", "const", "function_arg_info", "&", "arg", ")", "{", "return", "(", "arg", ".", "type", "!=", "0", "&&", "(", "TREE_CODE", "(", "TYPE_SIZE", "(", "arg", ".", "type", ")", ")", "!=", "INTEGER_CST", "||", "TREE_ADDRESSABLE", "(", "arg", ".", "type", ")", ")", ")", ";", "}", "</s>"], "natrual_language": ["For", "ARC", ",", "All", "aggregates", "and", "arguments", "greater", "than", "8", "bytes", "are", "passed", "by", "reference", "."], "TS_V_token": ["arc", "0"], "File": "arc", "Func": "arc_pass_by_reference", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33727, "Length": 43}
{"ground_truth": ["<s>", "static", "void", "arc_post_atomic_barrier", "(", "enum", "memmodel", "model", ")", "{", "if", "(", "need_atomic_barrier_p", "(", "model", ",", "false", ")", ")", "emit_insn", "(", "gen_memory_barrier", "(", ")", ")", ";", "}", "</s>"], "natrual_language": ["Emit", "a", "(", "post", ")", "memory", "barrier", "around", "an", "atomic", "sequence", "according", "to", "MODEL", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_post_atomic_barrier", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33728, "Length": 26}
{"ground_truth": ["<s>", "static", "unsigned", "arc_predicate_delay_insns", "(", "void", ")", "{", "for", "(", "rtx_insn", "*", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "rtx", "pat", ",", "jump", ",", "dlay", ",", "src", ",", "cond", ",", "*", "patp", ";", "int", "reverse", ";", "if", "(", "!", "NONJUMP_INSN_P", "(", "insn", ")", "||", "GET_CODE", "(", "pat", "=", "PATTERN", "(", "insn", ")", ")", "!=", "SEQUENCE", ")", "continue", ";", "jump", "=", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ";", "dlay", "=", "XVECEXP", "(", "pat", ",", "0", ",", "1", ")", ";", "if", "(", "!", "JUMP_P", "(", "jump", ")", "||", "!", "INSN_ANNULLED_BRANCH_P", "(", "jump", ")", ")", "continue", ";", "if", "(", "!", "TARGET_AT_DBR_CONDEXEC", "&&", "!", "INSN_FROM_TARGET_P", "(", "dlay", ")", ")", "continue", ";", "gcc_assert", "(", "GET_CODE", "(", "PATTERN", "(", "jump", ")", ")", "==", "SET", ")", ";", "gcc_assert", "(", "SET_DEST", "(", "PATTERN", "(", "jump", ")", ")", "==", "pc_rtx", ")", ";", "src", "=", "SET_SRC", "(", "PATTERN", "(", "jump", ")", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "src", ")", "==", "IF_THEN_ELSE", ")", ";", "cond", "=", "XEXP", "(", "src", ",", "0", ")", ";", "if", "(", "XEXP", "(", "src", ",", "2", ")", "==", "pc_rtx", ")", "reverse", "=", "0", ";", "else", "if", "(", "XEXP", "(", "src", ",", "1", ")", "==", "pc_rtx", ")", "reverse", "=", "1", ";", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "reverse", "!=", "!", "INSN_FROM_TARGET_P", "(", "dlay", ")", ")", "{", "machine_mode", "ccm", "=", "GET_MODE", "(", "XEXP", "(", "cond", ",", "0", ")", ")", ";", "enum", "rtx_code", "code", "=", "reverse_condition", "(", "GET_CODE", "(", "cond", ")", ")", ";", "if", "(", "code", "==", "UNKNOWN", "||", "ccm", "==", "CC_FP_GTmode", "||", "ccm", "==", "CC_FP_GEmode", ")", "code", "=", "reverse_condition_maybe_unordered", "(", "GET_CODE", "(", "cond", ")", ")", ";", "cond", "=", "gen_rtx_fmt_ee", "(", "code", ",", "GET_MODE", "(", "cond", ")", ",", "copy_rtx", "(", "XEXP", "(", "cond", ",", "0", ")", ")", ",", "copy_rtx", "(", "XEXP", "(", "cond", ",", "1", ")", ")", ")", ";", "}", "else", "cond", "=", "copy_rtx", "(", "cond", ")", ";", "patp", "=", "&", "PATTERN", "(", "dlay", ")", ";", "pat", "=", "*", "patp", ";", "pat", "=", "conditionalize_nonjump", "(", "pat", ",", "cond", ",", "dlay", ",", "true", ")", ";", "validate_change", "(", "dlay", ",", "patp", ",", "pat", ",", "1", ")", ";", "if", "(", "!", "apply_change_group", "(", ")", ")", "gcc_unreachable", "(", ")", ";", "}", "return", "0", ";", "}", "</s>"], "natrual_language": ["Find", "annulled", "delay", "insns", "and", "convert", "them", "to", "use", "the", "appropriate", "predicate", ".", "This", "allows", "branch", "shortening", "to", "size", "up", "these", "insns", "properly", "."], "TS_V_token": ["arc", "0", "0", "0", "1", "0", "2", "0", "1", "1", "0", "0", "1", "1", "0"], "File": "arc", "Func": "arc_predicate_delay_insns", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33729, "Length": 362}
{"ground_truth": ["<s>", "static", "machine_mode", "arc_preferred_simd_mode", "(", "scalar_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_HImode", ":", "return", "TARGET_PLUS_QMACW", "?", "V4HImode", ":", "V2HImode", ";", "case", "E_SImode", ":", "return", "V2SImode", ";", "default", ":", "return", "word_mode", ";", "}", "}", "</s>"], "natrual_language": ["Implements", "target", "hook", "TARGET_VECTORIZE_PREFERRED_SIMD_MODE", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_preferred_simd_mode", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33730, "Length": 36}
{"ground_truth": ["<s>", "static", "void", "arc_pre_atomic_barrier", "(", "enum", "memmodel", "model", ")", "{", "if", "(", "need_atomic_barrier_p", "(", "model", ",", "true", ")", ")", "emit_insn", "(", "gen_memory_barrier", "(", ")", ")", ";", "}", "</s>"], "natrual_language": ["Emit", "a", "(", "pre", ")", "memory", "barrier", "around", "an", "atomic", "sequence", "according", "to", "MODEL", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_pre_atomic_barrier", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33731, "Length": 26}
{"ground_truth": ["<s>", "void", "arc_print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "rtx", "base", ",", "index", "=", "0", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "fputs", "(", "reg_names", "[", "REGNO", "(", "addr", ")", "]", ",", "file", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "if", "(", "output_sdata", ")", "fputs", "(", "\"gp,\"", ",", "file", ")", ";", "output_addr_const", "(", "file", ",", "addr", ")", ";", "if", "(", "output_sdata", ")", "fputs", "(", "\"@sda\"", ",", "file", ")", ";", "output_sdata", "=", "0", ";", "break", ";", "case", "PLUS", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "MULT", ")", "index", "=", "XEXP", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ",", "base", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "if", "(", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", "index", "=", "XEXP", "(", "addr", ",", "0", ")", ",", "base", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "base", "=", "XEXP", "(", "addr", ",", "0", ")", ",", "index", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "gcc_assert", "(", "OBJECT_P", "(", "base", ")", ")", ";", "arc_print_operand_address", "(", "file", ",", "base", ")", ";", "if", "(", "CONSTANT_P", "(", "base", ")", "&&", "CONST_INT_P", "(", "index", ")", ")", "fputc", "(", "'+'", ",", "file", ")", ";", "else", "fputc", "(", "','", ",", "file", ")", ";", "gcc_assert", "(", "OBJECT_P", "(", "index", ")", ")", ";", "arc_print_operand_address", "(", "file", ",", "index", ")", ";", "break", ";", "case", "CONST", ":", "{", "rtx", "c", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "(", "GET_CODE", "(", "c", ")", "==", "UNSPEC", "&&", "(", "XINT", "(", "c", ",", "1", ")", "==", "UNSPEC_TLS_OFF", "||", "XINT", "(", "c", ",", "1", ")", "==", "UNSPEC_TLS_IE", ")", ")", "||", "(", "GET_CODE", "(", "c", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "c", ",", "0", ")", ")", "==", "UNSPEC", "&&", "(", "XINT", "(", "XEXP", "(", "c", ",", "0", ")", ",", "1", ")", "==", "UNSPEC_TLS_OFF", "||", "XINT", "(", "XEXP", "(", "c", ",", "0", ")", ",", "1", ")", "==", "ARC_UNSPEC_GOTOFFPC", ")", ")", ")", "{", "arc_output_pic_addr_const", "(", "file", ",", "c", ",", "0", ")", ";", "break", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "c", ")", "==", "PLUS", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "c", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "c", ",", "1", ")", ")", "==", "CONST_INT", ")", ";", "output_address", "(", "VOIDmode", ",", "XEXP", "(", "addr", ",", "0", ")", ")", ";", "break", ";", "}", "case", "PRE_INC", ":", "case", "PRE_DEC", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "default", ":", "if", "(", "flag_pic", ")", "arc_output_pic_addr_const", "(", "file", ",", "addr", ",", "0", ")", ";", "else", "output_addr_const", "(", "file", ",", "addr", ")", ";", "break", ";", "}", "}", "</s>"], "natrual_language": ["Print", "a", "memory", "address", "as", "an", "operand", "to", "reference", "that", "memory", "location", "."], "TS_V_token": ["arc", "0", "\"gp,\"", "\"@sda\"", "0", "0", "0", "0", "1", "0", "0", "1", "0", "1", "0", "1", "1", "0", "0", "1", "0", "1", "0", "0", "1", "0", "0"], "File": "arc", "Func": "arc_print_operand_address", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33732, "Length": 434}
{"ground_truth": ["<s>", "static", "bool", "arc_process_double_reg_moves", "(", "rtx", "*", "operands", ")", "{", "enum", "usesDxState", "{", "none", ",", "srcDx", ",", "destDx", ",", "maxDx", "}", ";", "enum", "usesDxState", "state", "=", "none", ";", "rtx", "dest", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "if", "(", "refers_to_regno_p", "(", "40", ",", "44", ",", "src", ",", "0", ")", ")", "{", "state", "=", "srcDx", ";", "gcc_assert", "(", "REG_P", "(", "dest", ")", ")", ";", "}", "if", "(", "refers_to_regno_p", "(", "40", ",", "44", ",", "dest", ",", "0", ")", ")", "{", "gcc_assert", "(", "REG_P", "(", "src", ")", ")", ";", "gcc_assert", "(", "state", "==", "none", ")", ";", "state", "=", "destDx", ";", "}", "if", "(", "state", "==", "none", ")", "return", "false", ";", "if", "(", "state", "==", "srcDx", ")", "{", "if", "(", "TARGET_DPFP_DISABLE_LRSR", ")", "{", "rtx", "set", "=", "gen_rtx_SET", "(", "dest", ",", "src", ")", ";", "rtx", "use1", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "const1_rtx", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "set", ",", "use1", ")", ")", ")", ";", "}", "else", "{", "rtx", "destHigh", "=", "simplify_gen_subreg", "(", "SImode", ",", "dest", ",", "DFmode", ",", "TARGET_BIG_ENDIAN", "?", "0", ":", "4", ")", ";", "rtx", "destLow", "=", "simplify_gen_subreg", "(", "SImode", ",", "dest", ",", "DFmode", ",", "TARGET_BIG_ENDIAN", "?", "4", ":", "0", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "destHigh", ",", "gen_rtx_UNSPEC_VOLATILE", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "src", ")", ",", "VUNSPEC_ARC_LR_HIGH", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "destLow", ",", "gen_rtx_UNSPEC_VOLATILE", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "src", ")", ",", "VUNSPEC_ARC_LR", ")", ")", ")", ";", "}", "}", "else", "if", "(", "state", "==", "destDx", ")", "{", "rtx", "srcHigh", "=", "simplify_gen_subreg", "(", "SImode", ",", "src", ",", "DFmode", ",", "TARGET_BIG_ENDIAN", "?", "0", ":", "4", ")", ";", "rtx", "srcLow", "=", "simplify_gen_subreg", "(", "SImode", ",", "src", ",", "DFmode", ",", "TARGET_BIG_ENDIAN", "?", "4", ":", "0", ")", ";", "emit_insn", "(", "gen_dexcl_2op", "(", "dest", ",", "srcHigh", ",", "srcLow", ")", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Handle", "DOUBLE_REGS", "uses", ".", "Operand", "0", ":", "destination", "register", "Operand", "1", ":", "source", "register"], "TS_V_token": ["arc", "0", "1", "40", "44", "0", "40", "44", "0", "2", "0", "4", "4", "0", "1", "1", "0", "4", "4", "0"], "File": "arc", "Func": "arc_process_double_reg_moves", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33733, "Length": 313}
{"ground_truth": ["<s>", "bool", "arc_raw_symbolic_reference_mentioned_p", "(", "rtx", "op", ",", "bool", "skip_local", ")", "{", "const", "char", "*", "fmt", ";", "int", "i", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "UNSPEC", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "SYMBOL_REF", ")", "{", "if", "(", "SYMBOL_REF_TLS_MODEL", "(", "op", ")", ")", "return", "true", ";", "if", "(", "!", "flag_pic", ")", "return", "false", ";", "tree", "decl", "=", "SYMBOL_REF_DECL", "(", "op", ")", ";", "return", "!", "skip_local", "||", "!", "decl", "||", "!", "default_binds_local_p", "(", "decl", ")", ";", "}", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "op", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "op", ")", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "int", "j", ";", "for", "(", "j", "=", "XVECLEN", "(", "op", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "if", "(", "arc_raw_symbolic_reference_mentioned_p", "(", "XVECEXP", "(", "op", ",", "i", ",", "j", ")", ",", "skip_local", ")", ")", "return", "true", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'e'", "&&", "arc_raw_symbolic_reference_mentioned_p", "(", "XEXP", "(", "op", ",", "i", ")", ",", "skip_local", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "OP", "contains", "a", "SYMBOL_REF", "that", "is", "not", "wrapped", "in", "an", "unspec", ".", "If", "SKIP_LOCAL", "is", "true", ",", "skip", "symbols", "that", "bind", "locally", ".", "This", "is", "used", "further", "down", "in", "this", "file", ",", "and", ",", "without", "SKIP_LOCAL", ",", "in", "the", "addsi3", "/", "subsi3", "expanders", "when", "generating", "PIC", "code", "."], "TS_V_token": ["arc", "1", "0", "1", "0"], "File": "arc", "Func": "arc_raw_symbolic_reference_mentioned_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33734, "Length": 195}
{"ground_truth": ["<s>", "static", "int", "arc_register_move_cost", "(", "machine_mode", ",", "reg_class_t", "from_class", ",", "reg_class_t", "to_class", ")", "{", "if", "(", "(", "TARGET_ARC700", "||", "TARGET_EM", ")", "&&", "TARGET_DPFP", "&&", "from_class", "==", "DOUBLE_REGS", "&&", "to_class", "==", "DOUBLE_REGS", ")", "return", "100", ";", "return", "2", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_REGISTER_MOVE_COST", "."], "TS_V_token": ["arc", "100", "2"], "File": "arc", "Func": "arc_register_move_cost", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33735, "Length": 38}
{"ground_truth": ["<s>", "rtx", "arc_regno_use_in", "(", "unsigned", "int", "regno", ",", "rtx", "x", ")", "{", "const", "char", "*", "fmt", ";", "int", "i", ",", "j", ";", "rtx", "tem", ";", "if", "(", "REG_P", "(", "x", ")", "&&", "refers_to_regno_p", "(", "regno", ",", "x", ")", ")", "return", "x", ";", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "x", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "x", ")", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'e'", ")", "{", "if", "(", "(", "tem", "=", "regno_use_in", "(", "regno", ",", "XEXP", "(", "x", ",", "i", ")", ")", ")", ")", "return", "tem", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "for", "(", "j", "=", "XVECLEN", "(", "x", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "if", "(", "(", "tem", "=", "regno_use_in", "(", "regno", ",", "XVECEXP", "(", "x", ",", "i", ",", "j", ")", ")", ")", ")", "return", "tem", ";", "}", "return", "NULL_RTX", ";", "}", "</s>"], "natrual_language": ["Searches", "X", "for", "any", "reference", "to", "REGNO", ",", "returning", "the", "rtx", "of", "the", "reference", "found", "if", "any", ".", "Otherwise", ",", "returns", "NULL_RTX", "."], "TS_V_token": ["arc", "1", "0", "1", "0"], "File": "arc", "Func": "arc_regno_use_in", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33736, "Length": 163}
{"ground_truth": ["<s>", "static", "void", "arc_reorg_loops", "(", "void", ")", "{", "reorg_loops", "(", "true", ",", "&", "arc_doloop_hooks", ")", ";", "}", "</s>"], "natrual_language": ["Run", "from", "machine_dependent_reorg", ",", "this", "pass", "looks", "for", "doloop_end", "insns", "and", "tries", "to", "rewrite", "the", "RTL", "of", "these", "loops", "so", "that", "proper", "Blackfin", "hardware", "loops", "are", "generated", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_reorg_loops", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33737, "Length": 16}
{"ground_truth": ["<s>", "static", "int", "arc_restore_callee_saves", "(", "uint64_t", "gmask", ",", "bool", "restore_blink", ",", "bool", "restore_fp", ",", "HOST_WIDE_INT", "offset", ",", "HOST_WIDE_INT", "allocated", ")", "{", "rtx", "reg", ";", "int", "frame_deallocated", "=", "0", ";", "HOST_WIDE_INT", "offs", "=", "cfun", "->", "machine", "->", "frame_info", ".", "reg_size", ";", "unsigned", "int", "fn_type", "=", "arc_compute_function_type", "(", "cfun", ")", ";", "bool", "early_blink_restore", ";", "int", "i", ";", "if", "(", "arc_frame_pointer_needed", "(", ")", "&&", "offset", ")", "{", "frame_move", "(", "stack_pointer_rtx", ",", "hard_frame_pointer_rtx", ")", ";", "frame_deallocated", "+=", "offset", ";", "offset", "=", "0", ";", "}", "if", "(", "restore_fp", ")", "{", "gcc_assert", "(", "offset", "==", "0", ")", ";", "frame_deallocated", "+=", "frame_restore_reg", "(", "hard_frame_pointer_rtx", ",", "0", ")", ";", "}", "if", "(", "offset", ")", "{", "frame_stack_add", "(", "offset", ")", ";", "frame_deallocated", "+=", "offset", ";", "offset", "=", "0", ";", "}", "early_blink_restore", "=", "restore_blink", "&&", "!", "optimize_size", "&&", "offs", "&&", "!", "ARC_INTERRUPT_P", "(", "fn_type", ")", ";", "if", "(", "early_blink_restore", ")", "{", "rtx", "addr", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offs", ")", ";", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ";", "rtx", "insn", "=", "frame_move_inc", "(", "reg", ",", "gen_frame_mem", "(", "Pmode", ",", "addr", ")", ",", "stack_pointer_rtx", ",", "NULL_RTX", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "reg", ")", ";", "restore_blink", "=", "false", ";", "}", "if", "(", "gmask", ")", "for", "(", "i", "=", "0", ";", "i", "<=", "GMASK_LEN", ";", "i", "++", ")", "{", "machine_mode", "restore_mode", "=", "SImode", ";", "if", "(", "TARGET_LL64", "&&", "(", "(", "i", "%", "2", ")", "==", "0", ")", "&&", "(", "(", "gmask", "&", "(", "1ULL", "<<", "i", ")", ")", "!=", "0", ")", "&&", "(", "(", "gmask", "&", "(", "1ULL", "<<", "(", "i", "+", "1", ")", ")", ")", "!=", "0", ")", ")", "restore_mode", "=", "DImode", ";", "else", "if", "(", "(", "gmask", "&", "(", "1ULL", "<<", "i", ")", ")", "==", "0", ")", "continue", ";", "reg", "=", "gen_rtx_REG", "(", "restore_mode", ",", "i", ")", ";", "offs", "=", "0", ";", "switch", "(", "restore_mode", ")", "{", "case", "E_DImode", ":", "if", "(", "(", "GMASK_LEN", "-", "__builtin_clzll", "(", "gmask", ")", ")", "==", "(", "i", "+", "1", ")", "&&", "early_blink_restore", ")", "offs", "=", "4", ";", "break", ";", "case", "E_SImode", ":", "if", "(", "(", "GMASK_LEN", "-", "__builtin_clzll", "(", "gmask", ")", ")", "==", "i", "&&", "early_blink_restore", ")", "offs", "=", "4", ";", "break", ";", "default", ":", "offs", "=", "0", ";", "}", "frame_deallocated", "+=", "frame_restore_reg", "(", "reg", ",", "offs", ")", ";", "offset", "=", "0", ";", "if", "(", "restore_mode", "==", "DImode", ")", "i", "++", ";", "}", "if", "(", "restore_blink", ")", "{", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ";", "frame_deallocated", "+=", "frame_restore_reg", "(", "reg", ",", "allocated", "-", "frame_deallocated", "-", "UNITS_PER_WORD", ")", ";", "}", "return", "frame_deallocated", ";", "}", "</s>"], "natrual_language": ["ARC", "'s", "epilogue", ",", "restore", "any", "required", "call-saved", "regs", "(", "and", "call-used", "if", "it", "is", "for", "an", "interrupt", "handler", ")", "using", "LD/LDD", "instructions", "."], "TS_V_token": ["arc", "0", "0", "0", "0", "0", "0", "2", "0", "1ULL", "0", "1ULL", "1", "0", "1ULL", "0", "0", "1", "4", "4", "0", "0"], "File": "arc", "Func": "arc_restore_callee_saves", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33738, "Length": 416}
{"ground_truth": ["<s>", "static", "int", "arc_return_address_register", "(", "unsigned", "int", "fn_type", ")", "{", "int", "regno", "=", "0", ";", "if", "(", "ARC_INTERRUPT_P", "(", "fn_type", ")", ")", "{", "if", "(", "(", "fn_type", "&", "(", "ARC_FUNCTION_ILINK1", "|", "ARC_FUNCTION_FIRQ", ")", ")", "!=", "0", ")", "regno", "=", "ILINK1_REG", ";", "else", "if", "(", "(", "fn_type", "&", "ARC_FUNCTION_ILINK2", ")", "!=", "0", ")", "regno", "=", "ILINK2_REG", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "ARC_NORMAL_P", "(", "fn_type", ")", "||", "ARC_NAKED_P", "(", "fn_type", ")", ")", "regno", "=", "RETURN_ADDR_REGNUM", ";", "gcc_assert", "(", "regno", "!=", "0", ")", ";", "return", "regno", ";", "}", "</s>"], "natrual_language": ["Return", "the", "register", "number", "of", "the", "register", "holding", "the", "return", "address", "for", "a", "function", "of", "type", "TYPE", "."], "TS_V_token": ["arc", "0", "0", "0", "0"], "File": "arc", "Func": "arc_return_address_register", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33739, "Length": 89}
{"ground_truth": ["<s>", "rtx", "arc_return_addr_rtx", "(", "int", "count", ",", "ATTRIBUTE_UNUSED", "rtx", "frame", ")", "{", "if", "(", "count", "!=", "0", ")", "return", "const0_rtx", ";", "return", "get_hard_reg_initial_val", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ";", "}", "</s>"], "natrual_language": ["Returns", "the", "return", "address", "that", "is", "used", "by", "builtin_return_address", "."], "TS_V_token": ["arc", "0"], "File": "arc", "Func": "arc_return_addr_rtx", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33740, "Length": 29}
{"ground_truth": ["<s>", "static", "bool", "arc_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "||", "TREE_ADDRESSABLE", "(", "type", ")", ")", "return", "true", ";", "else", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "return", "(", "size", "==", "-", "1", "||", "size", ">", "(", "TARGET_V2", "?", "16", ":", "8", ")", ")", ";", "}", "}", "</s>"], "natrual_language": ["Worker", "function", "for", "TARGET_RETURN_IN_MEMORY", "."], "TS_V_token": ["arc", "1", "16", "8"], "File": "arc", "Func": "arc_return_in_memory", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33741, "Length": 57}
{"ground_truth": ["<s>", "static", "int", "arc_save_callee_enter", "(", "uint64_t", "gmask", ",", "bool", "save_blink", ",", "bool", "save_fp", ",", "HOST_WIDE_INT", "offset", ")", "{", "int", "start_reg", "=", "ENTER_LEAVE_START_REG", ";", "int", "end_reg", "=", "ENTER_LEAVE_END_REG", ";", "int", "regno", ",", "indx", ",", "off", ",", "nregs", ";", "rtx", "insn", ",", "reg", ",", "mem", ";", "int", "frame_allocated", "=", "0", ";", "for", "(", "regno", "=", "start_reg", ";", "regno", "<=", "end_reg", "&&", "(", "gmask", "&", "(", "1ULL", "<<", "regno", ")", ")", ";", ")", "regno", "++", ";", "end_reg", "=", "regno", "-", "1", ";", "nregs", "=", "end_reg", "-", "start_reg", "+", "1", ";", "nregs", "+=", "save_blink", "?", "1", ":", "0", ";", "nregs", "+=", "save_fp", "?", "1", ":", "0", ";", "if", "(", "offset", ")", "frame_stack_add", "(", "offset", ")", ";", "insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "nregs", "+", "(", "save_fp", "?", "1", ":", "0", ")", "+", "1", ")", ")", ";", "indx", "=", "0", ";", "reg", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "nregs", "*", "UNITS_PER_WORD", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "reg", ")", "=", "1", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", "++", ")", "=", "reg", ";", "off", "=", "nregs", "*", "UNITS_PER_WORD", ";", "if", "(", "save_blink", ")", "{", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ";", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "off", ")", ")", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "insn", ",", "0", ",", "indx", "++", ")", ")", "=", "1", ";", "off", "-=", "UNITS_PER_WORD", ";", "save_blink", "=", "false", ";", "}", "for", "(", "regno", "=", "start_reg", ";", "regno", "<=", "end_reg", ";", "regno", "++", ",", "indx", "++", ",", "off", "-=", "UNITS_PER_WORD", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "off", ")", ")", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", ")", "=", "1", ";", "gmask", "=", "gmask", "&", "~", "(", "1ULL", "<<", "regno", ")", ";", "}", "if", "(", "save_fp", ")", "{", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "off", ")", ")", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", "=", "gen_rtx_SET", "(", "mem", ",", "hard_frame_pointer_rtx", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "insn", ",", "0", ",", "indx", "++", ")", ")", "=", "1", ";", "off", "-=", "UNITS_PER_WORD", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", "=", "gen_rtx_SET", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "insn", ",", "0", ",", "indx", "++", ")", ")", "=", "1", ";", "save_fp", "=", "false", ";", "}", "gcc_assert", "(", "off", "==", "0", ")", ";", "insn", "=", "frame_insn", "(", "insn", ")", ";", "add_reg_note", "(", "insn", ",", "REG_INC", ",", "stack_pointer_rtx", ")", ";", "frame_allocated", "=", "nregs", "*", "UNITS_PER_WORD", ";", "return", "frame_allocated", "-", "offset", ";", "}", "</s>"], "natrual_language": ["ARC", "prologue", ",", "save", "the", "registers", "using", "enter", "instruction", ".", "Leave", "instruction", "can", "also", "save", "$", "blink", "(", "SAVE_BLINK", ")", "and", "$", "fp", "(", "SAVE_FP", ")", "register", "."], "TS_V_token": ["arc", "0", "1ULL", "1", "1", "1", "0", "1", "0", "1", "0", "1", "0", "1", "0", "0", "0", "1", "0", "0", "1", "1ULL", "0", "0", "1", "0", "0", "1", "0"], "File": "arc", "Func": "arc_save_callee_enter", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33742, "Length": 466}
{"ground_truth": ["<s>", "static", "int", "arc_save_callee_milli", "(", "uint64_t", "gmask", ",", "bool", "save_blink", ",", "bool", "save_fp", ",", "HOST_WIDE_INT", "offset", ",", "HOST_WIDE_INT", "reg_size", ")", "{", "int", "start_reg", "=", "13", ";", "int", "end_reg", "=", "25", ";", "int", "regno", ",", "indx", ",", "off", ",", "nregs", ";", "rtx", "insn", ",", "reg", ",", "mem", ";", "int", "frame_allocated", "=", "0", ";", "for", "(", "regno", "=", "start_reg", ";", "regno", "<=", "end_reg", "&&", "(", "gmask", "&", "(", "1ULL", "<<", "regno", ")", ")", ";", ")", "regno", "++", ";", "end_reg", "=", "regno", "-", "1", ";", "nregs", "=", "end_reg", "-", "start_reg", "+", "1", ";", "gcc_assert", "(", "end_reg", ">", "14", ")", ";", "if", "(", "save_blink", ")", "{", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ";", "frame_allocated", "+=", "frame_save_reg", "(", "reg", ",", "offset", ")", ";", "offset", "=", "0", ";", "}", "if", "(", "reg_size", "||", "offset", ")", "{", "frame_stack_add", "(", "offset", "-", "reg_size", ")", ";", "frame_allocated", "+=", "nregs", "*", "UNITS_PER_WORD", "-", "offset", ";", "offset", "=", "0", ";", "}", "insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "nregs", "+", "1", ")", ")", ";", "indx", "=", "0", ";", "XVECEXP", "(", "insn", ",", "0", ",", "nregs", ")", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ")", ";", "for", "(", "regno", "=", "start_reg", ",", "indx", "=", "0", ",", "off", "=", "0", ";", "regno", "<=", "end_reg", ";", "regno", "++", ",", "indx", "++", ",", "off", "+=", "UNITS_PER_WORD", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "off", ")", ")", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", ")", "=", "1", ";", "gmask", "=", "gmask", "&", "~", "(", "1ULL", "<<", "regno", ")", ";", "}", "insn", "=", "frame_insn", "(", "insn", ")", ";", "for", "(", "regno", "=", "start_reg", ",", "off", "=", "0", ";", "regno", "<=", "end_reg", ";", "regno", "++", ",", "off", "+=", "UNITS_PER_WORD", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "off", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_OFFSET", ",", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ")", ";", "}", "if", "(", "arc_must_save_return_addr", "(", "cfun", ")", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ",", "gen_rtx_MEM", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "reg_size", ")", ")", ")", ")", ";", "}", "for", "(", "regno", "=", "0", ";", "regno", "<=", "GMASK_LEN", ";", "regno", "++", ")", "{", "if", "(", "(", "gmask", "&", "(", "1ULL", "<<", "regno", ")", ")", "==", "0", ")", "continue", ";", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "off", ")", ")", ";", "frame_move_inc", "(", "mem", ",", "reg", ",", "stack_pointer_rtx", ",", "0", ")", ";", "frame_allocated", "+=", "UNITS_PER_WORD", ";", "off", "+=", "UNITS_PER_WORD", ";", "}", "if", "(", "save_fp", ")", "frame_allocated", "+=", "frame_save_reg", "(", "hard_frame_pointer_rtx", ",", "offset", ")", ";", "if", "(", "arc_frame_pointer_needed", "(", ")", ")", "frame_move", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ";", "return", "frame_allocated", ";", "}", "</s>"], "natrual_language": ["Millicode", "thunks", "implementation", ":", "Generates", "calls", "to", "millicodes", "for", "registers", "starting", "from", "r13", "to", "r25", "Present", "Limitations", ":", "-", "Only", "one", "range", "supported", ".", "The", "remaining", "regs", "will", "have", "the", "ordinary", "st", "and", "ld", "instructions", "for", "store", "and", "loads", ".", "Hence", "a", "gmask", "asking", "to", "store", "r13-14", ",", "r16-r25", "will", "only", "generate", "calls", "to", "store", "and", "load", "r13", "to", "r14", "while", "store", "and", "load", "insns", "will", "be", "generated", "for", "r16", "to", "r25", "in", "the", "prologue", "and", "epilogue", "respectively", ".", "-", "Presently", "library", "only", "supports", "register", "ranges", "starting", "from", "r13", "."], "TS_V_token": ["arc", "13", "25", "0", "1ULL", "1", "1", "14", "0", "0", "1", "0", "0", "0", "0", "0", "0", "1", "1ULL", "0", "0", "1ULL", "0", "0"], "File": "arc", "Func": "arc_save_callee_milli", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33743, "Length": 496}
{"ground_truth": ["<s>", "static", "int", "arc_save_callee_saves", "(", "uint64_t", "gmask", ",", "bool", "save_blink", ",", "bool", "save_fp", ",", "HOST_WIDE_INT", "offset", ",", "bool", "emit_move", ")", "{", "rtx", "reg", ";", "int", "frame_allocated", "=", "0", ";", "int", "i", ";", "if", "(", "save_blink", ")", "{", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ";", "frame_allocated", "+=", "frame_save_reg", "(", "reg", ",", "offset", ")", ";", "offset", "=", "0", ";", "}", "if", "(", "gmask", ")", "for", "(", "i", "=", "GMASK_LEN", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "machine_mode", "save_mode", "=", "SImode", ";", "if", "(", "TARGET_LL64", "&&", "(", "(", "i", "-", "1", ")", "%", "2", "==", "0", ")", "&&", "(", "(", "gmask", "&", "(", "1ULL", "<<", "i", ")", ")", "!=", "0", ")", "&&", "(", "(", "gmask", "&", "(", "1ULL", "<<", "(", "i", "-", "1", ")", ")", ")", "!=", "0", ")", ")", "{", "save_mode", "=", "DImode", ";", "--", "i", ";", "}", "else", "if", "(", "(", "gmask", "&", "(", "1ULL", "<<", "i", ")", ")", "==", "0", ")", "continue", ";", "reg", "=", "gen_rtx_REG", "(", "save_mode", ",", "i", ")", ";", "frame_allocated", "+=", "frame_save_reg", "(", "reg", ",", "offset", ")", ";", "offset", "=", "0", ";", "}", "if", "(", "save_fp", ")", "{", "frame_allocated", "+=", "frame_save_reg", "(", "hard_frame_pointer_rtx", ",", "offset", ")", ";", "offset", "=", "0", ";", "}", "if", "(", "emit_move", ")", "frame_move", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ";", "return", "frame_allocated", ";", "}", "</s>"], "natrual_language": ["ARC", "'s", "prologue", ",", "save", "any", "needed", "call-saved", "regs", "(", "and", "call-used", "if", "this", "is", "an", "interrupt", "handler", ")", "for", "ARCompact", "ISA", ",", "using", "ST/STD", "instructions", "."], "TS_V_token": ["arc", "0", "0", "0", "1", "2", "0", "1ULL", "0", "1ULL", "1", "0", "1ULL", "0", "0", "0"], "File": "arc", "Func": "arc_save_callee_saves", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33744, "Length": 213}
{"ground_truth": ["<s>", "bool", "arc_scheduling_not_expected", "(", "void", ")", "{", "return", "cfun", "->", "machine", "->", "arc_reorg_started", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "the", "scheduling", "pass", "(", "es", ")", "has/have", "already", "run", ",", "i.e", ".", "where", "possible", ",", "we", "should", "try", "to", "mitigate", "high", "latencies", "by", "different", "instruction", "selection", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_scheduling_not_expected", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33745, "Length": 14}
{"ground_truth": ["<s>", "static", "int", "arc_sched_adjust_priority", "(", "rtx_insn", "*", "insn", ",", "int", "priority", ")", "{", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", "&&", "GET_MODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "DFmode", "&&", "GET_CODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "REG", ")", "{", "return", "priority", "+", "20", ";", "}", "return", "priority", ";", "}", "</s>"], "natrual_language": ["Try", "to", "keep", "the", "(", "mov", ":", "DF", "_", ",", "reg", ")", "as", "early", "as", "possible", "so", "that", "the", "d", "<", "add/sub/mul", ">", "h-lr", "insns", "appear", "together", "and", "can", "use", "the", "peephole2", "pattern", "."], "TS_V_token": ["arc", "20"], "File": "arc", "Func": "arc_sched_adjust_priority", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33746, "Length": 55}
{"ground_truth": ["<s>", "static", "int", "arc_sched_issue_rate", "(", "void", ")", "{", "switch", "(", "arc_tune", ")", "{", "case", "TUNE_ARCHS4X", ":", "case", "TUNE_ARCHS4XD", ":", "return", "3", ";", "default", ":", "break", ";", "}", "return", "1", ";", "}", "</s>"], "natrual_language": ["Implements", "target", "hook", "TARGET_SCHED_ISSUE_RATE", "."], "TS_V_token": ["arc", "3", "1"], "File": "arc", "Func": "arc_sched_issue_rate", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33747, "Length": 30}
{"ground_truth": ["<s>", "static", "reg_class_t", "arc_secondary_reload", "(", "bool", "in_p", ",", "rtx", "x", ",", "reg_class_t", "cl", ",", "machine_mode", "mode", ",", "secondary_reload_info", "*", "sri", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "if", "(", "cl", "==", "DOUBLE_REGS", ")", "return", "GENERAL_REGS", ";", "if", "(", "code", "==", "SUBREG", ")", "{", "rtx", "addr", "=", "NULL_RTX", ";", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "if", "(", "REG_P", "(", "x", ")", ")", "{", "int", "regno", "=", "REGNO", "(", "x", ")", ";", "if", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "regno", "=", "reg_renumber", "[", "regno", "]", ";", "if", "(", "regno", "!=", "-", "1", ")", "return", "NO_REGS", ";", "if", "(", "!", "lra_in_progress", "&&", "reg_equiv_mem", "(", "REGNO", "(", "x", ")", ")", ")", "{", "rtx", "mem", "=", "reg_equiv_mem", "(", "REGNO", "(", "x", ")", ")", ";", "addr", "=", "find_replacement", "(", "&", "XEXP", "(", "mem", ",", "0", ")", ")", ";", "}", "}", "else", "{", "gcc_assert", "(", "MEM_P", "(", "x", ")", ")", ";", "addr", "=", "XEXP", "(", "x", ",", "0", ")", ";", "addr", "=", "simplify_rtx", "(", "addr", ")", ";", "}", "if", "(", "addr", "&&", "GET_CODE", "(", "addr", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "&&", "(", "!", "RTX_OK_FOR_OFFSET_P", "(", "mode", ",", "XEXP", "(", "addr", ",", "1", ")", ")", ")", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "sri", "->", "icode", "=", "in_p", "?", "CODE_FOR_reload_qi_load", ":", "CODE_FOR_reload_qi_store", ";", "break", ";", "case", "E_HImode", ":", "sri", "->", "icode", "=", "in_p", "?", "CODE_FOR_reload_hi_load", ":", "CODE_FOR_reload_hi_store", ";", "break", ";", "default", ":", "break", ";", "}", "}", "}", "return", "NO_REGS", ";", "}", "</s>"], "natrual_language": ["For", "ARC", "base", "register", "+", "offset", "addressing", ",", "the", "validity", "of", "the", "address", "is", "mode-dependent", "for", "most", "of", "the", "offset", "range", ",", "as", "the", "offset", "can", "be", "scaled", "by", "the", "access", "size", ".", "We", "do", "n't", "expose", "these", "as", "mode-dependent", "addresses", "in", "the", "mode_dependent_address_p", "target", "hook", ",", "because", "that", "would", "disable", "lots", "of", "optimizations", ",", "and", "most", "uses", "of", "these", "addresses", "are", "for", "32", "or", "64", "bit", "accesses", "anyways", ",", "which", "are", "fine", ".", "However", ",", "that", "leaves", "some", "addresses", "for", "8", "/", "16", "bit", "values", "not", "properly", "reloaded", "by", "the", "generic", "code", ",", "which", "is", "why", "we", "have", "to", "schedule", "secondary", "reloads", "for", "these", "."], "TS_V_token": ["arc", "1", "0", "0", "1", "1"], "File": "arc", "Func": "arc_secondary_reload", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33748, "Length": 247}
{"ground_truth": ["<s>", "void", "arc_secondary_reload_conv", "(", "rtx", "reg", ",", "rtx", "mem", ",", "rtx", "scratch", ",", "bool", "store_p", ")", "{", "rtx", "addr", ";", "gcc_assert", "(", "GET_CODE", "(", "mem", ")", "==", "MEM", ")", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "emit_move_insn", "(", "scratch", ",", "addr", ")", ";", "mem", "=", "replace_equiv_address_nv", "(", "mem", ",", "scratch", ")", ";", "if", "(", "store_p", ")", "emit_insn", "(", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ")", ";", "else", "emit_insn", "(", "gen_rtx_SET", "(", "reg", ",", "mem", ")", ")", ";", "return", ";", "}", "</s>"], "natrual_language": ["Convert", "reloads", "using", "offsets", "that", "are", "too", "large", "to", "use", "indirect", "addressing", "."], "TS_V_token": ["arc", "0"], "File": "arc", "Func": "arc_secondary_reload_conv", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33749, "Length": 82}
{"ground_truth": ["<s>", "bool", "arc_sets_cc_p", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "NONJUMP_INSN_P", "(", "insn", ")", ")", "if", "(", "rtx_sequence", "*", "seq", "=", "dyn_cast", "<", "rtx_sequence", "*", ">", "(", "PATTERN", "(", "insn", ")", ")", ")", "insn", "=", "seq", "->", "insn", "(", "seq", "->", "len", "(", ")", "-", "1", ")", ";", "return", "arc_attr_type", "(", "insn", ")", "==", "TYPE_COMPARE", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "insn", "sets", "the", "condition", "codes", "."], "TS_V_token": ["arc", "1"], "File": "arc", "Func": "arc_sets_cc_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33750, "Length": 57}
{"ground_truth": ["<s>", "static", "void", "arc_setup_incoming_varargs", "(", "cumulative_args_t", "args_so_far", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_size", ",", "int", "no_rtl", ")", "{", "int", "first_anon_arg", ";", "CUMULATIVE_ARGS", "next_cum", ";", "next_cum", "=", "*", "get_cumulative_args", "(", "args_so_far", ")", ";", "arc_function_arg_advance", "(", "pack_cumulative_args", "(", "&", "next_cum", ")", ",", "arg", ")", ";", "first_anon_arg", "=", "next_cum", ";", "if", "(", "FUNCTION_ARG_REGNO_P", "(", "first_anon_arg", ")", ")", "{", "int", "first_reg_offset", "=", "first_anon_arg", ";", "if", "(", "!", "no_rtl", ")", "{", "rtx", "regblock", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "plus_constant", "(", "Pmode", ",", "arg_pointer_rtx", ",", "FIRST_PARM_OFFSET", "(", "0", ")", ")", ")", ";", "move_block_from_reg", "(", "first_reg_offset", ",", "regblock", ",", "MAX_ARC_PARM_REGS", "-", "first_reg_offset", ")", ";", "}", "*", "pretend_size", "=", "(", "(", "MAX_ARC_PARM_REGS", "-", "first_reg_offset", ")", "*", "UNITS_PER_WORD", ")", ";", "}", "}", "</s>"], "natrual_language": ["Do", "any", "needed", "setup", "for", "a", "variadic", "function", ".", "For", "the", "ARC", ",", "we", "must", "create", "a", "register", "parameter", "block", ",", "and", "then", "copy", "any", "anonymous", "arguments", "in", "registers", "to", "memory", ".", "CUM", "has", "not", "been", "updated", "for", "the", "last", "named", "argument", "which", "has", "type", "TYPE", "and", "mode", "MODE", ",", "and", "we", "rely", "on", "this", "fact", "."], "TS_V_token": ["arc", "0"], "File": "arc", "Func": "arc_setup_incoming_varargs", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33751, "Length": 115}
{"ground_truth": ["<s>", "bool", "arc_short_comparison_p", "(", "rtx", "comparison", ",", "int", "offset", ")", "{", "gcc_assert", "(", "ARC_CC_NC", "==", "ARC_CC_HS", ")", ";", "gcc_assert", "(", "ARC_CC_C", "==", "ARC_CC_LO", ")", ";", "switch", "(", "get_arc_condition_code", "(", "comparison", ")", ")", "{", "case", "ARC_CC_EQ", ":", "case", "ARC_CC_NE", ":", "return", "offset", ">=", "-", "512", "&&", "offset", "<=", "506", ";", "case", "ARC_CC_GT", ":", "case", "ARC_CC_LE", ":", "case", "ARC_CC_GE", ":", "case", "ARC_CC_LT", ":", "case", "ARC_CC_HI", ":", "case", "ARC_CC_LS", ":", "case", "ARC_CC_LO", ":", "case", "ARC_CC_HS", ":", "return", "offset", ">=", "-", "64", "&&", "offset", "<=", "58", ";", "default", ":", "return", "false", ";", "}", "}", "</s>"], "natrual_language": ["Return", "true", "if", "COMPARISON", "has", "a", "short", "form", "that", "can", "accomodate", "OFFSET", "."], "TS_V_token": ["arc", "512", "506", "64", "58"], "File": "arc", "Func": "arc_short_comparison_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33752, "Length": 89}
{"ground_truth": ["<s>", "const", "char", "*", "arc_short_long", "(", "rtx_insn", "*", "insn", ",", "const", "char", "*", "s_tmpl", ",", "const", "char", "*", "l_tmpl", ")", "{", "int", "is_short", "=", "arc_verify_short", "(", "insn", ",", "cfun", "->", "machine", "->", "unalign", ",", "-", "1", ")", ";", "extract_constrain_insn_cached", "(", "insn", ")", ";", "return", "is_short", "?", "s_tmpl", ":", "l_tmpl", ";", "}", "</s>"], "natrual_language": ["Select", "between", "the", "instruction", "output", "templates", "s_tmpl", "(", "for", "short", "INSNs", ")", "and", "l_tmpl", "(", "for", "long", "INSNs", ")", "."], "TS_V_token": ["arc", "1"], "File": "arc", "Func": "arc_short_long", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33753, "Length": 50}
{"ground_truth": ["<s>", "void", "arc_split_compare_and_swap", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "rval", ",", "mem", ",", "oldval", ",", "newval", ";", "machine_mode", "mode", ";", "enum", "memmodel", "mod_s", ",", "mod_f", ";", "bool", "is_weak", ";", "rtx", "label1", ",", "label2", ",", "x", ",", "cond", ";", "rval", "=", "operands", "[", "0", "]", ";", "mem", "=", "operands", "[", "1", "]", ";", "oldval", "=", "operands", "[", "2", "]", ";", "newval", "=", "operands", "[", "3", "]", ";", "is_weak", "=", "(", "operands", "[", "4", "]", "!=", "const0_rtx", ")", ";", "mod_s", "=", "(", "enum", "memmodel", ")", "INTVAL", "(", "operands", "[", "5", "]", ")", ";", "mod_f", "=", "(", "enum", "memmodel", ")", "INTVAL", "(", "operands", "[", "6", "]", ")", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "gcc_assert", "(", "mode", "==", "SImode", ")", ";", "arc_pre_atomic_barrier", "(", "mod_s", ")", ";", "label1", "=", "NULL_RTX", ";", "if", "(", "!", "is_weak", ")", "{", "label1", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label1", ")", ";", "}", "label2", "=", "gen_label_rtx", "(", ")", ";", "emit_insn", "(", "gen_arc_load_exclusivesi", "(", "rval", ",", "mem", ")", ")", ";", "mode", "=", "SELECT_CC_MODE", "(", "NE", ",", "rval", ",", "oldval", ")", ";", "cond", "=", "gen_rtx_REG", "(", "mode", ",", "CC_REG", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "cond", ",", "gen_rtx_COMPARE", "(", "mode", ",", "rval", ",", "oldval", ")", ")", ")", ";", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "cond", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "x", ",", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "label2", ")", ",", "pc_rtx", ")", ";", "emit_unlikely_jump", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "x", ")", ")", ";", "emit_insn", "(", "gen_arc_store_exclusivesi", "(", "mem", ",", "newval", ")", ")", ";", "if", "(", "!", "is_weak", ")", "{", "cond", "=", "gen_rtx_REG", "(", "CC_Zmode", ",", "CC_REG", ")", ";", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "cond", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "x", ",", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "label1", ")", ",", "pc_rtx", ")", ";", "emit_unlikely_jump", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "x", ")", ")", ";", "}", "if", "(", "mod_f", "!=", "MEMMODEL_RELAXED", ")", "emit_label", "(", "label2", ")", ";", "arc_post_atomic_barrier", "(", "mod_s", ")", ";", "if", "(", "mod_f", "==", "MEMMODEL_RELAXED", ")", "emit_label", "(", "label2", ")", ";", "}", "</s>"], "natrual_language": ["Helper", "function", "used", "by", "the", "``", "atomic_compare_and_swapsi_1", "''", "pattern", "."], "TS_V_token": ["arc", "0", "1", "2", "3", "4", "5", "6"], "File": "arc", "Func": "arc_split_compare_and_swap", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33754, "Length": 332}
{"ground_truth": ["<s>", "void", "arc_split_ior", "(", "rtx", "*", "operands", ")", "{", "unsigned", "HOST_WIDE_INT", "mask", ",", "maskx", ";", "rtx", "op1", "=", "operands", "[", "1", "]", ";", "gcc_assert", "(", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", ")", ";", "mask", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", "&", "0xffffffff", ";", "if", "(", "__builtin_popcount", "(", "mask", ")", ">", "3", "||", "(", "mask", "&", "0x3f", ")", ")", "{", "maskx", "=", "mask", "&", "0x3f", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "gen_rtx_IOR", "(", "SImode", ",", "op1", ",", "GEN_INT", "(", "maskx", ")", ")", ")", ")", ";", "op1", "=", "operands", "[", "0", "]", ";", "mask", "&=", "~", "maskx", ";", "}", "switch", "(", "__builtin_popcount", "(", "mask", ")", ")", "{", "case", "3", ":", "maskx", "=", "1", "<<", "(", "__builtin_ffs", "(", "mask", ")", "-", "1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "gen_rtx_IOR", "(", "SImode", ",", "op1", ",", "GEN_INT", "(", "maskx", ")", ")", ")", ")", ";", "mask", "&=", "~", "maskx", ";", "op1", "=", "operands", "[", "0", "]", ";", "case", "2", ":", "maskx", "=", "1", "<<", "(", "__builtin_ffs", "(", "mask", ")", "-", "1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "gen_rtx_IOR", "(", "SImode", ",", "op1", ",", "GEN_INT", "(", "maskx", ")", ")", ")", ")", ";", "mask", "&=", "~", "maskx", ";", "op1", "=", "operands", "[", "0", "]", ";", "case", "1", ":", "maskx", "=", "1", "<<", "(", "__builtin_ffs", "(", "mask", ")", "-", "1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "gen_rtx_IOR", "(", "SImode", ",", "op1", ",", "GEN_INT", "(", "maskx", ")", ")", ")", ")", ";", "break", ";", "case", "0", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Split", "an", "OR", "instruction", "into", "multiple", "BSET/OR", "instructions", "in", "a", "attempt", "to", "avoid", "long", "immediate", "constants", ".", "The", "next", "strategies", "are", "employed", "when", "destination", "is", "'", "q", "'", "reg", ".", "1.", "if", "there", "are", "up", "to", "three", "bits", "set", "in", "the", "mask", ",", "a", "succession", "of", "three", "bset", "instruction", "will", "be", "emitted", ":", "OR", "rA", ",", "rB", ",", "mask", "-", ">", "BSET", "(", "_S", ")", "rA", ",", "rB", ",", "mask1/BSET_S", "rA", ",", "rA", ",", "mask2/BSET_S", "rA", ",", "rA", ",", "mask3", "2.", "if", "the", "lower", "6", "bits", "of", "the", "mask", "is", "set", "and", "there", "is", "only", "one", "bit", "set", "in", "the", "upper", "remaining", "bits", "then", "we", "will", "emit", "one", "bset", "and", "one", "OR", "instruction", ":", "OR", "rA", ",", "rB", ",", "mask", "-", ">", "OR", "rA", ",", "rB", ",", "mask1/BSET_S", "rA", ",", "mask2", "3.", "otherwise", "an", "OR", "with", "limm", "will", "be", "emmitted", "."], "TS_V_token": ["arc", "1", "2", "2", "0xffffffff", "3", "0x3f", "0x3f", "0", "0", "3", "1", "1", "0", "0", "2", "1", "1", "0", "0", "1", "1", "1", "0", "0"], "File": "arc", "Func": "arc_split_ior", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33755, "Length": 267}
{"ground_truth": ["<s>", "bool", "arc_split_move_p", "(", "rtx", "*", "operands", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "if", "(", "TARGET_LL64", "&&", "(", "(", "memory_operand", "(", "operands", "[", "0", "]", ",", "mode", ")", "&&", "(", "even_register_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", "||", "satisfies_constraint_Cm3", "(", "operands", "[", "1", "]", ")", ")", ")", "||", "(", "memory_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", "&&", "even_register_operand", "(", "operands", "[", "0", "]", ",", "mode", ")", ")", ")", ")", "return", "false", ";", "if", "(", "TARGET_PLUS_QMACW", "&&", "even_register_operand", "(", "operands", "[", "0", "]", ",", "mode", ")", "&&", "even_register_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Check", "if", "we", "need", "to", "split", "a", "64bit", "move", ".", "We", "do", "not", "need", "to", "split", "it", "if", "we", "can", "use", "vadd2", "or", "ldd/std", "instructions", "."], "TS_V_token": ["arc", "0", "0", "1", "1", "1", "0", "0", "1"], "File": "arc", "Func": "arc_split_move_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33756, "Length": 113}
{"ground_truth": ["<s>", "bool", "arc_split_mov_const", "(", "rtx", "*", "operands", ")", "{", "unsigned", "HOST_WIDE_INT", "ival", ";", "HOST_WIDE_INT", "shimm", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "gcc_assert", "(", "CONST_INT_P", "(", "operands", "[", "1", "]", ")", ")", ";", "ival", "=", "INTVAL", "(", "operands", "[", "1", "]", ")", "&", "0xffffffff", ";", "if", "(", "TARGET_BARREL_SHIFTER", "&&", "TARGET_V2", "&&", "(", "(", "ival", "&", "~", "0x3f000000", ")", "==", "0", ")", ")", "{", "shimm", "=", "(", "ival", ">>", "24", ")", "&", "0x3f", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "gen_rtx_ROTATERT", "(", "mode", ",", "GEN_INT", "(", "shimm", ")", ",", "GEN_INT", "(", "8", ")", ")", ")", ")", ";", "return", "true", ";", "}", "if", "(", "TARGET_BARREL_SHIFTER", "&&", "TARGET_V2", "&&", "(", "(", "ival", "&", "~", "0x3f00", ")", "==", "0", ")", ")", "{", "shimm", "=", "(", "ival", ">>", "8", ")", "&", "0x3f", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "gen_rtx_ASHIFT", "(", "mode", ",", "GEN_INT", "(", "shimm", ")", ",", "GEN_INT", "(", "8", ")", ")", ")", ")", ";", "return", "true", ";", "}", "if", "(", "TARGET_BARREL_SHIFTER", "&&", "TARGET_V2", "&&", "(", "(", "ival", "&", "~", "0x3f0000", ")", "==", "0", ")", ")", "{", "shimm", "=", "(", "ival", ">>", "16", ")", "&", "0x3f", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "gen_rtx_ASHIFT", "(", "mode", ",", "GEN_INT", "(", "shimm", ")", ",", "GEN_INT", "(", "16", ")", ")", ")", ")", ";", "return", "true", ";", "}", "if", "(", "(", "(", "ival", ">>", "(", "__builtin_ffs", "(", "ival", ")", "-", "1", ")", ")", "&", "0xffffff00", ")", "==", "0", "&&", "TARGET_BARREL_SHIFTER", ")", "{", "HOST_WIDE_INT", "shift", "=", "__builtin_ffs", "(", "ival", ")", ";", "shimm", "=", "(", "ival", ">>", "(", "shift", "-", "1", ")", ")", "&", "0xff", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "GEN_INT", "(", "shimm", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "gen_rtx_ASHIFT", "(", "mode", ",", "operands", "[", "0", "]", ",", "GEN_INT", "(", "shift", "-", "1", ")", ")", ")", ")", ";", "return", "true", ";", "}", "if", "(", "(", "ival", "&", "~", "0x8000001f", ")", "==", "0", ")", "{", "shimm", "=", "(", "ival", "*", "2", "+", "1", ")", "&", "0x3f", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "gen_rtx_ROTATERT", "(", "mode", ",", "GEN_INT", "(", "shimm", ")", ",", "const1_rtx", ")", ")", ")", ";", "return", "true", ";", "}", "if", "(", "IS_POWEROF2_P", "(", "ival", "+", "1", ")", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "constm1_rtx", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "gen_rtx_AND", "(", "mode", ",", "operands", "[", "0", "]", ",", "GEN_INT", "(", "ival", ")", ")", ")", ")", ";", "return", "true", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>"], "natrual_language": ["Split", "a", "mov", "with", "long", "immediate", "instruction", "into", "smaller", ",", "size", "friendly", "instructions", "."], "TS_V_token": ["arc", "0", "1", "1", "0xffffffff", "0x3f000000", "0", "24", "0x3f", "0", "8", "0x3f00", "0", "8", "0x3f", "0", "8", "0x3f0000", "0", "16", "0x3f", "0", "16", "1", "0xffffff00", "0", "1", "0xff", "0", "0", "0", "1", "0x8000001f", "0", "2", "1", "0x3f", "0", "1", "0", "0", "0"], "File": "arc", "Func": "arc_split_mov_const", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33757, "Length": 426}
{"ground_truth": ["<s>", "static", "bool", "arc_store_addr_hazard_internal_p", "(", "rtx_insn", "*", "producer", ",", "rtx_insn", "*", "consumer", ")", "{", "rtx", "in_set", ",", "out_set", ";", "rtx", "out_addr", ",", "in_addr", ";", "if", "(", "!", "producer", ")", "return", "false", ";", "if", "(", "!", "consumer", ")", "return", "false", ";", "out_set", "=", "single_set", "(", "producer", ")", ";", "if", "(", "out_set", ")", "{", "out_addr", "=", "SET_DEST", "(", "out_set", ")", ";", "if", "(", "!", "out_addr", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "out_addr", ")", "==", "ZERO_EXTEND", "||", "GET_CODE", "(", "out_addr", ")", "==", "SIGN_EXTEND", ")", "out_addr", "=", "XEXP", "(", "out_addr", ",", "0", ")", ";", "if", "(", "!", "MEM_P", "(", "out_addr", ")", ")", "return", "false", ";", "in_set", "=", "single_set", "(", "consumer", ")", ";", "if", "(", "in_set", ")", "{", "in_addr", "=", "SET_SRC", "(", "in_set", ")", ";", "if", "(", "!", "in_addr", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "in_addr", ")", "==", "ZERO_EXTEND", "||", "GET_CODE", "(", "in_addr", ")", "==", "SIGN_EXTEND", ")", "in_addr", "=", "XEXP", "(", "in_addr", ",", "0", ")", ";", "if", "(", "!", "MEM_P", "(", "in_addr", ")", ")", "return", "false", ";", "in_addr", "=", "XEXP", "(", "in_addr", ",", "0", ")", ";", "out_addr", "=", "XEXP", "(", "out_addr", ",", "0", ")", ";", "return", "exp_equiv_p", "(", "in_addr", ",", "out_addr", ",", "0", ",", "true", ")", ";", "}", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "a", "load", "instruction", "(", "CONSUMER", ")", "uses", "the", "same", "address", "as", "a", "store", "instruction", "(", "PRODUCER", ")", ".", "This", "function", "is", "used", "to", "avoid", "st/ld", "address", "hazard", "in", "ARC700", "cores", "."], "TS_V_token": ["arc", "0", "0", "0", "0", "0"], "File": "arc", "Func": "arc_store_addr_hazard_internal_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33758, "Length": 201}
{"ground_truth": ["<s>", "bool", "arc_store_addr_hazard_p", "(", "rtx_insn", "*", "producer", ",", "rtx_insn", "*", "consumer", ")", "{", "if", "(", "TARGET_ARC700", "&&", "(", "arc_tune", "!=", "ARC_TUNE_ARC7XX", ")", ")", "return", "true", ";", "return", "arc_store_addr_hazard_internal_p", "(", "producer", ",", "consumer", ")", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "a", "load", "instruction", "(", "CONSUMER", ")", "uses", "the", "same", "address", "as", "a", "store", "instruction", "(", "PRODUCER", ")", ".", "This", "function", "is", "used", "to", "avoid", "st/ld", "address", "hazard", "in", "ARC700", "cores", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_store_addr_hazard_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33759, "Length": 34}
{"ground_truth": ["<s>", "static", "bool", "arc_symbol_binds_local_p", "(", "const_rtx", "x", ")", "{", "return", "(", "SYMBOL_REF_DECL", "(", "x", ")", "?", "targetm", ".", "binds_local_p", "(", "SYMBOL_REF_DECL", "(", "x", ")", ")", ":", "SYMBOL_REF_LOCAL_P", "(", "x", ")", ")", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "SYMBOL_REF", "X", "binds", "locally", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_symbol_binds_local_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33760, "Length": 32}
{"ground_truth": ["<s>", "bool", "arc_text_label", "(", "rtx_insn", "*", "label", ")", "{", "rtx_insn", "*", "next", ";", "gcc_assert", "(", "GET_CODE", "(", "label", ")", "==", "CODE_LABEL", "||", "(", "GET_CODE", "(", "label", ")", "==", "NOTE", "&&", "NOTE_KIND", "(", "label", ")", "==", "NOTE_INSN_DELETED_LABEL", ")", ")", ";", "next", "=", "next_nonnote_insn", "(", "label", ")", ";", "if", "(", "next", ")", "return", "(", "!", "JUMP_TABLE_DATA_P", "(", "next", ")", "||", "GET_CODE", "(", "PATTERN", "(", "next", ")", ")", "!=", "ADDR_VEC", ")", ";", "else", "if", "(", "!", "PREV_INSN", "(", "label", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "LABEL", "is", "in", "executable", "code", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_text_label", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33761, "Length": 84}
{"ground_truth": ["<s>", "static", "char", "*", "arc_tolower", "(", "char", "*", "lo", ",", "const", "char", "*", "up", ")", "{", "char", "*", "lo0", "=", "lo", ";", "for", "(", ";", "*", "up", ";", "up", "++", ",", "lo", "++", ")", "*", "lo", "=", "TOLOWER", "(", "*", "up", ")", ";", "*", "lo", "=", "'\\0'", ";", "return", "lo0", ";", "}", "</s>"], "natrual_language": ["Transform", "UP", "into", "lowercase", "and", "write", "the", "result", "to", "LO", ".", "You", "must", "provide", "enough", "space", "for", "LO", ".", "Return", "LO", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_tolower", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33762, "Length": 51}
{"ground_truth": ["<s>", "int", "arc_unalign_branch_p", "(", "rtx", "branch", ")", "{", "rtx", "note", ";", "if", "(", "!", "TARGET_UNALIGN_BRANCH", ")", "return", "0", ";", "if", "(", "get_attr_delay_slot_filled", "(", "branch", ")", "==", "DELAY_SLOT_FILLED_YES", "&&", "!", "NEXT_INSN", "(", "branch", ")", "->", "deleted", "(", ")", ")", "return", "0", ";", "note", "=", "find_reg_note", "(", "branch", ",", "REG_BR_PROB", ",", "0", ")", ";", "return", "(", "!", "note", "||", "(", "arc_unalign_prob_threshold", "&&", "!", "br_prob_note_reliable_p", "(", "note", ")", ")", "||", "INTVAL", "(", "XEXP", "(", "note", ",", "0", ")", ")", "<", "arc_unalign_prob_threshold", ")", ";", "}", "</s>"], "natrual_language": ["Return", "nonzero", "iff", "BRANCH", "should", "be", "unaligned", "if", "possible", "by", "upsizing", "a", "previous", "instruction", "."], "TS_V_token": ["arc", "0", "0", "0", "0"], "File": "arc", "Func": "arc_unalign_branch_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33763, "Length": 80}
{"ground_truth": ["<s>", "static", "rtx", "arc_unspec_offset", "(", "rtx", "loc", ",", "int", "unspec", ")", "{", "return", "gen_rtx_CONST", "(", "Pmode", ",", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "loc", ")", ",", "unspec", ")", ")", ";", "}", "</s>"], "natrual_language": ["Helper", "to", "generate", "unspec", "constant", "."], "TS_V_token": ["arc", "1"], "File": "arc", "Func": "arc_unspec_offset", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33764, "Length": 32}
{"ground_truth": ["<s>", "static", "bool", "arc_use_anchors_for_symbol_p", "(", "const_rtx", "symbol", ")", "{", "if", "(", "SYMBOL_REF_TLS_MODEL", "(", "symbol", ")", ")", "return", "false", ";", "if", "(", "flag_pic", ")", "return", "false", ";", "if", "(", "SYMBOL_REF_SMALL_P", "(", "symbol", ")", ")", "return", "false", ";", "return", "default_use_anchors_for_symbol_p", "(", "symbol", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_USE_ANCHORS_FOR_SYMBOL_P", ".", "We", "do", "n't", "want", "to", "use", "anchors", "for", "small", "data", ":", "the", "GP", "register", "acts", "as", "an", "anchor", "in", "that", "case", ".", "We", "also", "do", "n't", "want", "to", "use", "them", "for", "PC-relative", "accesses", ",", "where", "the", "PC", "acts", "as", "an", "anchor", ".", "Prohibit", "also", "TLS", "symbols", "to", "use", "anchors", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_use_anchors_for_symbol_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33765, "Length": 42}
{"ground_truth": ["<s>", "static", "bool", "arc_use_by_pieces_infrastructure_p", "(", "unsigned", "HOST_WIDE_INT", "size", ",", "unsigned", "int", "align", ",", "enum", "by_pieces_operation", "op", ",", "bool", "speed_p", ")", "{", "if", "(", "op", "==", "MOVE_BY_PIECES", ")", "return", "false", ";", "return", "default_use_by_pieces_infrastructure_p", "(", "size", ",", "align", ",", "op", ",", "speed_p", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_USE_BY_PIECES_INFRASTRUCTURE_P", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_use_by_pieces_infrastructure_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33766, "Length": 42}
{"ground_truth": ["<s>", "static", "bool", "arc_vector_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_V2HImode", ":", "return", "TARGET_PLUS_DMPY", ";", "case", "E_V4HImode", ":", "case", "E_V2SImode", ":", "return", "TARGET_PLUS_QMACW", ";", "case", "E_V4SImode", ":", "case", "E_V8HImode", ":", "return", "TARGET_SIMD_SET", ";", "default", ":", "return", "false", ";", "}", "}", "</s>"], "natrual_language": ["Implements", "target", "hook", "vector_mode_supported_p", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_vector_mode_supported_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33767, "Length": 44}
{"ground_truth": ["<s>", "static", "int", "arc_verify_short", "(", "rtx_insn", "*", "insn", ",", "int", ",", "int", "check_attr", ")", "{", "enum", "attr_iscompact", "iscompact", ";", "if", "(", "check_attr", ">", "0", ")", "{", "iscompact", "=", "get_attr_iscompact", "(", "insn", ")", ";", "if", "(", "iscompact", "==", "ISCOMPACT_FALSE", ")", "return", "0", ";", "}", "return", "(", "get_attr_length", "(", "insn", ")", "&", "2", ")", "!=", "0", ";", "}", "</s>"], "natrual_language": ["Return", "non-zero", "if", "INSN", "should", "be", "output", "as", "a", "short", "insn", ".", "UNALIGN", "is", "zero", "if", "the", "current", "insn", "is", "aligned", "to", "a", "4-byte-boundary", ",", "two", "otherwise", ".", "If", "CHECK_ATTR", "is", "greater", "than", "0", ",", "check", "the", "iscompact", "attribute", "first", "."], "TS_V_token": ["arc", "0", "0", "2", "0"], "File": "arc", "Func": "arc_verify_short", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33768, "Length": 55}
{"ground_truth": ["<s>", "static", "bool", "arc_warn_func_return", "(", "tree", "decl", ")", "{", "struct", "function", "*", "func", "=", "DECL_STRUCT_FUNCTION", "(", "decl", ")", ";", "unsigned", "int", "fn_type", "=", "arc_compute_function_type", "(", "func", ")", ";", "return", "!", "ARC_NAKED_P", "(", "fn_type", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_WARN_FUNC_RETURN", "'", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "arc_warn_func_return", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33769, "Length": 35}
{"ground_truth": ["<s>", "int", "arc_write_ext_corereg", "(", "rtx", "insn", ")", "{", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "PATTERN", "(", "insn", ")", ",", "NONCONST", ")", "{", "const_rtx", "x", "=", "*", "iter", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "SET", ":", "case", "POST_INC", ":", "case", "POST_DEC", ":", "case", "PRE_INC", ":", "case", "PRE_DEC", ":", "break", ";", "default", ":", "continue", ";", "}", "const_rtx", "dest", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "REG_P", "(", "dest", ")", "&&", "REGNO", "(", "dest", ")", ">=", "32", "&&", "REGNO", "(", "dest", ")", "<", "61", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>"], "natrual_language": ["Return", "nonzreo", "iff", "INSN", "writes", "to", "an", "extension", "core", "register", "."], "TS_V_token": ["arc", "0", "32", "61", "1", "0"], "File": "arc", "Func": "arc_write_ext_corereg", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33770, "Length": 101}
{"ground_truth": ["<s>", "static", "int", "branch_dest", "(", "rtx", "branch", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "branch", ")", ";", "rtx", "dest", "=", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", "?", "SET_SRC", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ")", ":", "SET_SRC", "(", "pat", ")", ")", ";", "int", "dest_uid", ";", "if", "(", "GET_CODE", "(", "dest", ")", "==", "IF_THEN_ELSE", ")", "dest", "=", "XEXP", "(", "dest", ",", "XEXP", "(", "dest", ",", "1", ")", "==", "pc_rtx", "?", "2", ":", "1", ")", ";", "dest", "=", "XEXP", "(", "dest", ",", "0", ")", ";", "dest_uid", "=", "INSN_UID", "(", "dest", ")", ";", "return", "INSN_ADDRESSES", "(", "dest_uid", ")", ";", "}", "</s>"], "natrual_language": ["Return", "the", "destination", "address", "of", "BRANCH", ".", "We", "need", "to", "use", "this", "instead", "of", "get_attr_length", ",", "because", "the", "cbranch_with_nops", "pattern", "conservatively", "sets", "its", "length", "to", "6", ",", "and", "we", "still", "prefer", "to", "use", "shorter", "sequences", "."], "TS_V_token": ["arc", "0", "0", "1", "2", "1", "0"], "File": "arc", "Func": "branch_dest", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33771, "Length": 100}
{"ground_truth": ["<s>", "bool", "check_if_valid_regno_const", "(", "rtx", "*", "operands", ",", "int", "opno", ")", "{", "switch", "(", "GET_CODE", "(", "operands", "[", "opno", "]", ")", ")", "{", "case", "SYMBOL_REF", ":", "case", "CONST", ":", "case", "CONST_INT", ":", "return", "true", ";", "default", ":", "error", "(", "\"register number must be a compile-time constant.  \"", "\"Try giving higher optimization levels\"", ")", ";", "break", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Returns", "true", "if", "the", "operands", "[", "opno", "]", "is", "a", "valid", "compile-time", "constant", "to", "be", "used", "as", "register", "number", "in", "the", "code", "for", "builtins", ".", "Else", "it", "flags", "an", "error", "and", "returns", "false", "."], "TS_V_token": ["arc", "\"register number must be a compile-time constant.  \"", "\"Try giving higher optimization levels\""], "File": "arc", "Func": "check_if_valid_regno_const", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33772, "Length": 49}
{"ground_truth": ["<s>", "static", "void", "check_store_cacheline_hazard", "(", "void", ")", "{", "rtx_insn", "*", "insn", ",", "*", "succ0", ",", "*", "insn1", ";", "bool", "found", "=", "false", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "arc_active_insn", "(", "insn", ")", ")", "{", "succ0", "=", "arc_active_insn", "(", "insn", ")", ";", "if", "(", "!", "succ0", ")", "return", ";", "if", "(", "!", "single_set", "(", "insn", ")", ")", "continue", ";", "if", "(", "(", "get_attr_type", "(", "insn", ")", "!=", "TYPE_STORE", ")", ")", "continue", ";", "for", "(", "insn1", "=", "succ0", ";", "insn1", ";", "insn1", "=", "arc_active_insn", "(", "insn1", ")", ")", "if", "(", "!", "single_set", "(", "insn1", ")", "||", "get_attr_type", "(", "insn1", ")", "!=", "TYPE_STORE", ")", "break", ";", "succ0", "=", "insn1", ";", "if", "(", "insn1", "&&", "single_set", "(", "insn1", ")", "&&", "(", "get_attr_type", "(", "insn1", ")", "==", "TYPE_LOAD", ")", ")", "{", "found", "=", "true", ";", "emit_insn_before", "(", "gen_nopv", "(", ")", ",", "insn1", ")", ";", "emit_insn_before", "(", "gen_nopv", "(", ")", ",", "insn1", ")", ";", "}", "else", "{", "if", "(", "insn1", "&&", "(", "get_attr_type", "(", "insn1", ")", "==", "TYPE_COMPARE", ")", ")", "{", "add_reg_note", "(", "insn1", ",", "REG_SAVE_NOTE", ",", "GEN_INT", "(", "3", ")", ")", ";", "}", "insn1", "=", "arc_active_insn", "(", "insn1", ")", ";", "if", "(", "insn1", "&&", "single_set", "(", "insn1", ")", "&&", "(", "get_attr_type", "(", "insn1", ")", "==", "TYPE_LOAD", ")", ")", "{", "found", "=", "true", ";", "emit_insn_before", "(", "gen_nopv", "(", ")", ",", "insn1", ")", ";", "}", "}", "if", "(", "found", ")", "{", "insn", "=", "insn1", ";", "found", "=", "false", ";", "}", "else", "insn", "=", "succ0", ";", "}", "}", "</s>"], "natrual_language": ["Search", "for", "a", "sequence", "made", "out", "of", "two", "stores", "and", "a", "given", "number", "of", "loads", ",", "insert", "a", "nop", "if", "required", "."], "TS_V_token": ["arc", "3"], "File": "arc", "Func": "check_store_cacheline_hazard", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33773, "Length": 246}
{"ground_truth": ["<s>", "bool", "compact_sda_memory_operand", "(", "rtx", "op", ",", "machine_mode", "mode", ",", "bool", "short_p", ")", "{", "rtx", "addr", ";", "int", "size", ";", "int", "align", "=", "0", ";", "int", "mask", "=", "0", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "false", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "GET_MODE", "(", "op", ")", ";", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "size", ">", "UNITS_PER_WORD", ")", "return", "false", ";", "addr", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "!", "legitimate_small_data_address_p", "(", "addr", ",", "mode", ")", ")", "return", "false", ";", "if", "(", "!", "short_p", "||", "size", "==", "1", ")", "return", "true", ";", "align", "=", "get_symbol_alignment", "(", "addr", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_HImode", ":", "mask", "=", "1", ";", "break", ";", "default", ":", "mask", "=", "3", ";", "break", ";", "}", "if", "(", "align", "&&", "(", "(", "align", "&", "mask", ")", "==", "0", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["volatile", "cache", "option", "still", "to", "be", "handled", "."], "TS_V_token": ["arc", "0", "0", "0", "1", "1", "3", "0"], "File": "arc", "Func": "compact_sda_memory_operand", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33774, "Length": 155}
{"ground_truth": ["<s>", "static", "rtx", "conditionalize_nonjump", "(", "rtx", "pat", ",", "rtx", "cond", ",", "rtx", "insn", ",", "bool", "annulled", ")", "{", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SET", ")", "{", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "if", "(", "COMMUTATIVE_P", "(", "src", ")", ")", "{", "rtx", "src0", "=", "XEXP", "(", "src", ",", "0", ")", ";", "rtx", "src1", "=", "XEXP", "(", "src", ",", "1", ")", ";", "rtx", "dst", "=", "SET_DEST", "(", "pat", ")", ";", "if", "(", "rtx_equal_p", "(", "src1", ",", "dst", ")", "&&", "!", "rtx_equal_p", "(", "src0", ",", "dst", ")", "&&", "REG_P", "(", "src0", ")", ")", "pat", "=", "gen_rtx_SET", "(", "dst", ",", "gen_rtx_fmt_ee", "(", "GET_CODE", "(", "src", ")", ",", "GET_MODE", "(", "src", ")", ",", "src1", ",", "src0", ")", ")", ";", "}", "}", "if", "(", "RTX_FRAME_RELATED_P", "(", "insn", ")", ")", "{", "gcc_assert", "(", "annulled", ")", ";", "rtx", "note", "=", "alloc_reg_note", "(", "REG_FRAME_RELATED_EXPR", ",", "pat", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "validate_change", "(", "insn", ",", "&", "REG_NOTES", "(", "insn", ")", ",", "note", ",", "1", ")", ";", "}", "pat", "=", "gen_rtx_COND_EXEC", "(", "VOIDmode", ",", "cond", ",", "pat", ")", ";", "return", "pat", ";", "}", "</s>"], "natrual_language": ["Return", "version", "of", "PAT", "conditionalized", "with", "COND", ",", "which", "is", "part", "of", "INSN", ".", "ANNULLED", "indicates", "if", "INSN", "is", "an", "annulled", "delay-slot", "insn", ".", "Register", "further", "changes", "if", "necessary", "."], "TS_V_token": ["arc", "0", "1", "1"], "File": "arc", "Func": "conditionalize_nonjump", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33775, "Length": 178}
{"ground_truth": ["<s>", "rtx", "disi_highpart", "(", "rtx", "in", ")", "{", "return", "simplify_gen_subreg", "(", "SImode", ",", "in", ",", "DImode", ",", "TARGET_BIG_ENDIAN", "?", "0", ":", "4", ")", ";", "}", "</s>"], "natrual_language": ["Return", "the", "SImode", "highpart", "of", "the", "DImode", "value", "IN", "."], "TS_V_token": ["arc", "0", "4"], "File": "arc", "Func": "disi_highpart", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33776, "Length": 24}
{"ground_truth": ["<s>", "void", "emit_shift", "(", "enum", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "op1", ",", "rtx", "op2", ")", "{", "rtx", "shift", "=", "gen_rtx_fmt_ee", "(", "code", ",", "SImode", ",", "op1", ",", "op2", ")", ";", "rtx", "pat", "=", "(", "(", "shift4_operator", "(", "shift", ",", "SImode", ")", "?", "gen_shift_si3", ":", "gen_shift_si3_loop", ")", "(", "op0", ",", "op1", ",", "op2", ",", "shift", ")", ")", ";", "emit_insn", "(", "pat", ")", ";", "}", "</s>"], "natrual_language": ["Emit", "a", "shift", "insn", "to", "set", "OP0", "to", "OP1", "shifted", "by", "OP2", ";", "CODE", "specifies", "what", "kind", "of", "shift", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "emit_shift", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33777, "Length": 64}
{"ground_truth": ["<s>", "static", "void", "emit_unlikely_jump", "(", "rtx", "insn", ")", "{", "rtx_insn", "*", "jump", "=", "emit_jump_insn", "(", "insn", ")", ";", "add_reg_br_prob_note", "(", "jump", ",", "profile_probability", "::", "very_unlikely", "(", ")", ")", ";", "}", "</s>"], "natrual_language": ["Mark", "the", "previous", "jump", "instruction", "as", "unlikely", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "emit_unlikely_jump", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33778, "Length": 29}
{"ground_truth": ["<s>", "virtual", "unsigned", "int", "execute", "(", "function", "*", ")", "{", "return", "arc_predicate_delay_insns", "(", ")", ";", "}", "</s>"], "natrual_language": ["Main", "entry", "point", "for", "this", "pass", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "execute", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33779, "Length": 15}
{"ground_truth": ["<s>", "static", "rtx", "frame_add", "(", "rtx", "reg", ",", "HOST_WIDE_INT", "offset", ")", "{", "gcc_assert", "(", "(", "offset", "&", "0x3", ")", "==", "0", ")", ";", "if", "(", "!", "offset", ")", "return", "NULL_RTX", ";", "return", "frame_move", "(", "reg", ",", "plus_constant", "(", "Pmode", ",", "reg", ",", "offset", ")", ")", ";", "}", "</s>"], "natrual_language": ["Emit", "a", "frame", "insn", "which", "adjusts", "a", "frame", "address", "register", "REG", "by", "OFFSET", "."], "TS_V_token": ["arc", "0x3", "0"], "File": "arc", "Func": "frame_add", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33780, "Length": 46}
{"ground_truth": ["<s>", "static", "rtx", "frame_insn", "(", "rtx", "x", ")", "{", "x", "=", "emit_insn", "(", "x", ")", ";", "RTX_FRAME_RELATED_P", "(", "x", ")", "=", "1", ";", "return", "x", ";", "}", "</s>"], "natrual_language": ["Emit", "the", "specified", "insn", "and", "mark", "it", "as", "frame", "related", ".", "FIXME", ":", "Rename", "this", "to", "emit_frame_insn", "."], "TS_V_token": ["arc", "1"], "File": "arc", "Func": "frame_insn", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33781, "Length": 26}
{"ground_truth": ["<s>", "static", "rtx", "frame_move", "(", "rtx", "dst", ",", "rtx", "src", ")", "{", "rtx", "tmp", "=", "gen_rtx_SET", "(", "dst", ",", "src", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "return", "frame_insn", "(", "tmp", ")", ";", "}", "</s>"], "natrual_language": ["Emit", "a", "frame", "insn", "to", "move", "SRC", "to", "DST", "."], "TS_V_token": ["arc", "1"], "File": "arc", "Func": "frame_move", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33782, "Length": 35}
{"ground_truth": ["<s>", "static", "rtx", "frame_move_inc", "(", "rtx", "dst", ",", "rtx", "src", ",", "rtx", "reg", ",", "rtx", "addr", ")", "{", "rtx", "insn", "=", "frame_move", "(", "dst", ",", "src", ")", ";", "if", "(", "!", "addr", "||", "GET_CODE", "(", "addr", ")", "==", "PRE_DEC", "||", "GET_CODE", "(", "addr", ")", "==", "POST_INC", "||", "GET_CODE", "(", "addr", ")", "==", "PRE_MODIFY", "||", "GET_CODE", "(", "addr", ")", "==", "POST_MODIFY", ")", "add_reg_note", "(", "insn", ",", "REG_INC", ",", "reg", ")", ";", "return", "insn", ";", "}", "</s>"], "natrual_language": ["Like", "frame_move", ",", "but", "add", "a", "REG_INC", "note", "for", "REG", "if", "ADDR", "contains", "an", "auto", "increment", "address", ",", "or", "is", "zero", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "frame_move_inc", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33783, "Length": 73}
{"ground_truth": ["<s>", "static", "int", "frame_restore_reg", "(", "rtx", "reg", ",", "HOST_WIDE_INT", "offset", ")", "{", "rtx", "addr", ",", "insn", ";", "if", "(", "offset", ")", "{", "rtx", "tmp", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", "+", "GET_MODE_SIZE", "(", "GET_MODE", "(", "reg", ")", ")", ")", ";", "addr", "=", "gen_frame_mem", "(", "GET_MODE", "(", "reg", ")", ",", "gen_rtx_POST_MODIFY", "(", "Pmode", ",", "stack_pointer_rtx", ",", "tmp", ")", ")", ";", "}", "else", "addr", "=", "gen_frame_mem", "(", "GET_MODE", "(", "reg", ")", ",", "gen_rtx_POST_INC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ")", ";", "insn", "=", "frame_move_inc", "(", "reg", ",", "addr", ",", "stack_pointer_rtx", ",", "0", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "reg", ")", ";", "if", "(", "reg", "==", "hard_frame_pointer_rtx", ")", "add_reg_note", "(", "insn", ",", "REG_CFA_DEF_CFA", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GET_MODE_SIZE", "(", "GET_MODE", "(", "reg", ")", ")", "+", "offset", ")", ")", ";", "else", "add_reg_note", "(", "insn", ",", "REG_CFA_ADJUST_CFA", ",", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GET_MODE_SIZE", "(", "GET_MODE", "(", "reg", ")", ")", "+", "offset", ")", ")", ")", ";", "return", "GET_MODE_SIZE", "(", "GET_MODE", "(", "reg", ")", ")", "+", "offset", ";", "}", "</s>"], "natrual_language": ["Helper", "for", "epilogue", ":", "emit", "frame", "load", "with", "post_modify", "or", "post_inc", "to", "restore", "register", "REG", "from", "stack", ".", "The", "initial", "offset", "is", "passed", "via", "OFFSET", "."], "TS_V_token": ["arc", "0"], "File": "arc", "Func": "frame_restore_reg", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33784, "Length": 173}
{"ground_truth": ["<s>", "static", "int", "frame_save_reg", "(", "rtx", "reg", ",", "HOST_WIDE_INT", "offset", ")", "{", "rtx", "addr", ";", "if", "(", "offset", ")", "{", "rtx", "tmp", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", "-", "GET_MODE_SIZE", "(", "GET_MODE", "(", "reg", ")", ")", ")", ";", "addr", "=", "gen_frame_mem", "(", "GET_MODE", "(", "reg", ")", ",", "gen_rtx_PRE_MODIFY", "(", "Pmode", ",", "stack_pointer_rtx", ",", "tmp", ")", ")", ";", "}", "else", "addr", "=", "gen_frame_mem", "(", "GET_MODE", "(", "reg", ")", ",", "gen_rtx_PRE_DEC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ")", ";", "frame_move_inc", "(", "addr", ",", "reg", ",", "stack_pointer_rtx", ",", "0", ")", ";", "return", "GET_MODE_SIZE", "(", "GET_MODE", "(", "reg", ")", ")", "-", "offset", ";", "}", "</s>"], "natrual_language": ["Helper", "for", "prologue", ":", "emit", "frame", "store", "with", "pre_modify", "or", "pre_dec", "to", "save", "register", "REG", "on", "stack", ".", "An", "initial", "offset", "OFFSET", "can", "be", "passed", "to", "the", "function", "."], "TS_V_token": ["arc", "0"], "File": "arc", "Func": "frame_save_reg", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33785, "Length": 100}
{"ground_truth": ["<s>", "static", "rtx", "frame_stack_add", "(", "HOST_WIDE_INT", "offset", ")", "{", "return", "frame_add", "(", "stack_pointer_rtx", ",", "offset", ")", ";", "}", "</s>"], "natrual_language": ["Emit", "a", "frame", "insn", "which", "adjusts", "stack", "pointer", "by", "OFFSET", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "frame_stack_add", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33786, "Length": 17}
{"ground_truth": ["<s>", "rtx", "gen_acc1", "(", "void", ")", "{", "return", "gen_rtx_REG", "(", "SImode", ",", "TARGET_BIG_ENDIAN", "?", "56", ":", "57", ")", ";", "}", "</s>"], "natrual_language": ["Return", "a", "REG", "rtx", "for", "acc1", ".", "N.B", ".", "the", "gcc-internal", "representation", "may", "differ", "from", "the", "hardware", "register", "number", "in", "order", "to", "allow", "the", "generic", "code", "to", "correctly", "split", "the", "concatenation", "of", "acc1", "and", "acc2", "."], "TS_V_token": ["arc", "56", "57"], "File": "arc", "Func": "gen_acc1", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33787, "Length": 19}
{"ground_truth": ["<s>", "rtx", "gen_acc2", "(", "void", ")", "{", "return", "gen_rtx_REG", "(", "SImode", ",", "TARGET_BIG_ENDIAN", "?", "57", ":", "56", ")", ";", "}", "</s>"], "natrual_language": ["Return", "a", "REG", "rtx", "for", "acc2", ".", "N.B", ".", "the", "gcc-internal", "representation", "may", "differ", "from", "the", "hardware", "register", "number", "in", "order", "to", "allow", "the", "generic", "code", "to", "correctly", "split", "the", "concatenation", "of", "acc1", "and", "acc2", "."], "TS_V_token": ["arc", "57", "56"], "File": "arc", "Func": "gen_acc2", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33788, "Length": 19}
{"ground_truth": ["<s>", "bool", "gen_operands_ldd_std", "(", "rtx", "*", "operands", ",", "bool", "load", ",", "bool", "commute", ")", "{", "int", "i", ",", "gap", ";", "HOST_WIDE_INT", "offsets", "[", "2", "]", ",", "offset", ";", "int", "nops", "=", "2", ";", "rtx", "cur_base", ",", "cur_offset", ",", "tmp", ";", "rtx", "base", "=", "NULL_RTX", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nops", ";", "i", "++", ")", "{", "if", "(", "!", "mem_ok_for_ldd_std", "(", "operands", "[", "nops", "+", "i", "]", ",", "&", "cur_base", ",", "&", "cur_offset", ")", ")", "return", "false", ";", "if", "(", "i", "==", "0", ")", "base", "=", "cur_base", ";", "else", "if", "(", "REGNO", "(", "base", ")", "!=", "REGNO", "(", "cur_base", ")", ")", "return", "false", ";", "offsets", "[", "i", "]", "=", "INTVAL", "(", "cur_offset", ")", ";", "if", "(", "GET_CODE", "(", "operands", "[", "i", "]", ")", "==", "SUBREG", ")", "{", "tmp", "=", "SUBREG_REG", "(", "operands", "[", "i", "]", ")", ";", "gcc_assert", "(", "GET_MODE", "(", "operands", "[", "i", "]", ")", "==", "GET_MODE", "(", "tmp", ")", ")", ";", "operands", "[", "i", "]", "=", "tmp", ";", "}", "}", "if", "(", "load", "&&", "REGNO", "(", "operands", "[", "0", "]", ")", "==", "REGNO", "(", "base", ")", ")", "return", "false", ";", "if", "(", "load", "&&", "REGNO", "(", "operands", "[", "0", "]", ")", "==", "REGNO", "(", "operands", "[", "1", "]", ")", ")", "return", "false", ";", "if", "(", "offsets", "[", "0", "]", ">", "offsets", "[", "1", "]", ")", "{", "gap", "=", "offsets", "[", "0", "]", "-", "offsets", "[", "1", "]", ";", "offset", "=", "offsets", "[", "1", "]", ";", "std", "::", "swap", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "std", "::", "swap", "(", "operands", "[", "2", "]", ",", "operands", "[", "3", "]", ")", ";", "}", "else", "{", "gap", "=", "offsets", "[", "1", "]", "-", "offsets", "[", "0", "]", ";", "offset", "=", "offsets", "[", "0", "]", ";", "}", "if", "(", "gap", "!=", "4", ")", "return", "false", ";", "if", "(", "operands_ok_ldd_std", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "offset", ")", ")", "return", "true", ";", "if", "(", "load", "&&", "commute", ")", "{", "std", "::", "swap", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "if", "(", "operands_ok_ldd_std", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "offset", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Called", "from", "peephole2", "to", "replace", "two", "word-size", "accesses", "with", "a", "single", "LDD/STD", "instruction", ".", "Returns", "true", "iff", "we", "can", "generate", "a", "new", "instruction", "sequence", ".", "That", "is", ",", "both", "accesses", "use", "the", "same", "base", "register", "and", "the", "gap", "between", "constant", "offsets", "is", "4", ".", "OPERANDS", "are", "the", "operands", "found", "by", "the", "peephole", "matcher", ";", "OPERANDS", "[", "0,1", "]", "are", "register", "operands", ",", "and", "OPERANDS", "[", "2,3", "]", "are", "the", "corresponding", "memory", "operands", ".", "LOAD", "indicates", "whether", "the", "access", "is", "load", "or", "store", "."], "TS_V_token": ["arc", "2", "2", "0", "0", "0", "0", "1", "0", "1", "0", "1", "1", "0", "1", "2", "3", "1", "0", "0", "4", "0", "1", "0", "1", "0", "1"], "File": "arc", "Func": "gen_operands_ldd_std", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33789, "Length": 368}
{"ground_truth": ["<s>", "static", "int", "get_symbol_alignment", "(", "rtx", "x", ")", "{", "tree", "decl", "=", "NULL_TREE", ";", "int", "align", "=", "0", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "SYMBOL_REF", ":", "decl", "=", "SYMBOL_REF_DECL", "(", "x", ")", ";", "break", ";", "case", "CONST", ":", "return", "get_symbol_alignment", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "case", "PLUS", ":", "gcc_assert", "(", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ";", "return", "get_symbol_alignment", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "default", ":", "return", "0", ";", "}", "if", "(", "decl", ")", "align", "=", "DECL_ALIGN", "(", "decl", ")", ";", "align", "=", "align", "/", "BITS_PER_UNIT", ";", "return", "align", ";", "}", "</s>"], "natrual_language": ["Given", "a", "symbol", "RTX", "(", "const", "(", "symb", "<", "+", "const_int", ">", ")", ",", "returns", "its", "alignment", "."], "TS_V_token": ["arc", "0", "0", "1", "0", "0"], "File": "arc", "Func": "get_symbol_alignment", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33790, "Length": 106}
{"ground_truth": ["<s>", "static", "void", "hwloop_fail", "(", "hwloop_info", "loop", ")", "{", "rtx", "test", ";", "rtx", "insn", "=", "loop", "->", "loop_end", ";", "if", "(", "TARGET_DBNZ", "&&", "(", "loop", "->", "length", "&&", "(", "loop", "->", "length", "<=", "ARC_MAX_LOOP_LENGTH", ")", ")", "&&", "REG_P", "(", "loop", "->", "iter_reg", ")", ")", "{", "test", "=", "gen_dbnz", "(", "loop", "->", "iter_reg", ",", "loop", "->", "start_label", ")", ";", "insn", "=", "emit_jump_insn_before", "(", "test", ",", "loop", "->", "loop_end", ")", ";", "}", "else", "if", "(", "REG_P", "(", "loop", "->", "iter_reg", ")", "&&", "(", "REGNO", "(", "loop", "->", "iter_reg", ")", "==", "LP_COUNT", ")", ")", "{", "emit_insn_before", "(", "gen_loop_fail", "(", ")", ",", "loop", "->", "loop_end", ")", ";", "test", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "CC_ZNmode", ",", "CC_REG", ")", ",", "const0_rtx", ")", ";", "test", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "test", ",", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "loop", "->", "start_label", ")", ",", "pc_rtx", ")", ";", "insn", "=", "emit_jump_insn_before", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "test", ")", ",", "loop", "->", "loop_end", ")", ";", "}", "else", "{", "emit_insn_before", "(", "gen_addsi3", "(", "loop", "->", "iter_reg", ",", "loop", "->", "iter_reg", ",", "constm1_rtx", ")", ",", "loop", "->", "loop_end", ")", ";", "test", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "loop", "->", "iter_reg", ",", "const0_rtx", ")", ";", "insn", "=", "emit_jump_insn_before", "(", "gen_cbranchsi4", "(", "test", ",", "loop", "->", "iter_reg", ",", "const0_rtx", ",", "loop", "->", "start_label", ")", ",", "loop", "->", "loop_end", ")", ";", "}", "JUMP_LABEL", "(", "insn", ")", "=", "loop", "->", "start_label", ";", "LABEL_NUSES", "(", "loop", "->", "start_label", ")", "++", ";", "delete_insn", "(", "loop", "->", "loop_end", ")", ";", "}", "</s>"], "natrual_language": ["A", "callback", "for", "the", "hw-doloop", "pass", ".", "Called", "when", "a", "loop", "we", "have", "discovered", "turns", "out", "not", "to", "be", "optimizable", ";", "we", "have", "to", "split", "the", "doloop_end", "pattern", "into", "a", "subtract", "and", "a", "test", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "hwloop_fail", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33791, "Length": 240}
{"ground_truth": ["<s>", "static", "rtx", "hwloop_pattern_reg", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "reg", ";", "if", "(", "!", "JUMP_P", "(", "insn", ")", "||", "recog_memoized", "(", "insn", ")", "!=", "CODE_FOR_loop_end", ")", "return", "NULL_RTX", ";", "reg", "=", "SET_DEST", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "1", ")", ")", ";", "if", "(", "!", "REG_P", "(", "reg", ")", ")", "return", "NULL_RTX", ";", "return", "reg", ";", "}", "</s>"], "natrual_language": ["A", "callback", "for", "the", "hw-doloop", "pass", ".", "This", "function", "examines", "INSN", ";", "if", "it", "is", "a", "doloop_end", "pattern", "we", "recognize", ",", "return", "the", "reg", "rtx", "for", "the", "loop", "counter", ".", "Otherwise", ",", "return", "NULL_RTX", "."], "TS_V_token": ["arc", "0", "1"], "File": "arc", "Func": "hwloop_pattern_reg", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33792, "Length": 62}
{"ground_truth": ["<s>", "static", "void", "irq_range", "(", "const", "char", "*", "cstr", ")", "{", "int", "i", ",", "first", ",", "last", ",", "blink", ",", "lpcount", ",", "xreg", ";", "char", "*", "str", ",", "*", "dash", ",", "*", "comma", ";", "i", "=", "strlen", "(", "cstr", ")", ";", "str", "=", "(", "char", "*", ")", "alloca", "(", "i", "+", "1", ")", ";", "memcpy", "(", "str", ",", "cstr", ",", "i", "+", "1", ")", ";", "blink", "=", "-", "1", ";", "lpcount", "=", "-", "1", ";", "dash", "=", "strchr", "(", "str", ",", "'-'", ")", ";", "if", "(", "!", "dash", ")", "{", "warning", "(", "OPT_mirq_ctrl_saved_", ",", "\"missing dash\"", ")", ";", "return", ";", "}", "*", "dash", "=", "'\\0'", ";", "comma", "=", "strchr", "(", "dash", "+", "1", ",", "','", ")", ";", "if", "(", "comma", ")", "*", "comma", "=", "'\\0'", ";", "first", "=", "decode_reg_name", "(", "str", ")", ";", "if", "(", "first", "!=", "0", ")", "{", "warning", "(", "OPT_mirq_ctrl_saved_", ",", "\"first register must be R0\"", ")", ";", "return", ";", "}", "if", "(", "!", "strcmp", "(", "dash", "+", "1", ",", "\"ilink\"", ")", ")", "last", "=", "29", ";", "else", "last", "=", "decode_reg_name", "(", "dash", "+", "1", ")", ";", "if", "(", "last", "<", "0", ")", "{", "warning", "(", "OPT_mirq_ctrl_saved_", ",", "\"unknown register name: %s\"", ",", "dash", "+", "1", ")", ";", "return", ";", "}", "if", "(", "!", "(", "last", "&", "0x01", ")", ")", "{", "warning", "(", "OPT_mirq_ctrl_saved_", ",", "\"last register name %s must be an odd register\"", ",", "dash", "+", "1", ")", ";", "return", ";", "}", "*", "dash", "=", "'-'", ";", "if", "(", "first", ">", "last", ")", "{", "warning", "(", "OPT_mirq_ctrl_saved_", ",", "\"%s-%s is an empty range\"", ",", "str", ",", "dash", "+", "1", ")", ";", "return", ";", "}", "while", "(", "comma", ")", "{", "*", "comma", "=", "','", ";", "str", "=", "comma", "+", "1", ";", "comma", "=", "strchr", "(", "str", ",", "','", ")", ";", "if", "(", "comma", ")", "*", "comma", "=", "'\\0'", ";", "xreg", "=", "decode_reg_name", "(", "str", ")", ";", "switch", "(", "xreg", ")", "{", "case", "31", ":", "blink", "=", "31", ";", "break", ";", "case", "60", ":", "lpcount", "=", "60", ";", "break", ";", "default", ":", "warning", "(", "OPT_mirq_ctrl_saved_", ",", "\"unknown register name: %s\"", ",", "str", ")", ";", "return", ";", "}", "}", "irq_ctrl_saved", ".", "irq_save_last_reg", "=", "last", ";", "irq_ctrl_saved", ".", "irq_save_blink", "=", "(", "blink", "==", "31", ")", "||", "(", "last", "==", "31", ")", ";", "irq_ctrl_saved", ".", "irq_save_lpcount", "=", "(", "lpcount", "==", "60", ")", ";", "}", "</s>"], "natrual_language": ["Parse", "-mirq-ctrl-saved=RegisterRange", ",", "blink", ",", "lp_copunt", ".", "The", "register", "range", "is", "specified", "as", "two", "registers", "separated", "by", "a", "dash", ".", "It", "always", "starts", "with", "r0", ",", "and", "its", "upper", "limit", "is", "fp", "register", ".", "blink", "and", "lp_count", "registers", "are", "optional", "."], "TS_V_token": ["arc", "1", "1", "1", "1", "\"missing dash\"", "1", "0", "\"first register must be R0\"", "1", "\"ilink\"", "29", "1", "0", "\"unknown register name: %s\"", "1", "0x01", "\"last register name %s must be an odd register\"", "1", "\"%s-%s is an empty range\"", "1", "1", "31", "31", "60", "60", "\"unknown register name: %s\"", "31", "31", "60"], "File": "arc", "Func": "irq_range", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33793, "Length": 359}
{"ground_truth": ["<s>", "static", "void", "jli_call_scan", "(", "void", ")", "{", "rtx_insn", "*", "insn", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "!", "CALL_P", "(", "insn", ")", ")", "continue", ";", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "COND_EXEC", ")", "pat", "=", "COND_EXEC_CODE", "(", "pat", ")", ";", "pat", "=", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SET", ")", "pat", "=", "SET_SRC", "(", "pat", ")", ";", "pat", "=", "XEXP", "(", "XEXP", "(", "pat", ",", "0", ")", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SYMBOL_REF", "&&", "arc_is_jli_call_p", "(", "pat", ")", ")", "arc_add_jli_section", "(", "pat", ")", ";", "}", "}", "</s>"], "natrual_language": ["Scan", "all", "calls", "and", "add", "symbols", "to", "be", "emitted", "in", "the", "jli", "section", "if", "needed", "."], "TS_V_token": ["arc", "0", "0", "0", "0"], "File": "arc", "Func": "jli_call_scan", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33794, "Length": 125}
{"ground_truth": ["<s>", "static", "bool", "legitimate_offset_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "index", ",", "bool", "strict", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "!=", "PLUS", ")", "return", "false", ";", "if", "(", "!", "RTX_OK_FOR_BASE_P", "(", "XEXP", "(", "x", ",", "0", ")", ",", "(", "strict", ")", ")", ")", "return", "false", ";", "if", "(", "(", "(", "index", "&&", "RTX_OK_FOR_INDEX_P", "(", "XEXP", "(", "x", ",", "1", ")", ",", "(", "strict", ")", ")", "&&", "GET_MODE_SIZE", "(", "(", "mode", ")", ")", "<=", "4", ")", "||", "RTX_OK_FOR_OFFSET_P", "(", "mode", ",", "XEXP", "(", "x", ",", "1", ")", ")", ")", ")", "return", "true", ";", "if", "(", "!", "flag_pic", "&&", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "SYMBOL_REF", ")", "&&", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "4", ")", "&&", "(", "!", "SYMBOL_REF_SMALL_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Check", "for", "constructions", "like", "REG", "+", "OFFS", ",", "where", "OFFS", "can", "be", "a", "register", ",", "an", "immediate", "or", "an", "long", "immediate", "."], "TS_V_token": ["arc", "0", "1", "4", "1", "1", "4", "1"], "File": "arc", "Func": "legitimate_offset_address_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33795, "Length": 143}
{"ground_truth": ["<s>", "static", "bool", "legitimate_scaled_address_p", "(", "machine_mode", "mode", ",", "rtx", "op", ",", "bool", "strict", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "!=", "PLUS", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "!=", "MULT", ")", "return", "false", ";", "if", "(", "!", "RTX_OK_FOR_INDEX_P", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "0", ")", ",", "strict", ")", ")", "return", "false", ";", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ")", ")", "return", "false", ";", "switch", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", "{", "case", "2", ":", "if", "(", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ")", "!=", "2", ")", "return", "false", ";", "break", ";", "case", "8", ":", "if", "(", "!", "TARGET_LL64", ")", "return", "false", ";", "case", "4", ":", "if", "(", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ")", "!=", "4", ")", "return", "false", ";", "default", ":", "return", "false", ";", "}", "if", "(", "RTX_OK_FOR_BASE_P", "(", "XEXP", "(", "op", ",", "1", ")", ",", "(", "strict", ")", ")", ")", "return", "true", ";", "if", "(", "flag_pic", ")", "{", "if", "(", "CONST_INT_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "if", "(", "legitimate_small_data_address_p", "(", "op", ",", "mode", ")", ")", "return", "false", ";", "if", "(", "CONSTANT_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["TRUE", "if", "op", "is", "an", "scaled", "address", "."], "TS_V_token": ["arc", "0", "0", "0", "0", "1", "2", "0", "1", "2", "8", "4", "0", "1", "4", "1", "1", "1"], "File": "arc", "Func": "legitimate_scaled_address_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33796, "Length": 238}
{"ground_truth": ["<s>", "static", "bool", "legitimate_small_data_address_p", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST", ":", "return", "legitimate_small_data_address_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "mode", ")", ";", "case", "SYMBOL_REF", ":", "return", "SYMBOL_REF_SMALL_P", "(", "x", ")", ";", "case", "PLUS", ":", "{", "bool", "p0", "=", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", "&&", "SYMBOL_REF_SMALL_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "return", "false", ";", "switch", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", "{", "case", "1", ":", "return", "p0", ";", "case", "2", ":", "return", "p0", "&&", "(", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&", "0x1", ")", "==", "0", ")", ";", "case", "4", ":", "case", "8", ":", "return", "p0", "&&", "(", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&", "0x3", ")", "==", "0", ")", ";", "default", ":", "return", "false", ";", "}", "}", "default", ":", "return", "false", ";", "}", "}", "</s>"], "natrual_language": ["Return", "true", "if", "x", "is", "ok", "to", "be", "used", "as", "a", "small", "data", "address", "."], "TS_V_token": ["arc", "0", "0", "0", "1", "1", "2", "1", "0x1", "0", "4", "8", "1", "0x3", "0"], "File": "arc", "Func": "legitimate_small_data_address_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33797, "Length": 170}
{"ground_truth": ["<s>", "static", "bool", "mem_ok_for_ldd_std", "(", "rtx", "mem", ",", "rtx", "*", "base", ",", "rtx", "*", "offset", ")", "{", "rtx", "addr", ";", "gcc_assert", "(", "base", "!=", "NULL", "&&", "offset", "!=", "NULL", ")", ";", "if", "(", "side_effects_p", "(", "mem", ")", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "mem", ")", "==", "SUBREG", ")", "return", "false", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "*", "offset", "=", "const0_rtx", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "if", "(", "!", "arc_legitimate_address_p", "(", "DImode", ",", "addr", ",", "reload_in_progress", "||", "reload_completed", ")", ")", "return", "false", ";", "if", "(", "REG_P", "(", "addr", ")", ")", "{", "*", "base", "=", "addr", ";", "return", "true", ";", "}", "else", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "||", "GET_CODE", "(", "addr", ")", "==", "MINUS", ")", "{", "*", "base", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "*", "offset", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "return", "(", "REG_P", "(", "*", "base", ")", "&&", "CONST_INT_P", "(", "*", "offset", ")", ")", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Helper", "for", "gen_operands_ldd_std", ".", "Returns", "true", "iff", "the", "memory", "operand", "MEM", "'s", "address", "contains", "an", "immediate", "offset", "from", "the", "base", "register", "and", "has", "no", "side", "effects", ",", "in", "which", "case", "it", "sets", "BASE", "and", "OFFSET", "accordingly", "."], "TS_V_token": ["arc", "0", "0", "1"], "File": "arc", "Func": "mem_ok_for_ldd_std", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33798, "Length": 166}
{"ground_truth": ["<s>", "static", "rtx_insn", "*", "next_nonnote_insn_bb", "(", "rtx_insn", "*", "insn", ")", "{", "while", "(", "insn", ")", "{", "insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "if", "(", "insn", "==", "0", "||", "!", "NOTE_P", "(", "insn", ")", ")", "break", ";", "if", "(", "NOTE_INSN_BASIC_BLOCK_P", "(", "insn", ")", ")", "return", "NULL", ";", "}", "return", "insn", ";", "}", "</s>"], "natrual_language": ["Return", "the", "next", "insn", "after", "INSN", "that", "is", "not", "a", "NOTE", ",", "but", "stop", "the", "search", "before", "we", "enter", "another", "basic", "block", ".", "This", "routine", "does", "not", "look", "inside", "SEQUENCEs", "."], "TS_V_token": ["arc", "0"], "File": "arc", "Func": "next_nonnote_insn_bb", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33799, "Length": 51}
{"ground_truth": ["<s>", "static", "bool", "operands_ok_ldd_std", "(", "rtx", "rt", ",", "rtx", "rt2", ",", "HOST_WIDE_INT", "offset", ")", "{", "unsigned", "int", "t", ",", "t2", ";", "if", "(", "!", "reload_completed", ")", "return", "true", ";", "if", "(", "!", "(", "SMALL_INT_RANGE", "(", "offset", ",", "(", "GET_MODE_SIZE", "(", "DImode", ")", "-", "1", ")", "&", "(", "~", "0x03", ")", ",", "(", "offset", "&", "(", "GET_MODE_SIZE", "(", "DImode", ")", "-", "1", ")", "&", "3", "?", "0", ":", "-", "(", "-", "GET_MODE_SIZE", "(", "DImode", ")", "|", "(", "~", "0x03", ")", ")", ">>", "1", ")", ")", ")", ")", "return", "false", ";", "t", "=", "REGNO", "(", "rt", ")", ";", "t2", "=", "REGNO", "(", "rt2", ")", ";", "if", "(", "(", "t2", "==", "PCL_REG", ")", "||", "(", "t", "%", "2", "!=", "0", ")", "||", "(", "t2", "!=", "t", "+", "1", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Checks", "whether", "the", "operands", "are", "valid", "for", "use", "in", "an", "LDD/STD", "instruction", ".", "Assumes", "that", "RT", ",", "and", "RT2", "are", "REG", ".", "This", "is", "guaranteed", "by", "the", "patterns", ".", "Assumes", "that", "the", "address", "in", "the", "base", "register", "RN", "is", "word", "aligned", ".", "Pattern", "guarantees", "that", "both", "memory", "accesses", "use", "the", "same", "base", "register", ",", "the", "offsets", "are", "constants", "within", "the", "range", ",", "and", "the", "gap", "between", "the", "offsets", "is", "4", ".", "If", "reload", "complete", "then", "check", "that", "registers", "are", "legal", "."], "TS_V_token": ["arc", "1", "0x03", "1", "3", "0", "0x03", "1", "2", "0", "1"], "File": "arc", "Func": "operands_ok_ldd_std", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33800, "Length": 133}
{"ground_truth": ["<s>", "const", "char", "*", "output_shift", "(", "rtx", "*", "operands", ")", "{", "rtx", "shift", "=", "operands", "[", "3", "]", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "shift", ")", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "shift", ")", ";", "const", "char", "*", "shift_one", ";", "gcc_assert", "(", "mode", "==", "SImode", ")", ";", "switch", "(", "code", ")", "{", "case", "ASHIFT", ":", "shift_one", "=", "\"add %0,%1,%1\"", ";", "break", ";", "case", "ASHIFTRT", ":", "shift_one", "=", "\"asr %0,%1\"", ";", "break", ";", "case", "LSHIFTRT", ":", "shift_one", "=", "\"lsr %0,%1\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "!=", "CONST_INT", ")", "{", "output_asm_insn", "(", "\"and.f lp_count,%2, 0x1f\"", ",", "operands", ")", ";", "goto", "shiftloop", ";", "}", "else", "{", "int", "n", ";", "n", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "n", "=", "n", "&", "0x1f", ";", "if", "(", "code", "==", "ASHIFT", "&&", "n", "<=", "9", "&&", "n", ">", "2", "&&", "dest_reg_operand", "(", "operands", "[", "4", "]", ",", "SImode", ")", ")", "{", "output_asm_insn", "(", "\"mov %4,0\\n\\tadd3 %0,%4,%1\"", ",", "operands", ")", ";", "for", "(", "n", "-=", "3", ";", "n", ">=", "3", ";", "n", "-=", "3", ")", "output_asm_insn", "(", "\"add3 %0,%4,%0\"", ",", "operands", ")", ";", "if", "(", "n", "==", "2", ")", "output_asm_insn", "(", "\"add2 %0,%4,%0\"", ",", "operands", ")", ";", "else", "if", "(", "n", ")", "output_asm_insn", "(", "\"add %0,%0,%0\"", ",", "operands", ")", ";", "}", "else", "if", "(", "n", "<=", "4", ")", "{", "while", "(", "--", "n", ">=", "0", ")", "{", "output_asm_insn", "(", "shift_one", ",", "operands", ")", ";", "operands", "[", "1", "]", "=", "operands", "[", "0", "]", ";", "}", "}", "else", "if", "(", "n", "==", "BITS_PER_WORD", "-", "1", ")", "{", "switch", "(", "code", ")", "{", "case", "ASHIFT", ":", "output_asm_insn", "(", "\"and %0,%1,1\\n\\tror %0,%0\"", ",", "operands", ")", ";", "break", ";", "case", "ASHIFTRT", ":", "output_asm_insn", "(", "\"add.f 0,%1,%1\\n\\tsbc %0,%0,%0\"", ",", "operands", ")", ";", "break", ";", "case", "LSHIFTRT", ":", "output_asm_insn", "(", "\"add.f 0,%1,%1\\n\\trlc %0,0\"", ",", "operands", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}", "else", "if", "(", "n", "==", "BITS_PER_WORD", "-", "2", "&&", "dest_reg_operand", "(", "operands", "[", "4", "]", ",", "SImode", ")", ")", "{", "switch", "(", "code", ")", "{", "case", "ASHIFT", ":", "output_asm_insn", "(", "\"and %0,%1,3\\n\\tror %0,%0\\n\\tror %0,%0\"", ",", "operands", ")", ";", "break", ";", "case", "ASHIFTRT", ":", "output_asm_insn", "(", "\"add.f %4,%1,%1\\n\\tsbc %0,%0,%0\\n\\t\"", "\"add.f 0,%4,%4\\n\\trlc %0,%0\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"add.f %4,%1,%1\\n\\tbxor %0,%4,31\\n\\t\"", "\"sbc.f %0,%0,%4\\n\\trlc %0,%0\"", ",", "operands", ")", ";", "break", ";", "case", "LSHIFTRT", ":", "output_asm_insn", "(", "\"add.f %4,%1,%1\\n\\trlc %0,0\\n\\t\"", "\"add.f 0,%4,%4\\n\\trlc %0,%0\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"add.f %0,%1,%1\\n\\trlc.f %0,0\\n\\t\"", "\"and %0,%0,1\\n\\trlc %0,%0\"", ",", "operands", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}", "else", "if", "(", "n", "==", "BITS_PER_WORD", "-", "3", "&&", "code", "==", "ASHIFT", ")", "output_asm_insn", "(", "\"and %0,%1,7\\n\\tror %0,%0\\n\\tror %0,%0\\n\\tror %0,%0\"", ",", "operands", ")", ";", "else", "{", "operands", "[", "2", "]", "=", "GEN_INT", "(", "n", ")", ";", "output_asm_insn", "(", "\"mov.f lp_count, %2\"", ",", "operands", ")", ";", "shiftloop", ":", "{", "output_asm_insn", "(", "\"lpnz\\t2f\"", ",", "operands", ")", ";", "output_asm_insn", "(", "shift_one", ",", "operands", ")", ";", "output_asm_insn", "(", "\"nop\"", ",", "operands", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"2:\\t%s end single insn loop\\n\"", ",", "ASM_COMMENT_START", ")", ";", "}", "}", "}", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["FIXME", ":", "This", "probably", "can", "be", "done", "using", "a", "define_split", "in", "arc.md", ".", "Alternately", ",", "generate", "rtx", "rather", "than", "output", "instructions", "."], "TS_V_token": ["arc", "3", "\"add %0,%1,%1\"", "\"asr %0,%1\"", "\"lsr %0,%1\"", "2", "\"and.f lp_count,%2, 0x1f\"", "2", "0x1f", "9", "2", "4", "\"mov %4,0\\n\\tadd3 %0,%4,%1\"", "3", "3", "3", "\"add3 %0,%4,%0\"", "2", "\"add2 %0,%4,%0\"", "\"add %0,%0,%0\"", "4", "0", "1", "0", "1", "\"and %0,%1,1\\n\\tror %0,%0\"", "\"add.f 0,%1,%1\\n\\tsbc %0,%0,%0\"", "\"add.f 0,%1,%1\\n\\trlc %0,0\"", "2", "4", "\"and %0,%1,3\\n\\tror %0,%0\\n\\tror %0,%0\"", "\"add.f %4,%1,%1\\n\\tsbc %0,%0,%0\\n\\t\"", "\"add.f 0,%4,%4\\n\\trlc %0,%0\"", "\"add.f %4,%1,%1\\n\\tbxor %0,%4,31\\n\\t\"", "\"sbc.f %0,%0,%4\\n\\trlc %0,%0\"", "\"add.f %4,%1,%1\\n\\trlc %0,0\\n\\t\"", "\"add.f 0,%4,%4\\n\\trlc %0,%0\"", "\"add.f %0,%1,%1\\n\\trlc.f %0,0\\n\\t\"", "\"and %0,%0,1\\n\\trlc %0,%0\"", "3", "\"and %0,%1,7\\n\\tror %0,%0\\n\\tror %0,%0\\n\\tror %0,%0\"", "2", "\"mov.f lp_count, %2\"", "\"lpnz\\t2f\"", "\"nop\"", "\"2:\\t%s end single insn loop\\n\"", "\"\""], "File": "arc", "Func": "output_shift", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33801, "Length": 466}
{"ground_truth": ["<s>", "static", "void", "output_short_suffix", "(", "FILE", "*", "file", ")", "{", "rtx_insn", "*", "insn", "=", "current_output_insn", ";", "if", "(", "!", "insn", ")", "return", ";", "if", "(", "arc_verify_short", "(", "insn", ",", "cfun", "->", "machine", "->", "unalign", ",", "1", ")", ")", "{", "fprintf", "(", "file", ",", "\"_s\"", ")", ";", "cfun", "->", "machine", "->", "unalign", "^=", "2", ";", "}", "extract_insn_cached", "(", "insn", ")", ";", "}", "</s>"], "natrual_language": ["When", "outputting", "an", "instruction", "(", "alternative", ")", "that", "can", "potentially", "be", "short", ",", "output", "the", "short", "suffix", "if", "the", "insn", "is", "in", "fact", "short", ",", "and", "update", "cfun-", ">", "machine-", ">", "unalign", "accordingly", "."], "TS_V_token": ["arc", "1", "\"_s\"", "2"], "File": "arc", "Func": "output_short_suffix", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33802, "Length": 60}
{"ground_truth": ["<s>", "static", "void", "pad_return", "(", "void", ")", "{", "rtx_insn", "*", "insn", ";", "long", "offset", ";", "if", "(", "!", "TARGET_PAD_RETURN", ")", "return", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "rtx_insn", "*", "prev0", "=", "prev_active_insn", "(", "insn", ")", ";", "bool", "wantlong", "=", "false", ";", "if", "(", "!", "INSN_P", "(", "insn", ")", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "SIMPLE_RETURN", ")", "continue", ";", "if", "(", "!", "prev0", ")", "{", "prev0", "=", "emit_insn_before", "(", "gen_nopv", "(", ")", ",", "insn", ")", ";", "add_reg_note", "(", "prev0", ",", "REG_SAVE_NOTE", ",", "GEN_INT", "(", "1", ")", ")", ";", "emit_insn_before", "(", "gen_nopv", "(", ")", ",", "insn", ")", ";", "continue", ";", "}", "offset", "=", "get_attr_length", "(", "prev0", ")", ";", "if", "(", "get_attr_length", "(", "prev0", ")", "==", "2", "&&", "get_attr_iscompact", "(", "prev0", ")", "!=", "ISCOMPACT_TRUE", ")", "{", "wantlong", "=", "true", ";", "offset", "+=", "2", ";", "}", "rtx_insn", "*", "prev", "=", "prev_active_insn", "(", "prev0", ")", ";", "if", "(", "prev", ")", "offset", "+=", "get_attr_length", "(", "prev", ")", ";", "prev", "=", "prev_active_insn", "(", "prev", ")", ";", "if", "(", "prev", ")", "offset", "+=", "get_attr_length", "(", "prev", ")", ";", "switch", "(", "offset", ")", "{", "case", "2", ":", "prev", "=", "emit_insn_before", "(", "gen_nopv", "(", ")", ",", "insn", ")", ";", "add_reg_note", "(", "prev", ",", "REG_SAVE_NOTE", ",", "GEN_INT", "(", "1", ")", ")", ";", "break", ";", "case", "4", ":", "emit_insn_before", "(", "gen_nopv", "(", ")", ",", "insn", ")", ";", "break", ";", "default", ":", "continue", ";", "}", "if", "(", "wantlong", ")", "add_reg_note", "(", "prev0", ",", "REG_SAVE_NOTE", ",", "GEN_INT", "(", "1", ")", ")", ";", "emit_insn_before", "(", "gen_blockage", "(", ")", ",", "insn", ")", ";", "}", "}", "</s>"], "natrual_language": ["Add", "padding", "if", "necessary", "to", "avoid", "a", "mispredict", ".", "A", "return", "could", "happen", "immediately", "after", "the", "function", "start", ".", "A", "call/return", "and", "return/return", "must", "be", "6", "bytes", "apart", "to", "avoid", "mispredict", "."], "TS_V_token": ["arc", "1", "2", "2", "2", "1", "4", "1"], "File": "arc", "Func": "pad_return", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33803, "Length": 264}
{"ground_truth": ["<s>", "static", "void", "parse_mrgf_banked_regs_option", "(", "const", "char", "*", "arg", ")", "{", "long", "int", "val", ";", "char", "*", "end_ptr", ";", "errno", "=", "0", ";", "val", "=", "strtol", "(", "arg", ",", "&", "end_ptr", ",", "10", ")", ";", "if", "(", "errno", "!=", "0", "||", "*", "arg", "==", "'\\0'", "||", "*", "end_ptr", "!=", "'\\0'", "||", "(", "val", "!=", "0", "&&", "val", "!=", "4", "&&", "val", "!=", "8", "&&", "val", "!=", "16", "&&", "val", "!=", "32", ")", ")", "{", "error", "(", "\"invalid number in %<-mrgf-banked-regs=%s%> \"", "\"valid values are 0, 4, 8, 16, or 32\"", ",", "arg", ")", ";", "return", ";", "}", "rgf_banked_register_count", "=", "(", "int", ")", "val", ";", "}", "</s>"], "natrual_language": ["Parse", "-mrgf-banked-regs=NUM", "option", "string", ".", "Valid", "values", "for", "NUM", "are", "4", ",", "8", ",", "16", ",", "or", "32", "."], "TS_V_token": ["arc", "0", "10", "0", "0", "4", "8", "16", "32", "\"invalid number in %<-mrgf-banked-regs=%s%> \"", "\"valid values are 0, 4, 8, 16, or 32\""], "File": "arc", "Func": "parse_mrgf_banked_regs_option", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33804, "Length": 92}
{"ground_truth": ["<s>", "static", "int", "pop_reg", "(", "rtx", "reg", ")", "{", "rtx", "stkslot", "=", "gen_rtx_MEM", "(", "GET_MODE", "(", "reg", ")", ",", "gen_rtx_POST_INC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ")", ";", "rtx", "insn", "=", "emit_move_insn", "(", "reg", ",", "stkslot", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_ADJUST_CFA", ",", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GET_MODE_SIZE", "(", "GET_MODE", "(", "reg", ")", ")", ")", ")", ")", ";", "return", "GET_MODE_SIZE", "(", "GET_MODE", "(", "reg", ")", ")", ";", "}", "</s>"], "natrual_language": ["Helper", "used", "when", "restoring", "AUX", "regs", "during", "ISR", "."], "TS_V_token": ["arc", "1"], "File": "arc", "Func": "pop_reg", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33805, "Length": 80}
{"ground_truth": ["<s>", "static", "int", "push_reg", "(", "rtx", "reg", ")", "{", "rtx", "stkslot", "=", "gen_rtx_MEM", "(", "GET_MODE", "(", "reg", ")", ",", "gen_rtx_PRE_DEC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ")", ";", "rtx", "insn", "=", "emit_move_insn", "(", "stkslot", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_ADJUST_CFA", ",", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "GET_MODE_SIZE", "(", "GET_MODE", "(", "reg", ")", ")", ")", ")", ")", ";", "return", "GET_MODE_SIZE", "(", "GET_MODE", "(", "reg", ")", ")", ";", "}", "</s>"], "natrual_language": ["Helper", "used", "when", "saving", "AUX", "regs", "during", "ISR", "."], "TS_V_token": ["arc", "1"], "File": "arc", "Func": "push_reg", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33806, "Length": 81}
{"ground_truth": ["<s>", "void", "split_addsi", "(", "rtx", "*", "operands", ")", "{", "int", "val", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "val", ">", "127", "&&", "val", "<=", "255", "&&", "satisfies_constraint_Rcq", "(", "operands", "[", "0", "]", ")", ")", "{", "operands", "[", "3", "]", "=", "operands", "[", "2", "]", ";", "operands", "[", "4", "]", "=", "gen_rtx_PLUS", "(", "SImode", ",", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "}", "else", "{", "operands", "[", "3", "]", "=", "operands", "[", "1", "]", ";", "operands", "[", "4", "]", "=", "gen_rtx_PLUS", "(", "SImode", ",", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ")", ";", "}", "}", "</s>"], "natrual_language": ["Operands", "0", "..", "2", "are", "the", "operands", "of", "a", "addsi", "which", "uses", "a", "12", "bit", "constant", "in", "operand", "2", ",", "but", "which", "would", "require", "a", "LIMM", "because", "of", "operand", "mismatch", ".", "operands", "3", "and", "4", "are", "new", "SET_SRCs", "for", "operands", "0", "."], "TS_V_token": ["arc", "2", "127", "255", "0", "3", "2", "4", "0", "1", "3", "1", "4", "0", "2"], "File": "arc", "Func": "split_addsi", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33807, "Length": 103}
{"ground_truth": ["<s>", "void", "split_subsi", "(", "rtx", "*", "operands", ")", "{", "int", "val", "=", "INTVAL", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "satisfies_constraint_Rcq", "(", "operands", "[", "0", "]", ")", "&&", "satisfies_constraint_Rcq", "(", "operands", "[", "2", "]", ")", ")", "{", "if", "(", "val", ">=", "-", "31", "&&", "val", "<=", "127", ")", "{", "operands", "[", "3", "]", "=", "gen_rtx_NEG", "(", "SImode", ",", "operands", "[", "2", "]", ")", ";", "operands", "[", "4", "]", "=", "gen_rtx_PLUS", "(", "SImode", ",", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "return", ";", "}", "else", "if", "(", "val", ">=", "0", "&&", "val", "<", "255", ")", "{", "operands", "[", "3", "]", "=", "operands", "[", "1", "]", ";", "operands", "[", "4", "]", "=", "gen_rtx_MINUS", "(", "SImode", ",", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ")", ";", "return", ";", "}", "}", "operands", "[", "3", "]", "=", "operands", "[", "2", "]", ";", "operands", "[", "4", "]", "=", "gen_rtx_MINUS", "(", "SImode", ",", "operands", "[", "1", "]", ",", "operands", "[", "0", "]", ")", ";", "}", "</s>"], "natrual_language": ["Operands", "0", "..", "2", "are", "the", "operands", "of", "a", "subsi", "which", "uses", "a", "12", "bit", "constant", "in", "operand", "1", ",", "but", "which", "would", "require", "a", "LIMM", "because", "of", "operand", "mismatch", ".", "operands", "3", "and", "4", "are", "new", "SET_SRCs", "for", "operands", "0", "."], "TS_V_token": ["arc", "1", "0", "2", "31", "127", "3", "2", "4", "0", "1", "0", "255", "3", "1", "4", "0", "2", "3", "2", "4", "1", "0"], "File": "arc", "Func": "split_subsi", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33808, "Length": 165}
{"ground_truth": ["<s>", "static", "bool", "symbolic_reference_mentioned_p", "(", "rtx", "op", ")", "{", "const", "char", "*", "fmt", ";", "int", "i", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "op", ")", "==", "LABEL_REF", ")", "return", "true", ";", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "op", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "op", ")", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "int", "j", ";", "for", "(", "j", "=", "XVECLEN", "(", "op", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "if", "(", "symbolic_reference_mentioned_p", "(", "XVECEXP", "(", "op", ",", "i", ",", "j", ")", ")", ")", "return", "true", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'e'", "&&", "symbolic_reference_mentioned_p", "(", "XEXP", "(", "op", ",", "i", ")", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "OP", "contains", "a", "symbol", "reference"], "TS_V_token": ["arc", "1", "0", "1", "0"], "File": "arc", "Func": "symbolic_reference_mentioned_p", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33809, "Length": 146}
{"ground_truth": ["<s>", "static", "void", "workaround_arc_anomaly", "(", "void", ")", "{", "rtx_insn", "*", "insn", ",", "*", "succ0", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "succ0", "=", "next_real_insn", "(", "insn", ")", ";", "if", "(", "arc_hazard", "(", "insn", ",", "succ0", ")", ")", "{", "emit_insn_before", "(", "gen_nopv", "(", ")", ",", "succ0", ")", ";", "}", "}", "if", "(", "!", "TARGET_ARC700", ")", "return", ";", "if", "(", "arc_tune", "!=", "ARC_TUNE_ARC7XX", ")", "check_store_cacheline_hazard", "(", ")", ";", "}", "</s>"], "natrual_language": ["The", "same", "functionality", "as", "arc_hazard", ".", "It", "is", "called", "in", "machine", "reorg", "before", "any", "other", "optimization", ".", "Hence", ",", "the", "NOP", "size", "is", "taken", "into", "account", "when", "doing", "branch", "shortening", "."], "TS_V_token": ["arc"], "File": "arc", "Func": "workaround_arc_anomaly", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33810, "Length": 78}
{"ground_truth": ["<s>", "const", "char", "*", "arc_cpu_to_as", "(", "int", "argc", ",", "const", "char", "*", "*", "argv", ")", "{", "const", "char", "*", "name", "=", "NULL", ";", "const", "arc_cpu_t", "*", "arc_selected_cpu", ";", "if", "(", "argc", "==", "0", ")", "{", "arc_selected_cpu", "=", "&", "arc_cpu_types", "[", "(", "int", ")", "TARGET_CPU_DEFAULT", "]", ";", "}", "else", "{", "name", "=", "argv", "[", "0", "]", ";", "for", "(", "arc_selected_cpu", "=", "arc_cpu_types", ";", "arc_selected_cpu", "->", "name", ";", "arc_selected_cpu", "++", ")", "{", "if", "(", "strcmp", "(", "arc_selected_cpu", "->", "name", ",", "name", ")", "==", "0", ")", "break", ";", "}", "}", "switch", "(", "arc_selected_cpu", "->", "arch_info", "->", "arch_id", ")", "{", "case", "BASE_ARCH_em", ":", "if", "(", "arc_selected_cpu", "->", "flags", "&", "FL_CD", ")", "name", "=", "\"-mcode-density\"", ";", "else", "name", "=", "\"\"", ";", "if", "(", "arc_selected_cpu", "->", "flags", "&", "FL_FPUDA", ")", "name", "=", "concat", "(", "\"-mfpuda \"", ",", "name", ",", "NULL", ")", ";", "if", "(", "arc_selected_cpu", "->", "flags", "&", "FL_SPFP", ")", "name", "=", "concat", "(", "\"-mspfp \"", ",", "name", ",", "NULL", ")", ";", "if", "(", "arc_selected_cpu", "->", "flags", "&", "FL_DPFP", ")", "name", "=", "concat", "(", "\"-mdpfp \"", ",", "name", ",", "NULL", ")", ";", "return", "concat", "(", "\"-mcpu=arcem \"", ",", "name", ",", "NULL", ")", ";", "case", "BASE_ARCH_hs", ":", "return", "\"-mcpu=archs\"", ";", "case", "BASE_ARCH_700", ":", "if", "(", "arc_selected_cpu", "->", "processor", "==", "PROCESSOR_nps400", ")", "return", "\"-mcpu=nps400 -mEA\"", ";", "else", "return", "\"-mcpu=arc700 -mEA\"", ";", "case", "BASE_ARCH_6xx", ":", "if", "(", "arc_selected_cpu", "->", "flags", "&", "FL_MUL64", ")", "return", "\"-mcpu=arc600 -mmul64 -mnorm\"", ";", "if", "(", "arc_selected_cpu", "->", "flags", "&", "FL_MUL32x16", ")", "return", "\"-mcpu=arc600 -mdsp-packa -mnorm\"", ";", "return", "\"-mcpu=arc600 -mnorm\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "NULL", ";", "}", "</s>"], "natrual_language": ["Returns", "command", "line", "parameters", "to", "pass", "to", "as", "."], "TS_V_token": ["arc", "0", "0", "0", "\"-mcode-density\"", "\"\"", "\"-mfpuda \"", "\"-mspfp \"", "\"-mdpfp \"", "\"-mcpu=arcem \"", "\"-mcpu=archs\"", "\"-mcpu=nps400 -mEA\"", "\"-mcpu=arc700 -mEA\"", "\"-mcpu=arc600 -mmul64 -mnorm\"", "\"-mcpu=arc600 -mdsp-packa -mnorm\"", "\"-mcpu=arc600 -mnorm\""], "File": "driver-arc", "Func": "arc_cpu_to_as", "Target": "arc", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 33811, "Length": 245}