{"ground_truth": ["<s>", "static", "void", "alpha_setup_incoming_varargs", "(", "cumulative_args_t", "pcum", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_size", ",", "int", "no_rtl", ")", "{", "CUMULATIVE_ARGS", "cum", "=", "*", "get_cumulative_args", "(", "pcum", ")", ";", "if", "(", "!", "TYPE_NO_NAMED_ARGS_STDARG_P", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ")", "targetm", ".", "calls", ".", "function_arg_advance", "(", "pack_cumulative_args", "(", "&", "cum", ")", ",", "arg", ")", ";", "if", "(", "cum", ".", "num_args", "<", "6", ")", "{", "if", "(", "!", "no_rtl", ")", "{", "emit_move_insn", "(", "gen_rtx_REG", "(", "DImode", ",", "1", ")", ",", "virtual_incoming_args_rtx", ")", ";", "emit_insn", "(", "gen_arg_home", "(", ")", ")", ";", "}", "*", "pretend_size", "=", "7", "*", "UNITS_PER_WORD", ";", "}", "if", "(", "cum", ">=", "6", ")", "return", ";", "if", "(", "!", "no_rtl", ")", "{", "int", "count", ";", "alias_set_type", "set", "=", "get_varargs_alias_set", "(", ")", ";", "rtx", "tmp", ";", "count", "=", "cfun", "->", "va_list_gpr_size", "/", "UNITS_PER_WORD", ";", "if", "(", "count", ">", "6", "-", "cum", ")", "count", "=", "6", "-", "cum", ";", "gcc_assert", "(", "(", "VA_LIST_MAX_FPR_SIZE", "&", "3", ")", "==", "3", ")", ";", "if", "(", "cfun", "->", "va_list_fpr_size", "&", "1", ")", "{", "tmp", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "(", "cum", "+", "6", ")", "*", "UNITS_PER_WORD", ")", ")", ";", "MEM_NOTRAP_P", "(", "tmp", ")", "=", "1", ";", "set_mem_alias_set", "(", "tmp", ",", "set", ")", ";", "move_block_from_reg", "(", "16", "+", "cum", ",", "tmp", ",", "count", ")", ";", "}", "if", "(", "cfun", "->", "va_list_fpr_size", "&", "2", ")", "{", "tmp", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "cum", "*", "UNITS_PER_WORD", ")", ")", ";", "MEM_NOTRAP_P", "(", "tmp", ")", "=", "1", ";", "set_mem_alias_set", "(", "tmp", ",", "set", ")", ";", "move_block_from_reg", "(", "16", "+", "cum", "+", "TARGET_FPREGS", "*", "32", ",", "tmp", ",", "count", ")", ";", "}", "}", "*", "pretend_size", "=", "12", "*", "UNITS_PER_WORD", ";", "}", "</s>"], "natrual_language": ["Perform", "any", "needed", "actions", "needed", "for", "a", "function", "that", "is", "receiving", "a", "variable", "number", "of", "arguments", "."], "TS_V_token": ["alpha", "6", "1", "7", "6", "6", "6", "3", "3", "1", "6", "1", "16", "2", "1", "16", "32", "12"], "File": "alpha1", "Func": "alpha_setup_incoming_varargs", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40546, "Length": 281}
{"ground_truth": ["<s>", "int", "alpha_store_data_bypass_p", "(", "rtx_insn", "*", "out_insn", ",", "rtx_insn", "*", "in_insn", ")", "{", "rtx", "in_set", "=", "single_set", "(", "in_insn", ")", ";", "if", "(", "in_set", ")", "return", "alpha_store_data_bypass_p_1", "(", "out_insn", ",", "in_set", ")", ";", "rtx", "in_pat", "=", "PATTERN", "(", "in_insn", ")", ";", "if", "(", "GET_CODE", "(", "in_pat", ")", "!=", "PARALLEL", ")", "return", "false", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "in_pat", ",", "0", ")", ";", "i", "++", ")", "{", "rtx", "in_exp", "=", "XVECEXP", "(", "in_pat", ",", "0", ",", "i", ")", ";", "if", "(", "GET_CODE", "(", "in_exp", ")", "==", "CLOBBER", "||", "GET_CODE", "(", "in_exp", ")", "==", "USE", "||", "GET_CODE", "(", "in_exp", ")", "==", "TRAP_IF", ")", "continue", ";", "gcc_assert", "(", "GET_CODE", "(", "in_exp", ")", "==", "SET", ")", ";", "if", "(", "!", "alpha_store_data_bypass_p_1", "(", "out_insn", ",", "in_exp", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["True", "if", "the", "dependency", "between", "OUT_INSN", "and", "IN_INSN", "is", "on", "the", "store", "data", "not", "the", "address", "operand", "(", "s", ")", "of", "the", "store", ".", "IN_INSN", "and", "OUT_INSN", "must", "be", "either", "a", "single_set", "or", "a", "PARALLEL", "with", "SETs", "inside", ".", "This", "alpha-specific", "version", "of", "store_data_bypass_p", "ignores", "TRAP_IF", "that", "would", "result", "in", "assertion", "failure", "(", "and", "internal", "compiler", "error", ")", "in", "the", "generic", "store_data_bypass_p", "function", "."], "TS_V_token": ["alpha", "0", "0", "0"], "File": "alpha1", "Func": "alpha_store_data_bypass_p", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40547, "Length": 137}
{"ground_truth": ["<s>", "static", "bool", "alpha_store_data_bypass_p_1", "(", "rtx_insn", "*", "out_insn", ",", "rtx", "in_set", ")", "{", "if", "(", "!", "MEM_P", "(", "SET_DEST", "(", "in_set", ")", ")", ")", "return", "false", ";", "rtx", "out_set", "=", "single_set", "(", "out_insn", ")", ";", "if", "(", "out_set", ")", "return", "!", "reg_mentioned_p", "(", "SET_DEST", "(", "out_set", ")", ",", "SET_DEST", "(", "in_set", ")", ")", ";", "rtx", "out_pat", "=", "PATTERN", "(", "out_insn", ")", ";", "if", "(", "GET_CODE", "(", "out_pat", ")", "!=", "PARALLEL", ")", "return", "false", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "out_pat", ",", "0", ")", ";", "i", "++", ")", "{", "rtx", "out_exp", "=", "XVECEXP", "(", "out_pat", ",", "0", ",", "i", ")", ";", "if", "(", "GET_CODE", "(", "out_exp", ")", "==", "CLOBBER", "||", "GET_CODE", "(", "out_exp", ")", "==", "USE", "||", "GET_CODE", "(", "out_exp", ")", "==", "TRAP_IF", ")", "continue", ";", "gcc_assert", "(", "GET_CODE", "(", "out_exp", ")", "==", "SET", ")", ";", "if", "(", "reg_mentioned_p", "(", "SET_DEST", "(", "out_exp", ")", ",", "SET_DEST", "(", "in_set", ")", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["Helper", "function", "for", "alpha_store_data_bypass_p", ",", "handle", "just", "a", "single", "SET", "IN_SET", "."], "TS_V_token": ["alpha", "0", "0", "0"], "File": "alpha1", "Func": "alpha_store_data_bypass_p_1", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40548, "Length": 163}
{"ground_truth": ["<s>", "rtx", "alpha_gp_save_rtx", "(", ")", "{", "rtx", "r", "=", "get_hard_reg_initial_val", "(", "DImode", ",", "29", ")", ";", "if", "(", "GET_CODE", "(", "r", ")", "!=", "MEM", ")", "r", "=", "gen_mem_addressof", "(", "r", ",", "NULL_TREE", ")", ";", "return", "r", ";", "}", "</s>"], "natrual_language": ["Return", "or", "create", "a", "pseudo", "containing", "the", "gp", "value", "for", "the", "current", "function", ".", "Needed", "only", "if", "TARGET_LD_BUGGY_LDGP", "."], "TS_V_token": ["alpha", "29"], "File": "alpha2", "Func": "alpha_gp_save_rtx", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40549, "Length": 37}
{"ground_truth": ["<s>", "static", "int", "alpha_issue_rate", "(", ")", "{", "return", "(", "alpha_cpu", "==", "PROCESSOR_EV4", "?", "2", ":", "4", ")", ";", "}", "</s>"], "natrual_language": ["Function", "to", "initialize", "the", "issue", "rate", "used", "by", "the", "scheduler", "."], "TS_V_token": ["alpha", "2", "4"], "File": "alpha2", "Func": "alpha_issue_rate", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40550, "Length": 18}
{"ground_truth": ["<s>", "int", "direct_return", "(", ")", "{", "return", "(", "!", "TARGET_ABI_OPEN_VMS", "&&", "!", "TARGET_ABI_UNICOSMK", "&&", "reload_completed", "&&", "alpha_sa_size", "(", ")", "==", "0", "&&", "get_frame_size", "(", ")", "==", "0", "&&", "current_function_outgoing_args_size", "==", "0", "&&", "current_function_pretend_args_size", "==", "0", ")", ";", "}", "</s>"], "natrual_language": ["Return", "non-zero", "if", "this", "function", "is", "known", "to", "have", "a", "null", "epilogue", "."], "TS_V_token": ["alpha", "0", "0", "0", "0"], "File": "alpha2", "Func": "direct_return", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40551, "Length": 37}
{"ground_truth": ["<s>", "static", "const", "char", "*", "get_round_mode_suffix", "(", ")", "{", "enum", "attr_round_suffix", "s", "=", "get_attr_round_suffix", "(", "current_output_insn", ")", ";", "switch", "(", "s", ")", "{", "case", "ROUND_SUFFIX_NONE", ":", "return", "NULL", ";", "case", "ROUND_SUFFIX_NORMAL", ":", "switch", "(", "alpha_fprm", ")", "{", "case", "ALPHA_FPRM_NORM", ":", "return", "NULL", ";", "case", "ALPHA_FPRM_MINF", ":", "return", "\"m\"", ";", "case", "ALPHA_FPRM_CHOP", ":", "return", "\"c\"", ";", "case", "ALPHA_FPRM_DYN", ":", "return", "\"d\"", ";", "}", "break", ";", "case", "ROUND_SUFFIX_C", ":", "return", "\"c\"", ";", "}", "abort", "(", ")", ";", "}", "</s>"], "natrual_language": ["Return", "the", "rounding", "mode", "suffix", "applicable", "to", "the", "current", "instruction", ",", "or", "NULL", "."], "TS_V_token": ["alpha", "\"m\"", "\"c\"", "\"d\"", "\"c\""], "File": "alpha2", "Func": "get_round_mode_suffix", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40552, "Length": 75}
{"ground_truth": ["<s>", "static", "const", "char", "*", "get_trap_mode_suffix", "(", ")", "{", "enum", "attr_trap_suffix", "s", "=", "get_attr_trap_suffix", "(", "current_output_insn", ")", ";", "switch", "(", "s", ")", "{", "case", "TRAP_SUFFIX_NONE", ":", "return", "NULL", ";", "case", "TRAP_SUFFIX_SU", ":", "if", "(", "alpha_fptm", ">=", "ALPHA_FPTM_SU", ")", "return", "\"su\"", ";", "return", "NULL", ";", "case", "TRAP_SUFFIX_SUI", ":", "if", "(", "alpha_fptm", ">=", "ALPHA_FPTM_SUI", ")", "return", "\"sui\"", ";", "return", "NULL", ";", "case", "TRAP_SUFFIX_V_SV", ":", "switch", "(", "alpha_fptm", ")", "{", "case", "ALPHA_FPTM_N", ":", "return", "NULL", ";", "case", "ALPHA_FPTM_U", ":", "return", "\"v\"", ";", "case", "ALPHA_FPTM_SU", ":", "case", "ALPHA_FPTM_SUI", ":", "return", "\"sv\"", ";", "}", "break", ";", "case", "TRAP_SUFFIX_V_SV_SVI", ":", "switch", "(", "alpha_fptm", ")", "{", "case", "ALPHA_FPTM_N", ":", "return", "NULL", ";", "case", "ALPHA_FPTM_U", ":", "return", "\"v\"", ";", "case", "ALPHA_FPTM_SU", ":", "return", "\"sv\"", ";", "case", "ALPHA_FPTM_SUI", ":", "return", "\"svi\"", ";", "}", "break", ";", "case", "TRAP_SUFFIX_U_SU_SUI", ":", "switch", "(", "alpha_fptm", ")", "{", "case", "ALPHA_FPTM_N", ":", "return", "NULL", ";", "case", "ALPHA_FPTM_U", ":", "return", "\"u\"", ";", "case", "ALPHA_FPTM_SU", ":", "return", "\"su\"", ";", "case", "ALPHA_FPTM_SUI", ":", "return", "\"sui\"", ";", "}", "break", ";", "}", "abort", "(", ")", ";", "}", "</s>"], "natrual_language": ["Return", "the", "trap", "mode", "suffix", "applicable", "to", "the", "current", "instruction", ",", "or", "NULL", "."], "TS_V_token": ["alpha", "\"su\"", "\"sui\"", "\"v\"", "\"sv\"", "\"v\"", "\"sv\"", "\"svi\"", "\"u\"", "\"su\"", "\"sui\""], "File": "alpha2", "Func": "get_trap_mode_suffix", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40553, "Length": 166}
{"ground_truth": ["<s>", "static", "rtx", "set_frame_related_p", "(", ")", "{", "rtx", "seq", "=", "gen_sequence", "(", ")", ";", "end_sequence", "(", ")", ";", "if", "(", "GET_CODE", "(", "seq", ")", "==", "SEQUENCE", ")", "{", "int", "i", "=", "XVECLEN", "(", "seq", ",", "0", ")", ";", "while", "(", "--", "i", ">=", "0", ")", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "seq", ",", "0", ",", "i", ")", ")", "=", "1", ";", "return", "emit_insn", "(", "seq", ")", ";", "}", "else", "{", "seq", "=", "emit_insn", "(", "seq", ")", ";", "RTX_FRAME_RELATED_P", "(", "seq", ")", "=", "1", ";", "return", "seq", ";", "}", "}", "</s>"], "natrual_language": ["Helper", "function", "to", "set", "RTX_FRAME_RELATED_P", "on", "instructions", ",", "including", "sequences", "."], "TS_V_token": ["alpha", "0", "0", "0", "1", "1"], "File": "alpha2", "Func": "set_frame_related_p", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40554, "Length": 86}
{"ground_truth": ["<s>", "static", "const", "char", "*", "unicosmk_ssib_name", "(", ")", "{", "static", "char", "name", "[", "256", "]", ";", "rtx", "x", ";", "const", "char", "*", "fnname", ";", "int", "len", ";", "x", "=", "DECL_RTL", "(", "cfun", "->", "decl", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "MEM", ")", "abort", "(", ")", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "SYMBOL_REF", ")", "abort", "(", ")", ";", "fnname", "=", "XSTR", "(", "x", ",", "0", ")", ";", "STRIP_NAME_ENCODING", "(", "fnname", ",", "fnname", ")", ";", "len", "=", "strlen", "(", "fnname", ")", ";", "if", "(", "len", "+", "SSIB_PREFIX_LEN", ">", "255", ")", "len", "=", "255", "-", "SSIB_PREFIX_LEN", ";", "strcpy", "(", "name", ",", "SSIB_PREFIX", ")", ";", "strncpy", "(", "name", "+", "SSIB_PREFIX_LEN", ",", "fnname", ",", "len", ")", ";", "name", "[", "len", "+", "SSIB_PREFIX_LEN", "]", "=", "0", ";", "return", "name", ";", "}", "</s>"], "natrual_language": ["Generate", "the", "name", "of", "the", "SSIB", "section", "for", "the", "current", "function", "."], "TS_V_token": ["alpha", "256", "0", "0", "255", "255", "0"], "File": "alpha2", "Func": "unicosmk_ssib_name", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40555, "Length": 138}
{"ground_truth": ["<s>", "static", "rtx", "alphaev4_next_group", "(", "rtx", "insn", ",", "int", "*", "pin_use", ",", "int", "*", "plen", ")", "{", "int", "len", ",", "in_use", ";", "len", "=", "in_use", "=", "0", ";", "if", "(", "!", "INSN_P", "(", "insn", ")", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", ")", "goto", "next_and_done", ";", "while", "(", "1", ")", "{", "enum", "alphaev4_pipe", "pipe", ";", "pipe", "=", "alphaev4_insn_pipe", "(", "insn", ")", ";", "switch", "(", "pipe", ")", "{", "case", "EV4_STOP", ":", "if", "(", "in_use", ")", "goto", "done", ";", "if", "(", "recog_memoized", "(", "insn", ")", "<", "0", ")", "len", "=", "-", "1", ";", "else", "len", "=", "get_attr_length", "(", "insn", ")", ";", "goto", "next_and_done", ";", "case", "EV4_IBX", ":", "if", "(", "in_use", "&", "EV4_IB0", ")", "{", "if", "(", "in_use", "&", "EV4_IB1", ")", "goto", "done", ";", "in_use", "|=", "EV4_IB1", ";", "}", "else", "in_use", "|=", "EV4_IB0", "|", "EV4_IBX", ";", "break", ";", "case", "EV4_IB0", ":", "if", "(", "in_use", "&", "EV4_IB0", ")", "{", "if", "(", "!", "(", "in_use", "&", "EV4_IBX", ")", "||", "(", "in_use", "&", "EV4_IB1", ")", ")", "goto", "done", ";", "in_use", "|=", "EV4_IB1", ";", "}", "in_use", "|=", "EV4_IB0", ";", "break", ";", "case", "EV4_IB1", ":", "if", "(", "in_use", "&", "EV4_IB1", ")", "goto", "done", ";", "in_use", "|=", "EV4_IB1", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "len", "+=", "4", ";", "if", "(", "GET_CODE", "(", "insn", ")", "==", "JUMP_INSN", ")", "goto", "next_and_done", ";", "next", ":", "insn", "=", "next_nonnote_insn", "(", "insn", ")", ";", "if", "(", "!", "insn", "||", "!", "INSN_P", "(", "insn", ")", ")", "goto", "done", ";", "if", "(", "GET_MODE", "(", "insn", ")", "==", "TImode", ")", "goto", "done", ";", "if", "(", "GET_CODE", "(", "insn", ")", "==", "CLOBBER", "||", "GET_CODE", "(", "insn", ")", "==", "USE", ")", "goto", "next", ";", "}", "next_and_done", ":", "insn", "=", "next_nonnote_insn", "(", "insn", ")", ";", "done", ":", "*", "plen", "=", "len", ";", "*", "pin_use", "=", "in_use", ";", "return", "insn", ";", "}", "</s>"], "natrual_language": ["IN_USE", "is", "a", "mask", "of", "the", "slots", "currently", "filled", "within", "the", "insn", "group", ".", "The", "mask", "bits", "come", "from", "alphaev4_pipe", "above", ".", "If", "EV4_IBX", "is", "set", ",", "then", "the", "insn", "in", "EV4_IB0", "can", "be", "swapped", "by", "the", "hardware", "into", "EV4_IB1", ".", "LEN", "is", ",", "of", "course", ",", "the", "length", "of", "the", "group", "in", "bytes", "."], "TS_V_token": ["alpha", "0", "1", "0", "1", "4"], "File": "alpha3", "Func": "alphaev4_next_group", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40556, "Length": 307}
{"ground_truth": ["<s>", "static", "rtx", "alphaev5_next_group", "(", "rtx", "insn", ",", "int", "*", "pin_use", ",", "int", "*", "plen", ")", "{", "int", "len", ",", "in_use", ";", "len", "=", "in_use", "=", "0", ";", "if", "(", "!", "INSN_P", "(", "insn", ")", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", ")", "goto", "next_and_done", ";", "while", "(", "1", ")", "{", "enum", "alphaev5_pipe", "pipe", ";", "pipe", "=", "alphaev5_insn_pipe", "(", "insn", ")", ";", "switch", "(", "pipe", ")", "{", "case", "EV5_STOP", ":", "if", "(", "in_use", ")", "goto", "done", ";", "if", "(", "recog_memoized", "(", "insn", ")", "<", "0", ")", "len", "=", "-", "1", ";", "else", "len", "=", "get_attr_length", "(", "insn", ")", ";", "goto", "next_and_done", ";", "case", "EV5_E01", ":", "if", "(", "in_use", "&", "EV5_E0", ")", "{", "if", "(", "in_use", "&", "EV5_E1", ")", "goto", "done", ";", "in_use", "|=", "EV5_E1", ";", "}", "else", "in_use", "|=", "EV5_E0", "|", "EV5_E01", ";", "break", ";", "case", "EV5_E0", ":", "if", "(", "in_use", "&", "EV5_E0", ")", "{", "if", "(", "!", "(", "in_use", "&", "EV5_E01", ")", "||", "(", "in_use", "&", "EV5_E1", ")", ")", "goto", "done", ";", "in_use", "|=", "EV5_E1", ";", "}", "in_use", "|=", "EV5_E0", ";", "break", ";", "case", "EV5_E1", ":", "if", "(", "in_use", "&", "EV5_E1", ")", "goto", "done", ";", "in_use", "|=", "EV5_E1", ";", "break", ";", "case", "EV5_FAM", ":", "if", "(", "in_use", "&", "EV5_FA", ")", "{", "if", "(", "in_use", "&", "EV5_FM", ")", "goto", "done", ";", "in_use", "|=", "EV5_FM", ";", "}", "else", "in_use", "|=", "EV5_FA", "|", "EV5_FAM", ";", "break", ";", "case", "EV5_FA", ":", "if", "(", "in_use", "&", "EV5_FA", ")", "goto", "done", ";", "in_use", "|=", "EV5_FA", ";", "break", ";", "case", "EV5_FM", ":", "if", "(", "in_use", "&", "EV5_FM", ")", "goto", "done", ";", "in_use", "|=", "EV5_FM", ";", "break", ";", "case", "EV5_NONE", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "len", "+=", "4", ";", "if", "(", "GET_CODE", "(", "insn", ")", "==", "JUMP_INSN", ")", "goto", "next_and_done", ";", "next", ":", "insn", "=", "next_nonnote_insn", "(", "insn", ")", ";", "if", "(", "!", "insn", "||", "!", "INSN_P", "(", "insn", ")", ")", "goto", "done", ";", "if", "(", "GET_MODE", "(", "insn", ")", "==", "TImode", ")", "goto", "done", ";", "if", "(", "GET_CODE", "(", "insn", ")", "==", "CLOBBER", "||", "GET_CODE", "(", "insn", ")", "==", "USE", ")", "goto", "next", ";", "}", "next_and_done", ":", "insn", "=", "next_nonnote_insn", "(", "insn", ")", ";", "done", ":", "*", "plen", "=", "len", ";", "*", "pin_use", "=", "in_use", ";", "return", "insn", ";", "}", "</s>"], "natrual_language": ["IN_USE", "is", "a", "mask", "of", "the", "slots", "currently", "filled", "within", "the", "insn", "group", ".", "The", "mask", "bits", "come", "from", "alphaev5_pipe", "above", ".", "If", "EV5_E01", "is", "set", ",", "then", "the", "insn", "in", "EV5_E0", "can", "be", "swapped", "by", "the", "hardware", "into", "EV5_E1", ".", "LEN", "is", ",", "of", "course", ",", "the", "length", "of", "the", "group", "in", "bytes", "."], "TS_V_token": ["alpha", "0", "1", "0", "1", "4"], "File": "alpha3", "Func": "alphaev5_next_group", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40557, "Length": 381}
{"ground_truth": ["<s>", "static", "int", "alpha_adjust_cost", "(", "rtx", "insn", ",", "rtx", "link", ",", "rtx", "dep_insn", ",", "int", "cost", ")", "{", "enum", "attr_type", "insn_type", ",", "dep_insn_type", ";", "if", "(", "REG_NOTE_KIND", "(", "link", ")", "!=", "0", ")", "return", "cost", ";", "if", "(", "recog_memoized", "(", "insn", ")", "<", "0", "||", "recog_memoized", "(", "dep_insn", ")", "<", "0", ")", "return", "cost", ";", "insn_type", "=", "get_attr_type", "(", "insn", ")", ";", "dep_insn_type", "=", "get_attr_type", "(", "dep_insn", ")", ";", "if", "(", "dep_insn_type", "==", "TYPE_ILD", "||", "dep_insn_type", "==", "TYPE_FLD", "||", "dep_insn_type", "==", "TYPE_LDSYM", ")", "cost", "+=", "alpha_memory_latency", "-", "1", ";", "return", "cost", ";", "}", "</s>"], "natrual_language": ["Adjust", "the", "cost", "of", "a", "scheduling", "dependency", ".", "Return", "the", "new", "cost", "of", "a", "dependency", "LINK", "or", "INSN", "on", "DEP_INSN", ".", "COST", "is", "the", "current", "cost", "."], "TS_V_token": ["alpha", "0", "0", "0", "1"], "File": "alpha3", "Func": "alpha_adjust_cost", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40558, "Length": 92}
{"ground_truth": ["<s>", "static", "void", "alpha_align_insns", "(", "unsigned", "int", "max_align", ",", "rtx", "(", "*", "next_group", ")", "(", "rtx", ",", "int", "*", ",", "int", "*", ")", ",", "rtx", "(", "*", "next_nop", ")", "(", "int", "*", ")", ")", "{", "unsigned", "int", "align", ";", "int", "ofs", ";", "int", "prev_in_use", ",", "in_use", ",", "len", ",", "ldgp", ";", "rtx", "i", ",", "next", ";", "shorten_branches", "(", "get_insns", "(", ")", ")", ";", "if", "(", "align_functions", "<", "4", ")", "align", "=", "4", ";", "else", "if", "(", "(", "unsigned", "int", ")", "align_functions", "<", "max_align", ")", "align", "=", "align_functions", ";", "else", "align", "=", "max_align", ";", "ofs", "=", "prev_in_use", "=", "0", ";", "i", "=", "get_insns", "(", ")", ";", "if", "(", "GET_CODE", "(", "i", ")", "==", "NOTE", ")", "i", "=", "next_nonnote_insn", "(", "i", ")", ";", "ldgp", "=", "alpha_function_needs_gp", "?", "8", ":", "0", ";", "while", "(", "i", ")", "{", "next", "=", "(", "*", "next_group", ")", "(", "i", ",", "&", "in_use", ",", "&", "len", ")", ";", "if", "(", "GET_CODE", "(", "i", ")", "==", "CODE_LABEL", ")", "{", "unsigned", "int", "new_align", "=", "1", "<<", "label_to_alignment", "(", "i", ")", ";", "if", "(", "new_align", ">=", "align", ")", "{", "align", "=", "new_align", "<", "max_align", "?", "new_align", ":", "max_align", ";", "ofs", "=", "0", ";", "}", "else", "if", "(", "ofs", "&", "(", "new_align", "-", "1", ")", ")", "ofs", "=", "(", "ofs", "|", "(", "new_align", "-", "1", ")", ")", "+", "1", ";", "gcc_assert", "(", "!", "len", ")", ";", "}", "else", "if", "(", "in_use", "==", "0", ")", "{", "if", "(", "len", "<", "0", ")", "{", "ofs", "=", "0", ";", "align", "=", "4", ";", "len", "=", "0", ";", "}", "}", "else", "if", "(", "(", "int", ")", "align", "<", "len", ")", "{", "unsigned", "int", "new_log_align", "=", "len", ">", "8", "?", "4", ":", "3", ";", "rtx", "prev", ",", "where", ";", "where", "=", "prev", "=", "prev_nonnote_insn", "(", "i", ")", ";", "if", "(", "!", "where", "||", "GET_CODE", "(", "where", ")", "!=", "CODE_LABEL", ")", "where", "=", "i", ";", "if", "(", "!", "(", "TARGET_EXPLICIT_RELOCS", "&&", "prev", "&&", "GET_CODE", "(", "prev", ")", "==", "CALL_INSN", ")", ")", "{", "emit_insn_before", "(", "gen_realign", "(", "GEN_INT", "(", "new_log_align", ")", ")", ",", "where", ")", ";", "align", "=", "1", "<<", "new_log_align", ";", "ofs", "=", "0", ";", "}", "}", "else", "if", "(", "ldgp", ">", "0", ")", "ldgp", "-=", "len", ";", "else", "if", "(", "ofs", "+", "len", ">", "(", "int", ")", "align", ")", "{", "int", "nop_count", "=", "(", "align", "-", "ofs", ")", "/", "4", ";", "rtx", "where", ";", "where", "=", "prev_nonnote_insn", "(", "i", ")", ";", "if", "(", "where", ")", "{", "if", "(", "GET_CODE", "(", "where", ")", "==", "CODE_LABEL", ")", "{", "rtx", "where2", "=", "prev_nonnote_insn", "(", "where", ")", ";", "if", "(", "where2", "&&", "GET_CODE", "(", "where2", ")", "==", "JUMP_INSN", ")", "where", "=", "where2", ";", "}", "else", "if", "(", "GET_CODE", "(", "where", ")", "==", "INSN", ")", "where", "=", "i", ";", "}", "else", "where", "=", "i", ";", "do", "emit_insn_before", "(", "(", "*", "next_nop", ")", "(", "&", "prev_in_use", ")", ",", "where", ")", ";", "while", "(", "--", "nop_count", ")", ";", "ofs", "=", "0", ";", "}", "ofs", "=", "(", "ofs", "+", "len", ")", "&", "(", "align", "-", "1", ")", ";", "prev_in_use", "=", "in_use", ";", "i", "=", "next", ";", "}", "}", "</s>"], "natrual_language": ["The", "instruction", "group", "alignment", "main", "loop", "."], "TS_V_token": ["alpha", "4", "4", "0", "8", "0", "1", "0", "1", "1", "1", "0", "0", "0", "4", "0", "8", "4", "3", "1", "0", "0", "4", "0", "1"], "File": "alpha3", "Func": "alpha_align_insns", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40559, "Length": 502}
{"ground_truth": ["<s>", "enum", "avms_arg_type", "alpha_arg_type", "(", "enum", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "SFmode", ":", "return", "TARGET_FLOAT_VAX", "?", "FF", ":", "FS", ";", "case", "DFmode", ":", "return", "TARGET_FLOAT_VAX", "?", "FD", ":", "FT", ";", "default", ":", "return", "I64", ";", "}", "}", "</s>"], "natrual_language": ["Return", "the", "VMS", "argument", "type", "corresponding", "to", "MODE", "."], "TS_V_token": ["alpha"], "File": "alpha3", "Func": "alpha_arg_type", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40560, "Length": 41}
{"ground_truth": ["<s>", "static", "bool", "alpha_cannot_copy_insn_p", "(", "rtx", "insn", ")", "{", "if", "(", "!", "reload_completed", "||", "!", "TARGET_EXPLICIT_RELOCS", ")", "return", "false", ";", "if", "(", "recog_memoized", "(", "insn", ")", ">=", "0", ")", "return", "get_attr_cannot_copy", "(", "insn", ")", ";", "else", "return", "false", ";", "}", "</s>"], "natrual_language": ["Indicate", "that", "INSN", "can", "not", "be", "duplicated", ".", "This", "is", "true", "for", "any", "insn", "that", "we", "'ve", "marked", "with", "gpdisp", "relocs", ",", "since", "those", "have", "to", "stay", "in", "1-1", "correspondence", "with", "one", "another", ".", "Technically", "we", "could", "copy", "them", "if", "we", "could", "set", "up", "a", "mapping", "from", "one", "sequence", "number", "to", "another", ",", "across", "the", "set", "of", "insns", "to", "be", "duplicated", ".", "This", "seems", "overly", "complicated", "and", "error-prone", "since", "interblock", "motion", "from", "sched-ebb", "could", "move", "one", "of", "the", "pair", "of", "insns", "to", "a", "different", "block", ".", "Also", "can", "not", "allow", "jsr", "insns", "to", "be", "duplicated", ".", "If", "they", "throw", "exceptions", ",", "then", "they", "'ll", "be", "in", "a", "different", "block", "from", "their", "ldgp", ".", "Which", "could", "lead", "the", "bb", "reorder", "code", "to", "think", "that", "it", "would", "be", "ok", "to", "copy", "just", "the", "block", "containing", "the", "call", "and", "branch", "to", "the", "block", "containing", "the", "ldgp", "."], "TS_V_token": ["alpha", "0"], "File": "alpha3", "Func": "alpha_cannot_copy_insn_p", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40561, "Length": 39}
{"ground_truth": ["<s>", "static", "bool", "alpha_cannot_force_const_mem", "(", "rtx", "x", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "return", "code", "==", "SYMBOL_REF", "||", "code", "==", "LABEL_REF", "||", "code", "==", "CONST", ";", "}", "</s>"], "natrual_language": ["Primarily", "this", "is", "required", "for", "TLS", "symbols", ",", "but", "given", "that", "our", "move", "patterns", "*", "ought", "*", "to", "be", "able", "to", "handle", "any", "symbol", "at", "any", "time", ",", "we", "should", "never", "be", "spilling", "symbolic", "operands", "to", "the", "constant", "pool", ",", "ever", "."], "TS_V_token": ["alpha"], "File": "alpha3", "Func": "alpha_cannot_force_const_mem", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40562, "Length": 31}
{"ground_truth": ["<s>", "bool", "alpha_const_double_ok_for_letter_p", "(", "rtx", "value", ",", "int", "c", ")", "{", "switch", "(", "c", ")", "{", "case", "'G'", ":", "return", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "value", ")", ")", "==", "MODE_FLOAT", "&&", "value", "==", "CONST0_RTX", "(", "GET_MODE", "(", "value", ")", ")", ")", ";", "case", "'H'", ":", "return", "(", "GET_MODE", "(", "value", ")", "==", "VOIDmode", "&&", "zap_mask", "(", "CONST_DOUBLE_LOW", "(", "value", ")", ")", "&&", "zap_mask", "(", "CONST_DOUBLE_HIGH", "(", "value", ")", ")", ")", ";", "default", ":", "return", "false", ";", "}", "}", "</s>"], "natrual_language": ["Implements", "CONST_DOUBLE_OK_FOR_LETTER_P", ".", "Return", "true", "if", "VALUE", "matches", "for", "C", "in", "[", "GH", "]", "."], "TS_V_token": ["alpha"], "File": "alpha3", "Func": "alpha_const_double_ok_for_letter_p", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40563, "Length": 77}
{"ground_truth": ["<s>", "bool", "alpha_const_ok_for_letter_p", "(", "HOST_WIDE_INT", "value", ",", "int", "c", ")", "{", "switch", "(", "c", ")", "{", "case", "'I'", ":", "return", "(", "unsigned", "HOST_WIDE_INT", ")", "value", "<", "0x100", ";", "case", "'J'", ":", "return", "value", "==", "0", ";", "case", "'K'", ":", "return", "(", "unsigned", "HOST_WIDE_INT", ")", "(", "value", "+", "0x8000", ")", "<", "0x10000", ";", "case", "'L'", ":", "return", "(", "(", "value", "&", "0xffff", ")", "==", "0", "&&", "(", "(", "value", ")", ">>", "31", "==", "-", "1", "||", "value", ">>", "31", "==", "0", ")", ")", ";", "case", "'M'", ":", "return", "zap_mask", "(", "value", ")", ";", "case", "'N'", ":", "return", "(", "unsigned", "HOST_WIDE_INT", ")", "(", "~", "value", ")", "<", "0x100", ";", "case", "'O'", ":", "return", "(", "unsigned", "HOST_WIDE_INT", ")", "(", "-", "value", ")", "<", "0x100", ";", "case", "'P'", ":", "return", "value", "==", "1", "||", "value", "==", "2", "||", "value", "==", "3", ";", "default", ":", "return", "false", ";", "}", "}", "</s>"], "natrual_language": ["Implements", "CONST_OK_FOR_LETTER_P", ".", "Return", "true", "if", "the", "value", "matches", "the", "range", "defined", "for", "C", "in", "[", "I-P", "]", "."], "TS_V_token": ["alpha", "0x100", "0", "0x8000", "0x10000", "0xffff", "0", "31", "1", "31", "0", "0x100", "0x100", "1", "2", "3"], "File": "alpha3", "Func": "alpha_const_ok_for_letter_p", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40564, "Length": 144}
{"ground_truth": ["<s>", "static", "void", "alpha_elf_select_rtx_section", "(", "enum", "machine_mode", "mode", ",", "rtx", "x", ",", "unsigned", "HOST_WIDE_INT", "align", ")", "{", "if", "(", "TARGET_SMALL_DATA", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<=", "g_switch_value", ")", "sdata_section", "(", ")", ";", "else", "default_elf_select_rtx_section", "(", "mode", ",", "x", ",", "align", ")", ";", "}", "</s>"], "natrual_language": ["Switch", "to", "the", "section", "to", "which", "we", "should", "output", "X", ".", "The", "only", "thing", "special", "we", "do", "here", "is", "to", "honor", "small", "data", "."], "TS_V_token": ["alpha"], "File": "alpha3", "Func": "alpha_elf_select_rtx_section", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40565, "Length": 42}
{"ground_truth": ["<s>", "rtx", "alpha_emit_setcc", "(", "enum", "rtx_code", "code", ")", "{", "enum", "rtx_code", "cmp_code", ";", "rtx", "op0", "=", "alpha_compare", ".", "op0", ",", "op1", "=", "alpha_compare", ".", "op1", ";", "int", "fp_p", "=", "alpha_compare", ".", "fp_p", ";", "rtx", "tmp", ";", "memset", "(", "&", "alpha_compare", ",", "0", ",", "sizeof", "(", "alpha_compare", ")", ")", ";", "if", "(", "fp_p", "&&", "GET_MODE", "(", "op0", ")", "==", "TFmode", ")", "{", "op0", "=", "alpha_emit_xfloating_compare", "(", "&", "code", ",", "op0", ",", "op1", ")", ";", "op1", "=", "const0_rtx", ";", "fp_p", "=", "0", ";", "}", "if", "(", "fp_p", "&&", "!", "TARGET_FIX", ")", "return", "NULL_RTX", ";", "cmp_code", "=", "UNKNOWN", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "LE", ":", "case", "LT", ":", "case", "LEU", ":", "case", "LTU", ":", "case", "UNORDERED", ":", "if", "(", "fp_p", ")", "cmp_code", "=", "code", ",", "code", "=", "NE", ";", "break", ";", "case", "NE", ":", "if", "(", "!", "fp_p", "&&", "op1", "==", "const0_rtx", ")", "break", ";", "case", "ORDERED", ":", "cmp_code", "=", "reverse_condition", "(", "code", ")", ";", "code", "=", "EQ", ";", "break", ";", "case", "GE", ":", "case", "GT", ":", "case", "GEU", ":", "case", "GTU", ":", "if", "(", "!", "fp_p", "&&", "op1", "==", "const0_rtx", ")", "break", ";", "code", "=", "swap_condition", "(", "code", ")", ";", "if", "(", "fp_p", ")", "cmp_code", "=", "code", ",", "code", "=", "NE", ";", "tmp", "=", "op0", ",", "op0", "=", "op1", ",", "op1", "=", "tmp", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "!", "fp_p", ")", "{", "if", "(", "!", "register_operand", "(", "op0", ",", "DImode", ")", ")", "op0", "=", "force_reg", "(", "DImode", ",", "op0", ")", ";", "if", "(", "!", "reg_or_8bit_operand", "(", "op1", ",", "DImode", ")", ")", "op1", "=", "force_reg", "(", "DImode", ",", "op1", ")", ";", "}", "if", "(", "cmp_code", "!=", "UNKNOWN", ")", "{", "enum", "machine_mode", "mode", "=", "fp_p", "?", "DFmode", ":", "DImode", ";", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "tmp", ",", "gen_rtx_fmt_ee", "(", "cmp_code", ",", "mode", ",", "op0", ",", "op1", ")", ")", ")", ";", "op0", "=", "fp_p", "?", "gen_lowpart", "(", "DImode", ",", "tmp", ")", ":", "tmp", ";", "op1", "=", "const0_rtx", ";", "}", "return", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "op0", ",", "op1", ")", ";", "}", "</s>"], "natrual_language": ["Certain", "simplifications", "can", "be", "done", "to", "make", "invalid", "setcc", "operations", "valid", ".", "Return", "the", "final", "comparison", ",", "or", "NULL", "if", "we", "ca", "n't", "work", "."], "TS_V_token": ["alpha", "0", "0"], "File": "alpha3", "Func": "alpha_emit_setcc", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40566, "Length": 346}
{"ground_truth": ["<s>", "static", "rtx", "alpha_emit_set_const", "(", "rtx", "target", ",", "enum", "machine_mode", "mode", ",", "HOST_WIDE_INT", "c", ",", "int", "n", ",", "bool", "no_output", ")", "{", "enum", "machine_mode", "orig_mode", "=", "mode", ";", "rtx", "orig_target", "=", "target", ";", "rtx", "result", "=", "0", ";", "int", "i", ";", "if", "(", "no_new_pseudos", "&&", "mode", "==", "SImode", "&&", "GET_CODE", "(", "target", ")", "==", "REG", "&&", "REGNO", "(", "target", ")", "<", "FIRST_PSEUDO_REGISTER", ")", "{", "result", "=", "alpha_emit_set_const_1", "(", "target", ",", "mode", ",", "c", ",", "1", ",", "no_output", ")", ";", "if", "(", "result", ")", "return", "result", ";", "target", "=", "no_output", "?", "NULL", ":", "gen_lowpart", "(", "DImode", ",", "target", ")", ";", "mode", "=", "DImode", ";", "}", "else", "if", "(", "mode", "==", "V8QImode", "||", "mode", "==", "V4HImode", "||", "mode", "==", "V2SImode", ")", "{", "target", "=", "no_output", "?", "NULL", ":", "gen_lowpart", "(", "DImode", ",", "target", ")", ";", "mode", "=", "DImode", ";", "}", "for", "(", "i", "=", "1", ";", "i", "<=", "n", ";", "i", "++", ")", "{", "result", "=", "alpha_emit_set_const_1", "(", "target", ",", "mode", ",", "c", ",", "i", ",", "no_output", ")", ";", "if", "(", "result", ")", "{", "rtx", "insn", ",", "set", ";", "if", "(", "no_output", ")", "return", "result", ";", "insn", "=", "get_last_insn", "(", ")", ";", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "!", "CONSTANT_P", "(", "SET_SRC", "(", "set", ")", ")", ")", "set_unique_reg_note", "(", "get_last_insn", "(", ")", ",", "REG_EQUAL", ",", "GEN_INT", "(", "c", ")", ")", ";", "break", ";", "}", "}", "if", "(", "result", ")", "{", "if", "(", "result", "==", "target", ")", "result", "=", "orig_target", ";", "else", "if", "(", "mode", "!=", "orig_mode", ")", "result", "=", "gen_lowpart", "(", "orig_mode", ",", "result", ")", ";", "}", "return", "result", ";", "}", "</s>"], "natrual_language": ["Try", "to", "output", "insns", "to", "set", "TARGET", "equal", "to", "the", "constant", "C", "if", "it", "can", "be", "done", "in", "less", "than", "N", "insns", ".", "Do", "all", "computations", "in", "MODE", ".", "Returns", "the", "place", "where", "the", "output", "has", "been", "placed", "if", "it", "can", "be", "done", "and", "the", "insns", "have", "been", "emitted", ".", "If", "it", "would", "take", "more", "than", "N", "insns", ",", "zero", "is", "returned", "and", "no", "insns", "and", "emitted", "."], "TS_V_token": ["alpha", "0", "1", "1"], "File": "alpha3", "Func": "alpha_emit_set_const", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40567, "Length": 261}
{"ground_truth": ["<s>", "static", "rtx", "alpha_emit_set_long_const", "(", "rtx", "target", ",", "HOST_WIDE_INT", "c1", ",", "HOST_WIDE_INT", "c2", ")", "{", "HOST_WIDE_INT", "d1", ",", "d2", ",", "d3", ",", "d4", ";", "gcc_assert", "(", "c2", "==", "-", "(", "c1", "<", "0", ")", ")", ";", "d1", "=", "(", "(", "c1", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "c1", "-=", "d1", ";", "d2", "=", "(", "(", "c1", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "c1", "=", "(", "c1", "-", "d2", ")", ">>", "32", ";", "d3", "=", "(", "(", "c1", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "c1", "-=", "d3", ";", "d4", "=", "(", "(", "c1", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "gcc_assert", "(", "c1", "==", "d4", ")", ";", "d1", "=", "(", "(", "c1", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "c1", "-=", "d1", ";", "d2", "=", "(", "(", "c1", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "gcc_assert", "(", "c1", "==", "d2", ")", ";", "c2", "+=", "(", "d2", "<", "0", ")", ";", "d3", "=", "(", "(", "c2", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "c2", "-=", "d3", ";", "d4", "=", "(", "(", "c2", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "gcc_assert", "(", "c2", "==", "d4", ")", ";", "if", "(", "d4", ")", "{", "emit_move_insn", "(", "target", ",", "GEN_INT", "(", "d4", ")", ")", ";", "if", "(", "d3", ")", "emit_move_insn", "(", "target", ",", "gen_rtx_PLUS", "(", "DImode", ",", "target", ",", "GEN_INT", "(", "d3", ")", ")", ")", ";", "}", "else", "emit_move_insn", "(", "target", ",", "GEN_INT", "(", "d3", ")", ")", ";", "emit_move_insn", "(", "target", ",", "gen_rtx_ASHIFT", "(", "DImode", ",", "target", ",", "GEN_INT", "(", "32", ")", ")", ")", ";", "if", "(", "d2", ")", "emit_move_insn", "(", "target", ",", "gen_rtx_PLUS", "(", "DImode", ",", "target", ",", "GEN_INT", "(", "d2", ")", ")", ")", ";", "if", "(", "d1", ")", "emit_move_insn", "(", "target", ",", "gen_rtx_PLUS", "(", "DImode", ",", "target", ",", "GEN_INT", "(", "d1", ")", ")", ")", ";", "return", "target", ";", "}", "</s>"], "natrual_language": ["Having", "failed", "to", "find", "a", "3", "insn", "sequence", "in", "alpha_emit_set_const", ",", "fall", "back", "to", "a", "straight", "forward", "decomposition", ".", "We", "do", "this", "to", "avoid", "exponential", "run", "times", "encountered", "when", "looking", "for", "longer", "sequences", "with", "alpha_emit_set_const", "."], "TS_V_token": ["alpha", "0", "0xffff", "0x8000", "0x8000", "0xffffffff", "0x80000000", "0x80000000", "32", "0xffff", "0x8000", "0x8000", "0xffffffff", "0x80000000", "0x80000000", "0xffff", "0x8000", "0x8000", "0xffffffff", "0x80000000", "0x80000000", "0", "0xffff", "0x8000", "0x8000", "0xffffffff", "0x80000000", "0x80000000", "32"], "File": "alpha3", "Func": "alpha_emit_set_long_const", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40568, "Length": 313}
{"ground_truth": ["<s>", "static", "rtx", "alpha_emit_xfloating_compare", "(", "enum", "rtx_code", "*", "pcode", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "enum", "rtx_code", "cmp_code", ",", "res_code", ";", "rtx", "func", ",", "out", ",", "operands", "[", "2", "]", ";", "cmp_code", "=", "*", "pcode", ";", "switch", "(", "cmp_code", ")", "{", "case", "UNORDERED", ":", "cmp_code", "=", "EQ", ";", "res_code", "=", "LT", ";", "break", ";", "case", "ORDERED", ":", "cmp_code", "=", "EQ", ";", "res_code", "=", "GE", ";", "break", ";", "case", "NE", ":", "res_code", "=", "NE", ";", "break", ";", "case", "EQ", ":", "case", "LT", ":", "case", "GT", ":", "case", "LE", ":", "case", "GE", ":", "res_code", "=", "GT", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "*", "pcode", "=", "res_code", ";", "func", "=", "alpha_lookup_xfloating_lib_func", "(", "cmp_code", ")", ";", "operands", "[", "0", "]", "=", "op0", ";", "operands", "[", "1", "]", "=", "op1", ";", "out", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "alpha_emit_xfloating_libcall", "(", "func", ",", "out", ",", "operands", ",", "2", ",", "gen_rtx_fmt_ee", "(", "cmp_code", ",", "CCmode", ",", "op0", ",", "op1", ")", ")", ";", "return", "out", ";", "}", "</s>"], "natrual_language": ["Emit", "an", "X_floating", "library", "function", "call", "for", "a", "comparison", "."], "TS_V_token": ["alpha", "2", "0", "1", "2"], "File": "alpha3", "Func": "alpha_emit_xfloating_compare", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40569, "Length": 164}
{"ground_truth": ["<s>", "static", "void", "alpha_emit_xfloating_libcall", "(", "rtx", "func", ",", "rtx", "target", ",", "rtx", "operands", "[", "]", ",", "int", "noperands", ",", "rtx", "equiv", ")", "{", "rtx", "usage", "=", "NULL_RTX", ",", "tmp", ",", "reg", ";", "int", "regno", "=", "16", ",", "i", ";", "start_sequence", "(", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "noperands", ";", "++", "i", ")", "{", "switch", "(", "GET_MODE", "(", "operands", "[", "i", "]", ")", ")", "{", "case", "TFmode", ":", "reg", "=", "gen_rtx_REG", "(", "TFmode", ",", "regno", ")", ";", "regno", "+=", "2", ";", "break", ";", "case", "DFmode", ":", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "regno", "+", "32", ")", ";", "regno", "+=", "1", ";", "break", ";", "case", "VOIDmode", ":", "gcc_assert", "(", "GET_CODE", "(", "operands", "[", "i", "]", ")", "==", "CONST_INT", ")", ";", "case", "DImode", ":", "reg", "=", "gen_rtx_REG", "(", "DImode", ",", "regno", ")", ";", "regno", "+=", "1", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_move_insn", "(", "reg", ",", "operands", "[", "i", "]", ")", ";", "usage", "=", "alloc_EXPR_LIST", "(", "0", ",", "gen_rtx_USE", "(", "VOIDmode", ",", "reg", ")", ",", "usage", ")", ";", "}", "switch", "(", "GET_MODE", "(", "target", ")", ")", "{", "case", "TFmode", ":", "reg", "=", "gen_rtx_REG", "(", "TFmode", ",", "16", ")", ";", "break", ";", "case", "DFmode", ":", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "32", ")", ";", "break", ";", "case", "DImode", ":", "reg", "=", "gen_rtx_REG", "(", "DImode", ",", "0", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "tmp", "=", "gen_rtx_MEM", "(", "QImode", ",", "func", ")", ";", "tmp", "=", "emit_call_insn", "(", "GEN_CALL_VALUE", "(", "reg", ",", "tmp", ",", "const0_rtx", ",", "const0_rtx", ",", "const0_rtx", ")", ")", ";", "CALL_INSN_FUNCTION_USAGE", "(", "tmp", ")", "=", "usage", ";", "CONST_OR_PURE_CALL_P", "(", "tmp", ")", "=", "1", ";", "tmp", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "emit_libcall_block", "(", "tmp", ",", "target", ",", "reg", ",", "equiv", ")", ";", "}", "</s>"], "natrual_language": ["Emit", "an", "X_floating", "library", "function", "call", ".", "Note", "that", "these", "functions", "do", "not", "follow", "normal", "calling", "conventions", ":", "TFmode", "arguments", "are", "passed", "in", "two", "integer", "registers", "(", "as", "opposed", "to", "indirect", ")", ";", "TFmode", "return", "values", "appear", "in", "R16+R17", ".", "FUNC", "is", "the", "function", "name", "to", "call", ".", "TARGET", "is", "where", "the", "output", "belongs", ".", "OPERANDS", "are", "the", "inputs", ".", "NOPERANDS", "is", "the", "count", "of", "inputs", ".", "EQUIV", "is", "the", "expression", "equivalent", "for", "the", "function", "."], "TS_V_token": ["alpha", "16", "0", "2", "32", "1", "1", "0", "16", "32", "0", "1"], "File": "alpha3", "Func": "alpha_emit_xfloating_libcall", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40570, "Length": 293}
{"ground_truth": ["<s>", "void", "alpha_end_function", "(", "FILE", "*", "file", ",", "const", "char", "*", "fnname", ",", "tree", "decl", "ATTRIBUTE_UNUSED", ")", "{", "alpha_write_linkage", "(", "file", ",", "fnname", ",", "decl", ")", ";", "if", "(", "!", "TARGET_ABI_UNICOSMK", "&&", "!", "flag_inhibit_size_directive", ")", "{", "fputs", "(", "\"\\t.end \"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "fnname", ")", ";", "putc", "(", "'\\n'", ",", "file", ")", ";", "}", "inside_function", "=", "FALSE", ";", "if", "(", "TARGET_ABI_UNICOSMK", ")", "{", "unicosmk_output_ssib", "(", "file", ",", "fnname", ")", ";", "unicosmk_output_deferred_case_vectors", "(", "file", ")", ";", "}", "}", "</s>"], "natrual_language": ["Output", "the", "rest", "of", "the", "textual", "info", "surrounding", "the", "epilogue", "."], "TS_V_token": ["alpha", "\"\\t.end \""], "File": "alpha3", "Func": "alpha_end_function", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40571, "Length": 80}
{"ground_truth": ["<s>", "static", "rtx", "alpha_expand_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "rtx", "subtarget", "ATTRIBUTE_UNUSED", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "ignore", "ATTRIBUTE_UNUSED", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "TREE_OPERAND", "(", "exp", ",", "0", ")", ",", "0", ")", ";", "unsigned", "int", "fcode", "=", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ";", "tree", "arglist", "=", "TREE_OPERAND", "(", "exp", ",", "1", ")", ";", "enum", "insn_code", "icode", ";", "rtx", "op", "[", "MAX_ARGS", "]", ",", "pat", ";", "int", "arity", ";", "bool", "nonvoid", ";", "if", "(", "fcode", ">=", "ALPHA_BUILTIN_max", ")", "internal_error", "(", "\"bad builtin fcode\"", ")", ";", "icode", "=", "code_for_builtin", "[", "fcode", "]", ";", "if", "(", "icode", "==", "0", ")", "internal_error", "(", "\"bad builtin fcode\"", ")", ";", "nonvoid", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "fndecl", ")", ")", "!=", "void_type_node", ";", "for", "(", "arglist", "=", "TREE_OPERAND", "(", "exp", ",", "1", ")", ",", "arity", "=", "0", ";", "arglist", ";", "arglist", "=", "TREE_CHAIN", "(", "arglist", ")", ",", "arity", "++", ")", "{", "const", "struct", "insn_operand_data", "*", "insn_op", ";", "tree", "arg", "=", "TREE_VALUE", "(", "arglist", ")", ";", "if", "(", "arg", "==", "error_mark_node", ")", "return", "NULL_RTX", ";", "if", "(", "arity", ">", "MAX_ARGS", ")", "return", "NULL_RTX", ";", "insn_op", "=", "&", "insn_data", "[", "icode", "]", ".", "operand", "[", "arity", "+", "nonvoid", "]", ";", "op", "[", "arity", "]", "=", "expand_expr", "(", "arg", ",", "NULL_RTX", ",", "insn_op", "->", "mode", ",", "0", ")", ";", "if", "(", "!", "(", "*", "insn_op", "->", "predicate", ")", "(", "op", "[", "arity", "]", ",", "insn_op", "->", "mode", ")", ")", "op", "[", "arity", "]", "=", "copy_to_mode_reg", "(", "insn_op", "->", "mode", ",", "op", "[", "arity", "]", ")", ";", "}", "if", "(", "nonvoid", ")", "{", "enum", "machine_mode", "tmode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ";", "if", "(", "!", "target", "||", "GET_MODE", "(", "target", ")", "!=", "tmode", "||", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "predicate", ")", "(", "target", ",", "tmode", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "}", "switch", "(", "arity", ")", "{", "case", "0", ":", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ")", ";", "break", ";", "case", "1", ":", "if", "(", "nonvoid", ")", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op", "[", "0", "]", ")", ";", "else", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "op", "[", "0", "]", ")", ";", "break", ";", "case", "2", ":", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op", "[", "0", "]", ",", "op", "[", "1", "]", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "if", "(", "nonvoid", ")", "return", "target", ";", "else", "return", "const0_rtx", ";", "}", "</s>"], "natrual_language": ["Expand", "an", "expression", "EXP", "that", "calls", "a", "built-in", "function", ",", "with", "result", "going", "to", "TARGET", "if", "that", "'s", "convenient", "(", "and", "in", "mode", "MODE", "if", "that", "'s", "convenient", ")", ".", "SUBTARGET", "may", "be", "used", "as", "the", "target", "for", "computing", "one", "of", "EXP", "'s", "operands", ".", "IGNORE", "is", "nonzero", "if", "the", "value", "is", "to", "be", "ignored", "."], "TS_V_token": ["alpha", "0", "0", "1", "\"bad builtin fcode\"", "0", "\"bad builtin fcode\"", "1", "0", "0", "0", "0", "0", "1", "0", "0", "2", "0", "1"], "File": "alpha3", "Func": "alpha_expand_builtin", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40572, "Length": 425}
{"ground_truth": ["<s>", "bool", "alpha_expand_mov", "(", "enum", "machine_mode", "mode", ",", "rtx", "*", "operands", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "MEM", "&&", "!", "reg_or_0_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "operands", "[", "1", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "if", "(", "mode", "==", "Pmode", "&&", "symbolic_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "{", "rtx", "tmp", ";", "tmp", "=", "alpha_legitimize_address", "(", "operands", "[", "1", "]", ",", "operands", "[", "0", "]", ",", "mode", ")", ";", "if", "(", "tmp", ")", "{", "if", "(", "tmp", "==", "operands", "[", "0", "]", ")", "return", "true", ";", "operands", "[", "1", "]", "=", "tmp", ";", "return", "false", ";", "}", "}", "if", "(", "!", "CONSTANT_P", "(", "operands", "[", "1", "]", ")", "||", "input_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "CONST_INT", "||", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "CONST_DOUBLE", "||", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "CONST_VECTOR", ")", "{", "if", "(", "alpha_split_const_mov", "(", "mode", ",", "operands", ")", ")", "return", "true", ";", "}", "operands", "[", "1", "]", "=", "force_const_mem", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "if", "(", "reload_in_progress", ")", "{", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ")", ";", "operands", "[", "1", "]", "=", "copy_rtx", "(", "operands", "[", "1", "]", ")", ";", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", "=", "operands", "[", "0", "]", ";", "}", "else", "operands", "[", "1", "]", "=", "validize_mem", "(", "operands", "[", "1", "]", ")", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Expand", "a", "move", "instruction", ";", "return", "true", "if", "all", "work", "is", "done", ".", "We", "do", "n't", "handle", "non-bwx", "subword", "loads", "here", "."], "TS_V_token": ["alpha", "0", "1", "1", "1", "1", "1", "0", "0", "1", "1", "1", "1", "1", "1", "1", "1", "0", "1", "0", "1", "1", "1", "0", "0", "1", "1"], "File": "alpha3", "Func": "alpha_expand_mov", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40573, "Length": 271}
{"ground_truth": ["<s>", "void", "alpha_expand_movmisalign", "(", "enum", "machine_mode", "mode", ",", "rtx", "*", "operands", ")", "{", "if", "(", "MEM_P", "(", "operands", "[", "1", "]", ")", ")", "{", "rtx", "tmp", ";", "if", "(", "register_operand", "(", "operands", "[", "0", "]", ",", "mode", ")", ")", "tmp", "=", "operands", "[", "0", "]", ";", "else", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "alpha_expand_unaligned_load", "(", "tmp", ",", "operands", "[", "1", "]", ",", "8", ",", "0", ",", "0", ")", ";", "if", "(", "tmp", "!=", "operands", "[", "0", "]", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "tmp", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "operands", "[", "0", "]", ")", ")", "{", "if", "(", "!", "reg_or_0_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "operands", "[", "1", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "alpha_expand_unaligned_store", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "8", ",", "0", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "the", "movmisalign", "patterns", ".", "One", "of", "the", "operands", "is", "a", "memory", "that", "is", "not", "naturally", "aligned", ".", "Emit", "instructions", "to", "load", "it", "."], "TS_V_token": ["alpha", "1", "0", "0", "1", "8", "0", "0", "0", "0", "0", "1", "1", "1", "0", "1", "8", "0"], "File": "alpha3", "Func": "alpha_expand_movmisalign", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40574, "Length": 153}
{"ground_truth": ["<s>", "static", "void", "alpha_expand_unaligned_load_words", "(", "rtx", "*", "out_regs", ",", "rtx", "smem", ",", "HOST_WIDE_INT", "words", ",", "HOST_WIDE_INT", "ofs", ")", "{", "rtx", "const", "im8", "=", "GEN_INT", "(", "-", "8", ")", ";", "rtx", "const", "i64", "=", "GEN_INT", "(", "64", ")", ";", "rtx", "ext_tmps", "[", "MAX_MOVE_WORDS", "]", ",", "data_regs", "[", "MAX_MOVE_WORDS", "+", "1", "]", ";", "rtx", "sreg", ",", "areg", ",", "tmp", ",", "smema", ";", "HOST_WIDE_INT", "i", ";", "smema", "=", "XEXP", "(", "smem", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "smema", ")", "==", "LO_SUM", ")", "smema", "=", "force_reg", "(", "Pmode", ",", "smema", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "words", ";", "++", "i", ")", "{", "data_regs", "[", "i", "]", "=", "out_regs", "[", "i", "]", ";", "ext_tmps", "[", "i", "]", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "}", "data_regs", "[", "words", "]", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "if", "(", "ofs", "!=", "0", ")", "smem", "=", "adjust_address", "(", "smem", ",", "GET_MODE", "(", "smem", ")", ",", "ofs", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "words", ";", "++", "i", ")", "{", "tmp", "=", "change_address", "(", "smem", ",", "DImode", ",", "gen_rtx_AND", "(", "DImode", ",", "plus_constant", "(", "smema", ",", "8", "*", "i", ")", ",", "im8", ")", ")", ";", "set_mem_alias_set", "(", "tmp", ",", "0", ")", ";", "emit_move_insn", "(", "data_regs", "[", "i", "]", ",", "tmp", ")", ";", "}", "tmp", "=", "change_address", "(", "smem", ",", "DImode", ",", "gen_rtx_AND", "(", "DImode", ",", "plus_constant", "(", "smema", ",", "8", "*", "words", "-", "1", ")", ",", "im8", ")", ")", ";", "set_mem_alias_set", "(", "tmp", ",", "0", ")", ";", "emit_move_insn", "(", "data_regs", "[", "words", "]", ",", "tmp", ")", ";", "sreg", "=", "copy_addr_to_reg", "(", "smema", ")", ";", "areg", "=", "expand_binop", "(", "DImode", ",", "and_optab", ",", "sreg", ",", "GEN_INT", "(", "7", ")", ",", "NULL", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "if", "(", "WORDS_BIG_ENDIAN", ")", "emit_move_insn", "(", "sreg", ",", "plus_constant", "(", "sreg", ",", "7", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "words", ";", "++", "i", ")", "{", "if", "(", "WORDS_BIG_ENDIAN", ")", "{", "emit_insn", "(", "gen_extqh_be", "(", "data_regs", "[", "i", "]", ",", "data_regs", "[", "i", "]", ",", "sreg", ")", ")", ";", "emit_insn", "(", "gen_extxl_be", "(", "ext_tmps", "[", "i", "]", ",", "data_regs", "[", "i", "+", "1", "]", ",", "i64", ",", "sreg", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_extxl_le", "(", "data_regs", "[", "i", "]", ",", "data_regs", "[", "i", "]", ",", "i64", ",", "sreg", ")", ")", ";", "emit_insn", "(", "gen_extqh_le", "(", "ext_tmps", "[", "i", "]", ",", "data_regs", "[", "i", "+", "1", "]", ",", "sreg", ")", ")", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "ext_tmps", "[", "i", "]", ",", "gen_rtx_IF_THEN_ELSE", "(", "DImode", ",", "gen_rtx_EQ", "(", "DImode", ",", "areg", ",", "const0_rtx", ")", ",", "const0_rtx", ",", "ext_tmps", "[", "i", "]", ")", ")", ")", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "words", ";", "++", "i", ")", "{", "out_regs", "[", "i", "]", "=", "expand_binop", "(", "DImode", ",", "ior_optab", ",", "data_regs", "[", "i", "]", ",", "ext_tmps", "[", "i", "]", ",", "data_regs", "[", "i", "]", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "}", "}", "</s>"], "natrual_language": ["Load", "an", "integral", "number", "of", "consecutive", "unaligned", "quadwords", "."], "TS_V_token": ["alpha", "8", "64", "1", "0", "0", "0", "0", "8", "0", "8", "1", "0", "7", "1", "7", "0", "1", "1", "0", "1"], "File": "alpha3", "Func": "alpha_expand_unaligned_load_words", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40575, "Length": 485}
{"ground_truth": ["<s>", "rtx", "alpha_expand_zap_mask", "(", "HOST_WIDE_INT", "value", ")", "{", "rtx", "result", ";", "int", "i", ";", "if", "(", "HOST_BITS_PER_WIDE_INT", ">=", "64", ")", "{", "HOST_WIDE_INT", "mask", "=", "0", ";", "for", "(", "i", "=", "7", ";", "i", ">=", "0", ";", "--", "i", ")", "{", "mask", "<<=", "8", ";", "if", "(", "!", "(", "(", "value", ">>", "i", ")", "&", "1", ")", ")", "mask", "|=", "0xff", ";", "}", "result", "=", "gen_int_mode", "(", "mask", ",", "DImode", ")", ";", "}", "else", "{", "HOST_WIDE_INT", "mask_lo", "=", "0", ",", "mask_hi", "=", "0", ";", "gcc_assert", "(", "HOST_BITS_PER_WIDE_INT", "==", "32", ")", ";", "for", "(", "i", "=", "7", ";", "i", ">=", "4", ";", "--", "i", ")", "{", "mask_hi", "<<=", "8", ";", "if", "(", "!", "(", "(", "value", ">>", "i", ")", "&", "1", ")", ")", "mask_hi", "|=", "0xff", ";", "}", "for", "(", "i", "=", "3", ";", "i", ">=", "0", ";", "--", "i", ")", "{", "mask_lo", "<<=", "8", ";", "if", "(", "!", "(", "(", "value", ">>", "i", ")", "&", "1", ")", ")", "mask_lo", "|=", "0xff", ";", "}", "result", "=", "immed_double_const", "(", "mask_lo", ",", "mask_hi", ",", "DImode", ")", ";", "}", "return", "result", ";", "}", "</s>"], "natrual_language": ["Returns", "a", "mask", "so", "that", "zap", "(", "x", ",", "value", ")", "==", "x", "&", "mask", "."], "TS_V_token": ["alpha", "64", "0", "7", "0", "8", "1", "0xff", "0", "0", "32", "7", "4", "8", "1", "0xff", "3", "0", "8", "1", "0xff"], "File": "alpha3", "Func": "alpha_expand_zap_mask", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40576, "Length": 177}
{"ground_truth": ["<s>", "static", "void", "alpha_extract_integer", "(", "rtx", "x", ",", "HOST_WIDE_INT", "*", "p0", ",", "HOST_WIDE_INT", "*", "p1", ")", "{", "HOST_WIDE_INT", "i0", ",", "i1", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_VECTOR", ")", "x", "=", "simplify_subreg", "(", "DImode", ",", "x", ",", "GET_MODE", "(", "x", ")", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "{", "i0", "=", "INTVAL", "(", "x", ")", ";", "i1", "=", "-", "(", "i0", "<", "0", ")", ";", "}", "else", "if", "(", "HOST_BITS_PER_WIDE_INT", ">=", "64", ")", "{", "i0", "=", "CONST_DOUBLE_LOW", "(", "x", ")", ";", "i1", "=", "-", "(", "i0", "<", "0", ")", ";", "}", "else", "{", "i0", "=", "CONST_DOUBLE_LOW", "(", "x", ")", ";", "i1", "=", "CONST_DOUBLE_HIGH", "(", "x", ")", ";", "}", "*", "p0", "=", "i0", ";", "*", "p1", "=", "i1", ";", "}", "</s>"], "natrual_language": ["Given", "an", "integral", "CONST_INT", ",", "CONST_DOUBLE", ",", "or", "CONST_VECTOR", ",", "return", "the", "low", "64", "bits", "."], "TS_V_token": ["alpha", "0", "0", "64", "0"], "File": "alpha3", "Func": "alpha_extract_integer", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40577, "Length": 126}
{"ground_truth": ["<s>", "bool", "alpha_extra_constraint", "(", "rtx", "value", ",", "int", "c", ")", "{", "switch", "(", "c", ")", "{", "case", "'Q'", ":", "return", "normal_memory_operand", "(", "value", ",", "VOIDmode", ")", ";", "case", "'R'", ":", "return", "direct_call_operand", "(", "value", ",", "Pmode", ")", ";", "case", "'S'", ":", "return", "(", "GET_CODE", "(", "value", ")", "==", "CONST_INT", "&&", "(", "unsigned", "HOST_WIDE_INT", ")", "INTVAL", "(", "value", ")", "<", "64", ")", ";", "case", "'T'", ":", "return", "GET_CODE", "(", "value", ")", "==", "HIGH", ";", "case", "'U'", ":", "return", "TARGET_ABI_UNICOSMK", "&&", "symbolic_operand", "(", "value", ",", "VOIDmode", ")", ";", "case", "'W'", ":", "return", "(", "GET_CODE", "(", "value", ")", "==", "CONST_VECTOR", "&&", "value", "==", "CONST0_RTX", "(", "GET_MODE", "(", "value", ")", ")", ")", ";", "default", ":", "return", "false", ";", "}", "}", "</s>"], "natrual_language": ["Implements", "CONST_DOUBLE_OK_FOR_LETTER_P", ".", "Return", "true", "if", "VALUE", "matches", "for", "C", "."], "TS_V_token": ["alpha", "64"], "File": "alpha3", "Func": "alpha_extra_constraint", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40578, "Length": 115}
{"ground_truth": ["<s>", "static", "tree", "alpha_fold_builtin_cmpbge", "(", "unsigned", "HOST_WIDE_INT", "opint", "[", "]", ",", "long", "op_const", ")", "{", "if", "(", "op_const", "==", "3", ")", "{", "int", "i", ",", "val", ";", "for", "(", "i", "=", "0", ",", "val", "=", "0", ";", "i", "<", "8", ";", "++", "i", ")", "{", "unsigned", "HOST_WIDE_INT", "c0", "=", "(", "opint", "[", "0", "]", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ";", "unsigned", "HOST_WIDE_INT", "c1", "=", "(", "opint", "[", "1", "]", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ";", "if", "(", "c0", ">=", "c1", ")", "val", "|=", "1", "<<", "i", ";", "}", "return", "build_int_cst", "(", "long_integer_type_node", ",", "val", ")", ";", "}", "else", "if", "(", "op_const", "==", "2", "&&", "opint", "[", "1", "]", "==", "0", ")", "return", "build_int_cst", "(", "long_integer_type_node", ",", "0xff", ")", ";", "return", "NULL", ";", "}", "</s>"], "natrual_language": ["Fold", "the", "builtin", "for", "the", "CMPBGE", "instruction", ".", "This", "is", "a", "vector", "comparison", "with", "an", "8", "bit", "output", "vector", ".", "OPINT", "contains", "the", "integer", "operands", ";", "bit", "N", "of", "OP_CONST", "is", "set", "if", "OPINT", "[", "N", "]", "is", "valid", "."], "TS_V_token": ["alpha", "3", "0", "0", "8", "0", "8", "0xff", "1", "8", "0xff", "1", "2", "1", "0", "0xff"], "File": "alpha3", "Func": "alpha_fold_builtin_cmpbge", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40579, "Length": 130}
{"ground_truth": ["<s>", "static", "tree", "alpha_fold_builtin_extxx", "(", "tree", "op", "[", "]", ",", "unsigned", "HOST_WIDE_INT", "opint", "[", "]", ",", "long", "op_const", ",", "unsigned", "HOST_WIDE_INT", "bytemask", ",", "bool", "is_high", ")", "{", "long", "zap_const", "=", "2", ";", "tree", "*", "zap_op", "=", "NULL", ";", "if", "(", "op_const", "&", "2", ")", "{", "unsigned", "HOST_WIDE_INT", "loc", ";", "loc", "=", "opint", "[", "1", "]", "&", "7", ";", "if", "(", "BYTES_BIG_ENDIAN", ")", "loc", "^=", "7", ";", "loc", "*=", "8", ";", "if", "(", "loc", "!=", "0", ")", "{", "if", "(", "op_const", "&", "1", ")", "{", "unsigned", "HOST_WIDE_INT", "temp", "=", "opint", "[", "0", "]", ";", "if", "(", "is_high", ")", "temp", "<<=", "loc", ";", "else", "temp", ">>=", "loc", ";", "opint", "[", "0", "]", "=", "temp", ";", "zap_const", "=", "3", ";", "}", "}", "else", "zap_op", "=", "op", ";", "}", "opint", "[", "1", "]", "=", "bytemask", ";", "return", "alpha_fold_builtin_zapnot", "(", "zap_op", ",", "opint", ",", "zap_const", ")", ";", "}", "</s>"], "natrual_language": ["Fold", "the", "builtins", "for", "the", "EXT", "family", "of", "instructions", "."], "TS_V_token": ["alpha", "2", "2", "1", "7", "7", "8", "0", "1", "0", "0", "3", "1"], "File": "alpha3", "Func": "alpha_fold_builtin_extxx", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40580, "Length": 142}
{"ground_truth": ["<s>", "static", "tree", "alpha_fold_builtin_insxx", "(", "tree", "op", "[", "]", ",", "unsigned", "HOST_WIDE_INT", "opint", "[", "]", ",", "long", "op_const", ",", "unsigned", "HOST_WIDE_INT", "bytemask", ",", "bool", "is_high", ")", "{", "if", "(", "(", "op_const", "&", "1", ")", "&&", "opint", "[", "0", "]", "==", "0", ")", "return", "build_int_cst", "(", "long_integer_type_node", ",", "0", ")", ";", "if", "(", "op_const", "&", "2", ")", "{", "unsigned", "HOST_WIDE_INT", "temp", ",", "loc", ",", "byteloc", ";", "tree", "*", "zap_op", "=", "NULL", ";", "loc", "=", "opint", "[", "1", "]", "&", "7", ";", "if", "(", "BYTES_BIG_ENDIAN", ")", "loc", "^=", "7", ";", "bytemask", "<<=", "loc", ";", "temp", "=", "opint", "[", "0", "]", ";", "if", "(", "is_high", ")", "{", "byteloc", "=", "(", "64", "-", "(", "loc", "*", "8", ")", ")", "&", "0x3f", ";", "if", "(", "byteloc", "==", "0", ")", "zap_op", "=", "op", ";", "else", "temp", ">>=", "byteloc", ";", "bytemask", ">>=", "8", ";", "}", "else", "{", "byteloc", "=", "loc", "*", "8", ";", "if", "(", "byteloc", "==", "0", ")", "zap_op", "=", "op", ";", "else", "temp", "<<=", "byteloc", ";", "}", "opint", "[", "0", "]", "=", "temp", ";", "opint", "[", "1", "]", "=", "bytemask", ";", "return", "alpha_fold_builtin_zapnot", "(", "zap_op", ",", "opint", ",", "op_const", ")", ";", "}", "return", "NULL", ";", "}", "</s>"], "natrual_language": ["Fold", "the", "builtins", "for", "the", "INS", "family", "of", "instructions", "."], "TS_V_token": ["alpha", "1", "0", "0", "0", "2", "1", "7", "7", "0", "64", "8", "0x3f", "0", "8", "8", "0", "0", "1"], "File": "alpha3", "Func": "alpha_fold_builtin_insxx", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40581, "Length": 190}
{"ground_truth": ["<s>", "static", "tree", "alpha_fold_builtin_zapnot", "(", "tree", "*", "op", ",", "unsigned", "HOST_WIDE_INT", "opint", "[", "]", ",", "long", "op_const", ")", "{", "if", "(", "op_const", "&", "2", ")", "{", "unsigned", "HOST_WIDE_INT", "mask", "=", "0", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "++", "i", ")", "if", "(", "(", "opint", "[", "1", "]", ">>", "i", ")", "&", "1", ")", "mask", "|=", "(", "unsigned", "HOST_WIDE_INT", ")", "0xff", "<<", "(", "i", "*", "8", ")", ";", "if", "(", "op_const", "&", "1", ")", "return", "build_int_cst", "(", "long_integer_type_node", ",", "opint", "[", "0", "]", "&", "mask", ")", ";", "if", "(", "op", ")", "return", "fold", "(", "build2", "(", "BIT_AND_EXPR", ",", "long_integer_type_node", ",", "op", "[", "0", "]", ",", "build_int_cst", "(", "long_integer_type_node", ",", "mask", ")", ")", ")", ";", "}", "else", "if", "(", "(", "op_const", "&", "1", ")", "&&", "opint", "[", "0", "]", "==", "0", ")", "return", "build_int_cst", "(", "long_integer_type_node", ",", "0", ")", ";", "return", "NULL", ";", "}", "</s>"], "natrual_language": ["Fold", "the", "builtin", "for", "the", "ZAPNOT", "instruction", ".", "This", "is", "essentially", "a", "specialized", "form", "of", "an", "AND", "operation", ".", "Other", "byte", "manipulation", "instructions", "are", "defined", "in", "terms", "of", "this", "instruction", ",", "so", "this", "is", "also", "used", "as", "a", "subroutine", "for", "other", "builtins", ".", "OP", "contains", "the", "tree", "operands", ";", "OPINT", "contains", "the", "extracted", "integer", "values", ".", "Bit", "N", "of", "OP_CONST", "it", "set", "if", "OPINT", "[", "N", "]", "is", "valid", ".", "OP", "may", "be", "null", "if", "only", "OPINT", "may", "be", "considered", "."], "TS_V_token": ["alpha", "2", "0", "0", "8", "1", "1", "0xff", "8", "1", "0", "0", "1", "0", "0", "0"], "File": "alpha3", "Func": "alpha_fold_builtin_zapnot", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40582, "Length": 149}
{"ground_truth": ["<s>", "rtx", "alpha_gp_save_rtx", "(", "void", ")", "{", "rtx", "seq", ",", "m", "=", "cfun", "->", "machine", "->", "gp_save_rtx", ";", "if", "(", "m", "==", "NULL", ")", "{", "start_sequence", "(", ")", ";", "m", "=", "assign_stack_local", "(", "DImode", ",", "UNITS_PER_WORD", ",", "BITS_PER_WORD", ")", ";", "m", "=", "validize_mem", "(", "m", ")", ";", "emit_move_insn", "(", "m", ",", "pic_offset_table_rtx", ")", ";", "seq", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "emit_insn_after", "(", "seq", ",", "entry_of_function", "(", ")", ")", ";", "cfun", "->", "machine", "->", "gp_save_rtx", "=", "m", ";", "}", "return", "m", ";", "}", "</s>"], "natrual_language": ["Return", "or", "create", "a", "pseudo", "containing", "the", "gp", "value", "for", "the", "current", "function", ".", "Needed", "only", "if", "TARGET_LD_BUGGY_LDGP", "."], "TS_V_token": ["alpha"], "File": "alpha3", "Func": "alpha_gp_save_rtx", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40583, "Length": 85}
{"ground_truth": ["<s>", "static", "bool", "alpha_handle_option", "(", "size_t", "code", ",", "const", "char", "*", "arg", ",", "int", "value", ")", "{", "switch", "(", "code", ")", "{", "case", "OPT_mfp_regs", ":", "if", "(", "value", "==", "0", ")", "target_flags", "|=", "MASK_SOFT_FP", ";", "break", ";", "case", "OPT_mieee", ":", "case", "OPT_mieee_with_inexact", ":", "target_flags", "|=", "MASK_IEEE_CONFORMANT", ";", "break", ";", "case", "OPT_mtls_size_", ":", "if", "(", "value", "!=", "16", "&&", "value", "!=", "32", "&&", "value", "!=", "64", ")", "error", "(", "\"bad value %qs for -mtls-size switch\"", ",", "arg", ")", ";", "break", ";", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_HANDLE_OPTION", "."], "TS_V_token": ["alpha", "0", "16", "32", "64", "\"bad value %qs for -mtls-size switch\""], "File": "alpha3", "Func": "alpha_handle_option", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40584, "Length": 79}
{"ground_truth": ["<s>", "void", "alpha_initialize_trampoline", "(", "rtx", "tramp", ",", "rtx", "fnaddr", ",", "rtx", "cxt", ",", "int", "fnofs", ",", "int", "cxtofs", ",", "int", "jmpofs", ")", "{", "rtx", "temp", ",", "temp1", ",", "addr", ";", "enum", "machine_mode", "mode", "=", "TARGET_ABI_OPEN_VMS", "?", "Pmode", ":", "ptr_mode", ";", "fnaddr", "=", "convert_memory_address", "(", "mode", ",", "fnaddr", ")", ";", "cxt", "=", "convert_memory_address", "(", "mode", ",", "cxt", ")", ";", "addr", "=", "memory_address", "(", "mode", ",", "plus_constant", "(", "tramp", ",", "fnofs", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "mode", ",", "addr", ")", ",", "fnaddr", ")", ";", "addr", "=", "memory_address", "(", "mode", ",", "plus_constant", "(", "tramp", ",", "cxtofs", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "mode", ",", "addr", ")", ",", "cxt", ")", ";", "if", "(", "0", "&&", "jmpofs", ">=", "0", ")", "{", "temp", "=", "force_operand", "(", "plus_constant", "(", "tramp", ",", "jmpofs", "+", "4", ")", ",", "NULL_RTX", ")", ";", "temp", "=", "expand_binop", "(", "DImode", ",", "sub_optab", ",", "fnaddr", ",", "temp", ",", "temp", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "temp", "=", "expand_shift", "(", "RSHIFT_EXPR", ",", "Pmode", ",", "temp", ",", "build_int_cst", "(", "NULL_TREE", ",", "2", ")", ",", "NULL_RTX", ",", "1", ")", ";", "temp", "=", "expand_and", "(", "SImode", ",", "gen_lowpart", "(", "SImode", ",", "temp", ")", ",", "GEN_INT", "(", "0x3fff", ")", ",", "0", ")", ";", "addr", "=", "memory_address", "(", "SImode", ",", "plus_constant", "(", "tramp", ",", "jmpofs", ")", ")", ";", "temp1", "=", "force_reg", "(", "SImode", ",", "gen_rtx_MEM", "(", "SImode", ",", "addr", ")", ")", ";", "temp1", "=", "expand_and", "(", "SImode", ",", "temp1", ",", "GEN_INT", "(", "0xffffc000", ")", ",", "NULL_RTX", ")", ";", "temp1", "=", "expand_binop", "(", "SImode", ",", "ior_optab", ",", "temp1", ",", "temp", ",", "temp1", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "addr", ")", ",", "temp1", ")", ";", "}", "emit_library_call", "(", "init_one_libfunc", "(", "\"__enable_execute_stack\"", ")", ",", "0", ",", "VOIDmode", ",", "1", ",", "tramp", ",", "Pmode", ")", ";", "if", "(", "jmpofs", ">=", "0", ")", "emit_insn", "(", "gen_imb", "(", ")", ")", ";", "}", "</s>"], "natrual_language": ["Emit", "RTL", "insns", "to", "initialize", "the", "variable", "parts", "of", "a", "trampoline", "at", "TRAMP", ".", "FNADDR", "is", "an", "RTX", "for", "the", "address", "of", "the", "function", "'s", "pure", "code", ".", "CXT", "is", "an", "RTX", "for", "the", "static", "chain", "value", "for", "the", "function", ".", "The", "three", "offset", "parameters", "are", "for", "the", "individual", "template", "'s", "layout", ".", "A", "JMPOFS", "<", "0", "indicates", "that", "the", "trampoline", "does", "not", "contain", "instructions", "at", "all", ".", "We", "assume", "here", "that", "a", "function", "will", "be", "called", "many", "more", "times", "than", "its", "address", "is", "taken", "(", "e.g.", ",", "it", "might", "be", "passed", "to", "qsort", ")", ",", "so", "we", "take", "the", "trouble", "to", "initialize", "the", "``", "hint", "''", "field", "in", "the", "JMP", "insn", ".", "Note", "that", "the", "hint", "field", "is", "PC", "(", "new", ")", "+", "4", "*", "bits", "13:0", "."], "TS_V_token": ["alpha", "0", "0", "4", "1", "2", "1", "0x3fff", "0", "0xffffc000", "1", "\"__enable_execute_stack\"", "0", "1", "0"], "File": "alpha3", "Func": "alpha_initialize_trampoline", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40585, "Length": 304}
{"ground_truth": ["<s>", "HOST_WIDE_INT", "alpha_initial_elimination_offset", "(", "unsigned", "int", "from", ",", "unsigned", "int", "to", "ATTRIBUTE_UNUSED", ")", "{", "HOST_WIDE_INT", "ret", ";", "ret", "=", "alpha_sa_size", "(", ")", ";", "ret", "+=", "ALPHA_ROUND", "(", "current_function_outgoing_args_size", ")", ";", "switch", "(", "from", ")", "{", "case", "FRAME_POINTER_REGNUM", ":", "break", ";", "case", "ARG_POINTER_REGNUM", ":", "ret", "+=", "(", "ALPHA_ROUND", "(", "get_frame_size", "(", ")", "+", "current_function_pretend_args_size", ")", "-", "current_function_pretend_args_size", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "ret", ";", "}", "</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": ["alpha"], "File": "alpha3", "Func": "alpha_initial_elimination_offset", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40586, "Length": 70}
{"ground_truth": ["<s>", "static", "bool", "alpha_in_small_data_p", "(", "tree", "exp", ")", "{", "if", "(", "TREE_CODE", "(", "exp", ")", "==", "STRING_CST", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "exp", ")", "==", "FUNCTION_DECL", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "exp", ")", "==", "VAR_DECL", "&&", "DECL_SECTION_NAME", "(", "exp", ")", ")", "{", "const", "char", "*", "section", "=", "TREE_STRING_POINTER", "(", "DECL_SECTION_NAME", "(", "exp", ")", ")", ";", "if", "(", "strcmp", "(", "section", ",", "\".sdata\"", ")", "==", "0", "||", "strcmp", "(", "section", ",", "\".sbss\"", ")", "==", "0", ")", "return", "true", ";", "}", "else", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "TREE_TYPE", "(", "exp", ")", ")", ";", "if", "(", "size", ">", "0", "&&", "(", "unsigned", "HOST_WIDE_INT", ")", "size", "<=", "g_switch_value", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "EXP", "should", "be", "placed", "in", "the", "small", "data", "section", "."], "TS_V_token": ["alpha", "\".sdata\"", "0", "\".sbss\"", "0", "0"], "File": "alpha3", "Func": "alpha_in_small_data_p", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40587, "Length": 119}
{"ground_truth": ["<s>", "bool", "alpha_legitimate_address_p", "(", "enum", "machine_mode", "mode", ",", "rtx", "x", ",", "int", "strict", ")", "{", "if", "(", "mode", "==", "DImode", "&&", "GET_CODE", "(", "x", ")", "==", "AND", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "-", "8", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SUBREG", "&&", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", "<", "GET_MODE_SIZE", "(", "GET_MODE", "(", "SUBREG_REG", "(", "x", ")", ")", ")", ")", ")", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "if", "(", "REG_P", "(", "x", ")", "&&", "(", "strict", "?", "STRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ":", "NONSTRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ")", ")", "return", "true", ";", "if", "(", "CONSTANT_ADDRESS_P", "(", "x", ")", ")", "return", "true", ";", "if", "(", "LINKAGE_SYMBOL_REF_P", "(", "x", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "rtx", "ofs", "=", "XEXP", "(", "x", ",", "1", ")", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SUBREG", "&&", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", "<", "GET_MODE_SIZE", "(", "GET_MODE", "(", "SUBREG_REG", "(", "x", ")", ")", ")", ")", ")", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "if", "(", "REG_P", "(", "x", ")", ")", "{", "if", "(", "!", "strict", "&&", "NONSTRICT_REG_OK_FP_BASE_P", "(", "x", ")", "&&", "GET_CODE", "(", "ofs", ")", "==", "CONST_INT", ")", "return", "true", ";", "if", "(", "(", "strict", "?", "STRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ":", "NONSTRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ")", "&&", "CONSTANT_ADDRESS_P", "(", "ofs", ")", ")", "return", "true", ";", "}", "}", "else", "if", "(", "TARGET_EXPLICIT_RELOCS", ")", "{", "if", "(", "small_symbolic_operand", "(", "x", ",", "Pmode", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "LO_SUM", ")", "{", "rtx", "ofs", "=", "XEXP", "(", "x", ",", "1", ")", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SUBREG", "&&", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", "<", "GET_MODE_SIZE", "(", "GET_MODE", "(", "SUBREG_REG", "(", "x", ")", ")", ")", ")", ")", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "if", "(", "!", "(", "REG_P", "(", "x", ")", "&&", "(", "strict", "?", "STRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ":", "NONSTRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ")", ")", ")", "return", "false", ";", "if", "(", "local_symbolic_operand", "(", "ofs", ",", "Pmode", ")", "||", "dtp32_symbolic_operand", "(", "ofs", ",", "Pmode", ")", "||", "tp32_symbolic_operand", "(", "ofs", ",", "Pmode", ")", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["legitimate_address_p", "recognizes", "an", "RTL", "expression", "that", "is", "a", "valid", "memory", "address", "for", "an", "instruction", ".", "The", "MODE", "argument", "is", "the", "machine", "mode", "for", "the", "MEM", "expression", "that", "wants", "to", "use", "this", "address", ".", "For", "Alpha", ",", "we", "have", "either", "a", "constant", "address", "or", "the", "sum", "of", "a", "register", "and", "a", "constant", "address", ",", "or", "just", "a", "register", ".", "For", "DImode", ",", "any", "of", "those", "forms", "can", "be", "surrounded", "with", "an", "AND", "that", "clear", "the", "low-order", "three", "bits", ";", "this", "is", "an", "``", "unaligned", "''", "access", "."], "TS_V_token": ["alpha", "1", "1", "8", "0", "1", "0", "1", "0"], "File": "alpha3", "Func": "alpha_legitimate_address_p", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40588, "Length": 405}
{"ground_truth": ["<s>", "bool", "alpha_legitimate_constant_p", "(", "rtx", "x", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "HOST_WIDE_INT", "i0", ",", "i1", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST", ":", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "case", "HIGH", ":", "return", "true", ";", "case", "CONST_DOUBLE", ":", "if", "(", "x", "==", "CONST0_RTX", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", ")", "return", "false", ";", "goto", "do_integer", ";", "case", "CONST_VECTOR", ":", "if", "(", "x", "==", "CONST0_RTX", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_VECTOR_INT", ")", "return", "false", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "!=", "8", ")", "return", "false", ";", "goto", "do_integer", ";", "case", "CONST_INT", ":", "do_integer", ":", "if", "(", "TARGET_BUILD_CONSTANTS", ")", "return", "true", ";", "alpha_extract_integer", "(", "x", ",", "&", "i0", ",", "&", "i1", ")", ";", "if", "(", "HOST_BITS_PER_WIDE_INT", ">=", "64", "||", "i1", "==", "(", "-", "i0", "<", "0", ")", ")", "return", "alpha_emit_set_const_1", "(", "x", ",", "mode", ",", "i0", ",", "3", ",", "true", ")", "!=", "NULL", ";", "return", "false", ";", "default", ":", "return", "false", ";", "}", "}", "</s>"], "natrual_language": ["Implement", "LEGITIMATE_CONSTANT_P", ".", "This", "is", "all", "constants", "for", "which", "we", "are", "willing", "to", "load", "the", "value", "into", "a", "register", "via", "a", "move", "pattern", ".", "Normally", "this", "is", "all", "symbolic", "constants", ",", "integral", "constants", "that", "take", "three", "or", "fewer", "instructions", ",", "and", "floating-point", "zero", "."], "TS_V_token": ["alpha", "8", "64", "0", "3"], "File": "alpha3", "Func": "alpha_legitimate_constant_p", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40589, "Length": 178}
{"ground_truth": ["<s>", "rtx", "alpha_legitimize_reload_address", "(", "rtx", "x", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "opnum", ",", "int", "type", ",", "int", "ind_levels", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "REG", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", "==", "CONST_INT", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "{", "push_reload", "(", "XEXP", "(", "x", ",", "0", ")", ",", "NULL_RTX", ",", "&", "XEXP", "(", "x", ",", "0", ")", ",", "NULL", ",", "BASE_REG_CLASS", ",", "GET_MODE", "(", "x", ")", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "type", ")", ";", "return", "x", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "<", "FIRST_PSEUDO_REGISTER", "&&", "REGNO_OK_FOR_BASE_P", "(", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "{", "HOST_WIDE_INT", "val", "=", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ";", "HOST_WIDE_INT", "low", "=", "(", "(", "val", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "HOST_WIDE_INT", "high", "=", "(", "(", "(", "val", "-", "low", ")", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "if", "(", "high", "+", "low", "!=", "val", ")", "return", "NULL_RTX", ";", "x", "=", "gen_rtx_PLUS", "(", "GET_MODE", "(", "x", ")", ",", "gen_rtx_PLUS", "(", "GET_MODE", "(", "x", ")", ",", "XEXP", "(", "x", ",", "0", ")", ",", "GEN_INT", "(", "high", ")", ")", ",", "GEN_INT", "(", "low", ")", ")", ";", "push_reload", "(", "XEXP", "(", "x", ",", "0", ")", ",", "NULL_RTX", ",", "&", "XEXP", "(", "x", ",", "0", ")", ",", "NULL", ",", "BASE_REG_CLASS", ",", "GET_MODE", "(", "x", ")", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "type", ")", ";", "return", "x", ";", "}", "return", "NULL_RTX", ";", "}", "</s>"], "natrual_language": ["Try", "a", "machine-dependent", "way", "of", "reloading", "an", "illegitimate", "address", "operand", ".", "If", "we", "find", "one", ",", "push", "the", "reload", "and", "return", "the", "new", "rtx", "."], "TS_V_token": ["alpha", "0", "0", "0", "0", "1", "1", "0", "0", "0", "0", "0", "0", "0", "1", "1", "0xffff", "0x8000", "0x8000", "0xffffffff", "0x80000000", "0x80000000", "0", "0", "0", "0", "0"], "File": "alpha3", "Func": "alpha_legitimize_reload_address", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40590, "Length": 332}
{"ground_truth": ["<s>", "static", "const", "char", "*", "alpha_mangle_fundamental_type", "(", "tree", "type", ")", "{", "if", "(", "TYPE_MAIN_VARIANT", "(", "type", ")", "==", "long_double_type_node", "&&", "TARGET_LONG_DOUBLE_128", ")", "return", "\"g\"", ";", "return", "NULL", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_MANGLE_FUNDAMENTAL_TYPE", "."], "TS_V_token": ["alpha", "\"g\""], "File": "alpha3", "Func": "alpha_mangle_fundamental_type", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40591, "Length": 28}
{"ground_truth": ["<s>", "rtx", "alpha_need_linkage", "(", "const", "char", "*", "name", "ATTRIBUTE_UNUSED", ",", "int", "is_local", "ATTRIBUTE_UNUSED", ")", "{", "return", "NULL_RTX", ";", "}", "</s>"], "natrual_language": ["Make", "(", "or", "fake", ")", ".linkage", "entry", "for", "function", "call", ".", "IS_LOCAL", "is", "0", "if", "name", "is", "used", "in", "call", ",", "1", "if", "name", "is", "used", "in", "definition", ".", "Return", "an", "SYMBOL_REF", "rtx", "for", "the", "linkage", "."], "TS_V_token": ["alpha"], "File": "alpha3", "Func": "alpha_need_linkage", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40592, "Length": 18}
{"ground_truth": ["<s>", "void", "alpha_output_filename", "(", "FILE", "*", "stream", ",", "const", "char", "*", "name", ")", "{", "static", "int", "first_time", "=", "TRUE", ";", "if", "(", "first_time", ")", "{", "first_time", "=", "FALSE", ";", "++", "num_source_filenames", ";", "current_function_file", "=", "name", ";", "fprintf", "(", "stream", ",", "\"\\t.file\\t%d \"", ",", "num_source_filenames", ")", ";", "output_quoted_string", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\"\\n\"", ")", ";", "if", "(", "!", "TARGET_GAS", "&&", "write_symbols", "==", "DBX_DEBUG", ")", "fprintf", "(", "stream", ",", "\"\\t#@stabs\\n\"", ")", ";", "}", "else", "if", "(", "write_symbols", "==", "DBX_DEBUG", ")", "return", ";", "else", "if", "(", "name", "!=", "current_function_file", "&&", "strcmp", "(", "name", ",", "current_function_file", ")", "!=", "0", ")", "{", "if", "(", "inside_function", "&&", "!", "TARGET_GAS", ")", "fprintf", "(", "stream", ",", "\"\\t#.file\\t%d \"", ",", "num_source_filenames", ")", ";", "else", "{", "++", "num_source_filenames", ";", "current_function_file", "=", "name", ";", "fprintf", "(", "stream", ",", "\"\\t.file\\t%d \"", ",", "num_source_filenames", ")", ";", "}", "output_quoted_string", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\"\\n\"", ")", ";", "}", "}", "</s>"], "natrual_language": ["Emit", "a", "new", "filename", "to", "a", "stream", "."], "TS_V_token": ["alpha", "\"\\t.file\\t%d \"", "\"\\n\"", "\"\\t#@stabs\\n\"", "0", "\"\\t#.file\\t%d \"", "\"\\t.file\\t%d \"", "\"\\n\""], "File": "alpha3", "Func": "alpha_output_filename", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40593, "Length": 152}
{"ground_truth": ["<s>", "static", "void", "alpha_output_function_end_prologue", "(", "FILE", "*", "file", ")", "{", "if", "(", "TARGET_ABI_UNICOSMK", ")", ";", "else", "if", "(", "TARGET_ABI_OPEN_VMS", ")", "fputs", "(", "\"\\t.prologue\\n\"", ",", "file", ")", ";", "else", "if", "(", "TARGET_ABI_WINDOWS_NT", ")", "fputs", "(", "\"\\t.prologue 0\\n\"", ",", "file", ")", ";", "else", "if", "(", "!", "flag_inhibit_size_directive", ")", "fprintf", "(", "file", ",", "\"\\t.prologue %d\\n\"", ",", "alpha_function_needs_gp", "||", "current_function_is_thunk", ")", ";", "}", "</s>"], "natrual_language": ["Emit", "the", ".prologue", "note", "at", "the", "scheduled", "end", "of", "the", "prologue", "."], "TS_V_token": ["alpha", "\"\\t.prologue\\n\"", "\"\\t.prologue 0\\n\"", "\"\\t.prologue %d\\n\""], "File": "alpha3", "Func": "alpha_output_function_end_prologue", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40594, "Length": 56}
{"ground_truth": ["<s>", "static", "void", "alpha_output_mi_thunk_osf", "(", "FILE", "*", "file", ",", "tree", "thunk_fndecl", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "HOST_WIDE_INT", "hi", ",", "lo", ";", "rtx", "this", ",", "insn", ",", "funexp", ";", "reset_block_changes", "(", ")", ";", "emit_insn", "(", "gen_prologue_ldgp", "(", ")", ")", ";", "emit_note", "(", "NOTE_INSN_PROLOGUE_END", ")", ";", "if", "(", "aggregate_value_p", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "function", ")", ")", ",", "function", ")", ")", "this", "=", "gen_rtx_REG", "(", "Pmode", ",", "17", ")", ";", "else", "this", "=", "gen_rtx_REG", "(", "Pmode", ",", "16", ")", ";", "lo", "=", "(", "(", "delta", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "hi", "=", "(", "(", "(", "delta", "-", "lo", ")", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "if", "(", "hi", "+", "lo", "==", "delta", ")", "{", "if", "(", "hi", ")", "emit_insn", "(", "gen_adddi3", "(", "this", ",", "this", ",", "GEN_INT", "(", "hi", ")", ")", ")", ";", "if", "(", "lo", ")", "emit_insn", "(", "gen_adddi3", "(", "this", ",", "this", ",", "GEN_INT", "(", "lo", ")", ")", ")", ";", "}", "else", "{", "rtx", "tmp", "=", "alpha_emit_set_long_const", "(", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ",", "delta", ",", "-", "(", "delta", "<", "0", ")", ")", ";", "emit_insn", "(", "gen_adddi3", "(", "this", ",", "this", ",", "tmp", ")", ")", ";", "}", "if", "(", "vcall_offset", ")", "{", "rtx", "tmp", ",", "tmp2", ";", "tmp", "=", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ";", "emit_move_insn", "(", "tmp", ",", "gen_rtx_MEM", "(", "Pmode", ",", "this", ")", ")", ";", "lo", "=", "(", "(", "vcall_offset", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "hi", "=", "(", "(", "(", "vcall_offset", "-", "lo", ")", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "if", "(", "hi", "+", "lo", "==", "vcall_offset", ")", "{", "if", "(", "hi", ")", "emit_insn", "(", "gen_adddi3", "(", "tmp", ",", "tmp", ",", "GEN_INT", "(", "hi", ")", ")", ")", ";", "}", "else", "{", "tmp2", "=", "alpha_emit_set_long_const", "(", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ",", "vcall_offset", ",", "-", "(", "vcall_offset", "<", "0", ")", ")", ";", "emit_insn", "(", "gen_adddi3", "(", "tmp", ",", "tmp", ",", "tmp2", ")", ")", ";", "lo", "=", "0", ";", "}", "if", "(", "lo", ")", "tmp2", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "tmp", ",", "GEN_INT", "(", "lo", ")", ")", ";", "else", "tmp2", "=", "tmp", ";", "emit_move_insn", "(", "tmp", ",", "gen_rtx_MEM", "(", "Pmode", ",", "tmp2", ")", ")", ";", "emit_insn", "(", "gen_adddi3", "(", "this", ",", "this", ",", "tmp", ")", ")", ";", "}", "if", "(", "!", "TREE_USED", "(", "function", ")", ")", "{", "assemble_external", "(", "function", ")", ";", "TREE_USED", "(", "function", ")", "=", "1", ";", "}", "funexp", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ";", "funexp", "=", "gen_rtx_MEM", "(", "FUNCTION_MODE", ",", "funexp", ")", ";", "insn", "=", "emit_call_insn", "(", "gen_sibcall", "(", "funexp", ",", "const0_rtx", ")", ")", ";", "SIBLING_CALL_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "get_insns", "(", ")", ";", "insn_locators_initialize", "(", ")", ";", "shorten_branches", "(", "insn", ")", ";", "final_start_function", "(", "insn", ",", "file", ",", "1", ")", ";", "final", "(", "insn", ",", "file", ",", "1", ")", ";", "final_end_function", "(", ")", ";", "}", "</s>"], "natrual_language": ["Emit", "a", "tail", "call", "to", "FUNCTION", "after", "adjusting", "THIS", "by", "DELTA", ".", "In", "order", "to", "avoid", "the", "hordes", "of", "differences", "between", "generated", "code", "with", "and", "without", "TARGET_EXPLICIT_RELOCS", ",", "and", "to", "avoid", "duplicating", "lots", "of", "code", "loading", "up", "large", "constants", ",", "generate", "rtl", "and", "emit", "it", "instead", "of", "going", "straight", "to", "text", ".", "Not", "sure", "why", "this", "idea", "has", "n't", "been", "explored", "before", "..."], "TS_V_token": ["alpha", "17", "16", "0xffff", "0x8000", "0x8000", "0xffffffff", "0x80000000", "0x80000000", "0", "0", "0", "0xffff", "0x8000", "0x8000", "0xffffffff", "0x80000000", "0x80000000", "1", "0", "0", "1", "0", "1", "1", "1"], "File": "alpha3", "Func": "alpha_output_mi_thunk_osf", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40595, "Length": 481}
{"ground_truth": ["<s>", "enum", "reg_class", "alpha_preferred_reload_class", "(", "rtx", "x", ",", "enum", "reg_class", "class", ")", "{", "if", "(", "x", "==", "CONST0_RTX", "(", "GET_MODE", "(", "x", ")", ")", ")", "return", "class", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", "||", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", "||", "GET_CODE", "(", "x", ")", "==", "CONST_VECTOR", ")", "{", "if", "(", "class", "==", "FLOAT_REGS", ")", "return", "NO_REGS", ";", "if", "(", "class", "==", "ALL_REGS", ")", "return", "GENERAL_REGS", ";", "return", "class", ";", "}", "if", "(", "CONSTANT_P", "(", "x", ")", ")", "return", "(", "class", "==", "ALL_REGS", "?", "GENERAL_REGS", ":", "class", ")", ";", "return", "class", ";", "}", "</s>"], "natrual_language": ["On", "the", "Alpha", ",", "all", "(", "non-symbolic", ")", "constants", "except", "zero", "go", "into", "a", "floating-point", "register", "via", "memory", ".", "Note", "that", "we", "can", "not", "return", "anything", "that", "is", "not", "a", "subset", "of", "CLASS", ",", "and", "that", "some", "symbolic", "constants", "can", "not", "be", "dropped", "to", "memory", "."], "TS_V_token": ["alpha"], "File": "alpha3", "Func": "alpha_preferred_reload_class", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40596, "Length": 95}
{"ground_truth": ["<s>", "static", "void", "alpha_reorg", "(", "void", ")", "{", "if", "(", "alpha_tp", "!=", "ALPHA_TP_PROG", "||", "flag_exceptions", ")", "alpha_handle_trap_shadows", "(", ")", ";", "if", "(", "optimize", "&&", "!", "optimize_size", "&&", "alpha_tp", "!=", "ALPHA_TP_INSN", "&&", "flag_schedule_insns_after_reload", ")", "{", "if", "(", "alpha_tune", "==", "PROCESSOR_EV4", ")", "alpha_align_insns", "(", "8", ",", "alphaev4_next_group", ",", "alphaev4_next_nop", ")", ";", "else", "if", "(", "alpha_tune", "==", "PROCESSOR_EV5", ")", "alpha_align_insns", "(", "16", ",", "alphaev5_next_group", ",", "alphaev5_next_nop", ")", ";", "}", "}", "</s>"], "natrual_language": ["Machine", "dependent", "reorg", "pass", "."], "TS_V_token": ["alpha", "8", "16"], "File": "alpha3", "Func": "alpha_reorg", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40597, "Length": 66}
{"ground_truth": ["<s>", "static", "bool", "alpha_return_in_memory", "(", "tree", "type", ",", "tree", "fndecl", "ATTRIBUTE_UNUSED", ")", "{", "enum", "machine_mode", "mode", "=", "VOIDmode", ";", "int", "size", ";", "if", "(", "type", ")", "{", "mode", "=", "TYPE_MODE", "(", "type", ")", ";", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "return", "true", ";", "}", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "switch", "(", "GET_MODE_CLASS", "(", "mode", ")", ")", "{", "case", "MODE_VECTOR_FLOAT", ":", "return", "true", ";", "case", "MODE_COMPLEX_FLOAT", ":", "size", "=", "GET_MODE_UNIT_SIZE", "(", "mode", ")", ";", "break", ";", "case", "MODE_INT", ":", "case", "MODE_FLOAT", ":", "case", "MODE_COMPLEX_INT", ":", "case", "MODE_VECTOR_INT", ":", "break", ";", "default", ":", "return", "true", ";", "}", "return", "size", ">", "UNITS_PER_WORD", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "TYPE", "must", "be", "returned", "in", "memory", ",", "instead", "of", "in", "registers", "."], "TS_V_token": ["alpha"], "File": "alpha3", "Func": "alpha_return_in_memory", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40598, "Length": 103}
{"ground_truth": ["<s>", "static", "void", "alpha_sa_mask", "(", "unsigned", "long", "*", "imaskP", ",", "unsigned", "long", "*", "fmaskP", ")", "{", "unsigned", "long", "imask", "=", "0", ";", "unsigned", "long", "fmask", "=", "0", ";", "unsigned", "int", "i", ";", "if", "(", "current_function_is_thunk", ")", "{", "*", "imaskP", "=", "0", ";", "*", "fmaskP", "=", "0", ";", "return", ";", "}", "if", "(", "TARGET_ABI_OPEN_VMS", "&&", "alpha_procedure_type", "==", "PT_STACK", ")", "imask", "|=", "(", "1UL", "<<", "HARD_FRAME_POINTER_REGNUM", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "if", "(", "!", "fixed_regs", "[", "i", "]", "&&", "!", "call_used_regs", "[", "i", "]", "&&", "regs_ever_live", "[", "i", "]", "&&", "i", "!=", "REG_RA", "&&", "(", "!", "TARGET_ABI_UNICOSMK", "||", "i", "!=", "HARD_FRAME_POINTER_REGNUM", ")", ")", "{", "if", "(", "i", "<", "32", ")", "imask", "|=", "(", "1UL", "<<", "i", ")", ";", "else", "fmask", "|=", "(", "1UL", "<<", "(", "i", "-", "32", ")", ")", ";", "}", "if", "(", "current_function_calls_eh_return", ")", "{", "for", "(", "i", "=", "0", ";", ";", "++", "i", ")", "{", "unsigned", "regno", "=", "EH_RETURN_DATA_REGNO", "(", "i", ")", ";", "if", "(", "regno", "==", "INVALID_REGNUM", ")", "break", ";", "imask", "|=", "1UL", "<<", "regno", ";", "}", "}", "if", "(", "imask", "||", "fmask", "||", "alpha_ra_ever_killed", "(", ")", ")", "imask", "|=", "(", "1UL", "<<", "REG_RA", ")", ";", "*", "imaskP", "=", "imask", ";", "*", "fmaskP", "=", "fmask", ";", "}", "</s>"], "natrual_language": ["Compute", "register", "masks", "for", "saved", "registers", "."], "TS_V_token": ["alpha", "0", "0", "0", "0", "1UL", "0", "32", "1UL", "1UL", "32", "0", "1UL", "1UL"], "File": "alpha3", "Func": "alpha_sa_mask", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40599, "Length": 208}
{"ground_truth": ["<s>", "static", "bool", "alpha_scalar_mode_supported_p", "(", "enum", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "case", "HImode", ":", "case", "SImode", ":", "case", "DImode", ":", "case", "TImode", ":", "return", "true", ";", "case", "SFmode", ":", "case", "DFmode", ":", "return", "true", ";", "case", "TFmode", ":", "return", "TARGET_HAS_XFLOATING_LIBS", ";", "default", ":", "return", "false", ";", "}", "}", "</s>"], "natrual_language": ["The", "scalar", "modes", "supported", "differs", "from", "the", "default", "check-what-c-supports", "version", "in", "that", "sometimes", "TFmode", "is", "available", "even", "when", "long", "double", "indicates", "only", "DFmode", ".", "On", "unicosmk", ",", "we", "have", "the", "situation", "that", "HImode", "does", "n't", "map", "to", "any", "C", "type", ",", "but", "of", "course", "we", "still", "support", "that", "."], "TS_V_token": ["alpha"], "File": "alpha3", "Func": "alpha_scalar_mode_supported_p", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40600, "Length": 54}
{"ground_truth": ["<s>", "static", "void", "alpha_setup_incoming_varargs", "(", "CUMULATIVE_ARGS", "*", "pcum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "*", "pretend_size", ",", "int", "no_rtl", ")", "{", "CUMULATIVE_ARGS", "cum", "=", "*", "pcum", ";", "FUNCTION_ARG_ADVANCE", "(", "cum", ",", "mode", ",", "type", ",", "1", ")", ";", "if", "(", "cum", ".", "num_reg_words", "<", "6", ")", "{", "if", "(", "!", "no_rtl", ")", "{", "emit_insn", "(", "gen_umk_mismatch_args", "(", "GEN_INT", "(", "cum", ".", "num_reg_words", ")", ")", ")", ";", "emit_insn", "(", "gen_arg_home_umk", "(", ")", ")", ";", "}", "*", "pretend_size", "=", "0", ";", "}", "if", "(", "cum", ".", "num_args", "<", "6", ")", "{", "if", "(", "!", "no_rtl", ")", "{", "emit_move_insn", "(", "gen_rtx_REG", "(", "DImode", ",", "1", ")", ",", "virtual_incoming_args_rtx", ")", ";", "emit_insn", "(", "gen_arg_home", "(", ")", ")", ";", "}", "*", "pretend_size", "=", "7", "*", "UNITS_PER_WORD", ";", "}", "if", "(", "cum", ">=", "6", ")", "return", ";", "if", "(", "!", "no_rtl", ")", "{", "int", "count", ",", "set", "=", "get_varargs_alias_set", "(", ")", ";", "rtx", "tmp", ";", "count", "=", "cfun", "->", "va_list_gpr_size", "/", "UNITS_PER_WORD", ";", "if", "(", "count", ">", "6", "-", "cum", ")", "count", "=", "6", "-", "cum", ";", "gcc_assert", "(", "(", "VA_LIST_MAX_FPR_SIZE", "&", "3", ")", "==", "3", ")", ";", "if", "(", "cfun", "->", "va_list_fpr_size", "&", "1", ")", "{", "tmp", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "plus_constant", "(", "virtual_incoming_args_rtx", ",", "(", "cum", "+", "6", ")", "*", "UNITS_PER_WORD", ")", ")", ";", "MEM_NOTRAP_P", "(", "tmp", ")", "=", "1", ";", "set_mem_alias_set", "(", "tmp", ",", "set", ")", ";", "move_block_from_reg", "(", "16", "+", "cum", ",", "tmp", ",", "count", ")", ";", "}", "if", "(", "cfun", "->", "va_list_fpr_size", "&", "2", ")", "{", "tmp", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "plus_constant", "(", "virtual_incoming_args_rtx", ",", "cum", "*", "UNITS_PER_WORD", ")", ")", ";", "MEM_NOTRAP_P", "(", "tmp", ")", "=", "1", ";", "set_mem_alias_set", "(", "tmp", ",", "set", ")", ";", "move_block_from_reg", "(", "16", "+", "cum", "+", "TARGET_FPREGS", "*", "32", ",", "tmp", ",", "count", ")", ";", "}", "}", "*", "pretend_size", "=", "12", "*", "UNITS_PER_WORD", ";", "}", "</s>"], "natrual_language": ["Perform", "any", "needed", "actions", "needed", "for", "a", "function", "that", "is", "receiving", "a", "variable", "number", "of", "arguments", "."], "TS_V_token": ["alpha", "1", "6", "0", "6", "1", "7", "6", "6", "6", "3", "3", "1", "6", "1", "16", "2", "1", "16", "32", "12"], "File": "alpha3", "Func": "alpha_setup_incoming_varargs", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40601, "Length": 303}
{"ground_truth": ["<s>", "void", "alpha_set_memflags", "(", "rtx", "insn", ",", "rtx", "ref", ")", "{", "rtx", "*", "base_ptr", ";", "if", "(", "GET_CODE", "(", "ref", ")", "!=", "MEM", ")", "return", ";", "if", "(", "!", "MEM_VOLATILE_P", "(", "ref", ")", "&&", "!", "MEM_IN_STRUCT_P", "(", "ref", ")", "&&", "!", "MEM_SCALAR_P", "(", "ref", ")", "&&", "!", "MEM_NOTRAP_P", "(", "ref", ")", "&&", "!", "MEM_READONLY_P", "(", "ref", ")", ")", "return", ";", "if", "(", "INSN_P", "(", "insn", ")", ")", "base_ptr", "=", "&", "PATTERN", "(", "insn", ")", ";", "else", "base_ptr", "=", "&", "insn", ";", "for_each_rtx", "(", "base_ptr", ",", "alpha_set_memflags_1", ",", "(", "void", "*", ")", "ref", ")", ";", "}", "</s>"], "natrual_language": ["Given", "INSN", ",", "which", "is", "an", "INSN", "list", "or", "the", "PATTERN", "of", "a", "single", "insn", "generated", "to", "perform", "a", "memory", "operation", ",", "look", "for", "any", "MEMs", "in", "either", "a", "SET_DEST", "or", "a", "SET_SRC", "and", "copy", "the", "in-struct", ",", "unchanging", ",", "and", "volatile", "flags", "from", "REF", "into", "each", "of", "the", "MEMs", "found", ".", "If", "REF", "is", "not", "a", "MEM", ",", "do", "n't", "do", "anything", "."], "TS_V_token": ["alpha"], "File": "alpha3", "Func": "alpha_set_memflags", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40602, "Length": 94}
{"ground_truth": ["<s>", "static", "int", "alpha_set_memflags_1", "(", "rtx", "*", "xp", ",", "void", "*", "data", ")", "{", "rtx", "x", "=", "*", "xp", ",", "orig", "=", "(", "rtx", ")", "data", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "MEM", ")", "return", "0", ";", "MEM_VOLATILE_P", "(", "x", ")", "=", "MEM_VOLATILE_P", "(", "orig", ")", ";", "MEM_IN_STRUCT_P", "(", "x", ")", "=", "MEM_IN_STRUCT_P", "(", "orig", ")", ";", "MEM_SCALAR_P", "(", "x", ")", "=", "MEM_SCALAR_P", "(", "orig", ")", ";", "MEM_NOTRAP_P", "(", "x", ")", "=", "MEM_NOTRAP_P", "(", "orig", ")", ";", "MEM_READONLY_P", "(", "x", ")", "=", "MEM_READONLY_P", "(", "orig", ")", ";", "return", "-", "1", ";", "}", "</s>"], "natrual_language": ["Subfunction", "of", "the", "following", "function", ".", "Update", "the", "flags", "of", "any", "MEM", "found", "in", "part", "of", "X", "."], "TS_V_token": ["alpha", "0", "1"], "File": "alpha3", "Func": "alpha_set_memflags_1", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40603, "Length": 93}
{"ground_truth": ["<s>", "void", "alpha_split_atomic_op", "(", "enum", "rtx_code", "code", ",", "rtx", "mem", ",", "rtx", "val", ",", "rtx", "before", ",", "rtx", "after", ",", "rtx", "scratch", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "rtx", "label", ",", "x", ",", "cond", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "scratch", ")", ")", ";", "emit_insn", "(", "gen_memory_barrier", "(", ")", ")", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label", ")", ";", "label", "=", "gen_rtx_LABEL_REF", "(", "DImode", ",", "label", ")", ";", "if", "(", "before", "==", "NULL", ")", "before", "=", "scratch", ";", "emit_load_locked", "(", "mode", ",", "before", ",", "mem", ")", ";", "if", "(", "code", "==", "NOT", ")", "x", "=", "gen_rtx_AND", "(", "mode", ",", "gen_rtx_NOT", "(", "mode", ",", "before", ")", ",", "val", ")", ";", "else", "x", "=", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "before", ",", "val", ")", ";", "if", "(", "after", ")", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "after", ",", "copy_rtx", "(", "x", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "scratch", ",", "x", ")", ")", ";", "emit_store_conditional", "(", "mode", ",", "cond", ",", "mem", ",", "scratch", ")", ";", "x", "=", "gen_rtx_EQ", "(", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_unlikely_jump", "(", "x", ",", "label", ")", ";", "emit_insn", "(", "gen_memory_barrier", "(", ")", ")", ";", "}", "</s>"], "natrual_language": ["Expand", "an", "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", ".", "SCRATCH", "is", "a", "scratch", "register", "."], "TS_V_token": ["alpha"], "File": "alpha3", "Func": "alpha_split_atomic_op", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40604, "Length": 199}
{"ground_truth": ["<s>", "void", "alpha_split_compare_and_swap", "(", "rtx", "retval", ",", "rtx", "mem", ",", "rtx", "oldval", ",", "rtx", "newval", ",", "rtx", "scratch", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "rtx", "label1", ",", "label2", ",", "x", ",", "cond", "=", "gen_lowpart", "(", "DImode", ",", "scratch", ")", ";", "emit_insn", "(", "gen_memory_barrier", "(", ")", ")", ";", "label1", "=", "gen_rtx_LABEL_REF", "(", "DImode", ",", "gen_label_rtx", "(", ")", ")", ";", "label2", "=", "gen_rtx_LABEL_REF", "(", "DImode", ",", "gen_label_rtx", "(", ")", ")", ";", "emit_label", "(", "XEXP", "(", "label1", ",", "0", ")", ")", ";", "emit_load_locked", "(", "mode", ",", "retval", ",", "mem", ")", ";", "x", "=", "gen_lowpart", "(", "DImode", ",", "retval", ")", ";", "if", "(", "oldval", "==", "const0_rtx", ")", "x", "=", "gen_rtx_NE", "(", "DImode", ",", "x", ",", "const0_rtx", ")", ";", "else", "{", "x", "=", "gen_rtx_EQ", "(", "DImode", ",", "x", ",", "oldval", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "cond", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_EQ", "(", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "}", "emit_unlikely_jump", "(", "x", ",", "label2", ")", ";", "emit_move_insn", "(", "scratch", ",", "newval", ")", ";", "emit_store_conditional", "(", "mode", ",", "cond", ",", "mem", ",", "scratch", ")", ";", "x", "=", "gen_rtx_EQ", "(", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_unlikely_jump", "(", "x", ",", "label1", ")", ";", "emit_insn", "(", "gen_memory_barrier", "(", ")", ")", ";", "emit_label", "(", "XEXP", "(", "label2", ",", "0", ")", ")", ";", "}", "</s>"], "natrual_language": ["Expand", "a", "compare", "and", "swap", "operation", "."], "TS_V_token": ["alpha", "0", "0"], "File": "alpha3", "Func": "alpha_split_compare_and_swap", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40605, "Length": 216}
{"ground_truth": ["<s>", "static", "bool", "alpha_split_complex_arg", "(", "tree", "type", ")", "{", "return", "TYPE_MODE", "(", "type", ")", "!=", "TCmode", ";", "}", "</s>"], "natrual_language": ["TCmode", "complex", "values", "are", "passed", "by", "invisible", "reference", ".", "We", "should", "not", "split", "these", "values", "."], "TS_V_token": ["alpha"], "File": "alpha3", "Func": "alpha_split_complex_arg", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40606, "Length": 17}
{"ground_truth": ["<s>", "int", "alpha_split_conditional_move", "(", "enum", "rtx_code", "code", ",", "rtx", "dest", ",", "rtx", "cond", ",", "rtx", "t_rtx", ",", "rtx", "f_rtx", ")", "{", "HOST_WIDE_INT", "t", ",", "f", ",", "diff", ";", "enum", "machine_mode", "mode", ";", "rtx", "target", ",", "subtarget", ",", "tmp", ";", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "t", "=", "INTVAL", "(", "t_rtx", ")", ";", "f", "=", "INTVAL", "(", "f_rtx", ")", ";", "diff", "=", "t", "-", "f", ";", "if", "(", "(", "(", "code", "==", "NE", "||", "code", "==", "EQ", ")", "&&", "diff", "<", "0", ")", "||", "(", "code", "==", "GE", "||", "code", "==", "GT", ")", ")", "{", "code", "=", "reverse_condition", "(", "code", ")", ";", "diff", "=", "t", ",", "t", "=", "f", ",", "f", "=", "diff", ";", "diff", "=", "t", "-", "f", ";", "}", "subtarget", "=", "target", "=", "dest", ";", "if", "(", "mode", "!=", "DImode", ")", "{", "target", "=", "gen_lowpart", "(", "DImode", ",", "dest", ")", ";", "if", "(", "!", "no_new_pseudos", ")", "subtarget", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "else", "subtarget", "=", "target", ";", "}", "if", "(", "f", "==", "0", "&&", "exact_log2", "(", "diff", ")", ">", "0", "&&", "(", "diff", "<=", "8", "||", "alpha_tune", "==", "PROCESSOR_EV6", ")", ")", "{", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "copy_rtx", "(", "subtarget", ")", ",", "tmp", ")", ")", ";", "tmp", "=", "gen_rtx_ASHIFT", "(", "DImode", ",", "copy_rtx", "(", "subtarget", ")", ",", "GEN_INT", "(", "exact_log2", "(", "t", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "target", ",", "tmp", ")", ")", ";", "}", "else", "if", "(", "f", "==", "0", "&&", "t", "==", "-", "1", ")", "{", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "copy_rtx", "(", "subtarget", ")", ",", "tmp", ")", ")", ";", "emit_insn", "(", "gen_negdi2", "(", "target", ",", "copy_rtx", "(", "subtarget", ")", ")", ")", ";", "}", "else", "if", "(", "diff", "==", "1", "||", "diff", "==", "4", "||", "diff", "==", "8", ")", "{", "rtx", "add_op", ";", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "copy_rtx", "(", "subtarget", ")", ",", "tmp", ")", ")", ";", "if", "(", "diff", "==", "1", ")", "emit_insn", "(", "gen_adddi3", "(", "target", ",", "copy_rtx", "(", "subtarget", ")", ",", "GEN_INT", "(", "f", ")", ")", ")", ";", "else", "{", "add_op", "=", "GEN_INT", "(", "f", ")", ";", "if", "(", "sext_add_operand", "(", "add_op", ",", "mode", ")", ")", "{", "tmp", "=", "gen_rtx_MULT", "(", "DImode", ",", "copy_rtx", "(", "subtarget", ")", ",", "GEN_INT", "(", "diff", ")", ")", ";", "tmp", "=", "gen_rtx_PLUS", "(", "DImode", ",", "tmp", ",", "add_op", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "target", ",", "tmp", ")", ")", ";", "}", "else", "return", "0", ";", "}", "}", "else", "return", "0", ";", "return", "1", ";", "}", "</s>"], "natrual_language": ["Simplify", "a", "conditional", "move", "of", "two", "constants", "into", "a", "setcc", "with", "arithmetic", ".", "This", "is", "done", "with", "a", "splitter", "since", "combine", "would", "just", "undo", "the", "work", "if", "done", "during", "code", "generation", ".", "It", "also", "catches", "cases", "we", "would", "n't", "have", "before", "cse", "."], "TS_V_token": ["alpha", "0", "0", "0", "8", "0", "1", "1", "4", "8", "1", "0", "0", "1"], "File": "alpha3", "Func": "alpha_split_conditional_move", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40607, "Length": 445}
{"ground_truth": ["<s>", "bool", "alpha_split_const_mov", "(", "enum", "machine_mode", "mode", ",", "rtx", "*", "operands", ")", "{", "HOST_WIDE_INT", "i0", ",", "i1", ";", "rtx", "temp", "=", "NULL_RTX", ";", "alpha_extract_integer", "(", "operands", "[", "1", "]", ",", "&", "i0", ",", "&", "i1", ")", ";", "if", "(", "HOST_BITS_PER_WIDE_INT", ">=", "64", "||", "i1", "==", "-", "(", "i0", "<", "0", ")", ")", "temp", "=", "alpha_emit_set_const", "(", "operands", "[", "0", "]", ",", "mode", ",", "i0", ",", "3", ",", "false", ")", ";", "if", "(", "!", "temp", "&&", "TARGET_BUILD_CONSTANTS", ")", "temp", "=", "alpha_emit_set_long_const", "(", "operands", "[", "0", "]", ",", "i0", ",", "i1", ")", ";", "if", "(", "temp", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "operands", "[", "0", "]", ",", "temp", ")", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "temp", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Operand", "1", "is", "known", "to", "be", "a", "constant", ",", "and", "should", "require", "more", "than", "one", "instruction", "to", "load", ".", "Emit", "that", "multi-part", "load", "."], "TS_V_token": ["alpha", "1", "64", "0", "0", "3", "0", "0", "0"], "File": "alpha3", "Func": "alpha_split_const_mov", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40608, "Length": 126}
{"ground_truth": ["<s>", "void", "alpha_split_lock_test_and_set", "(", "rtx", "retval", ",", "rtx", "mem", ",", "rtx", "val", ",", "rtx", "scratch", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "rtx", "label", ",", "x", ",", "cond", "=", "gen_lowpart", "(", "DImode", ",", "scratch", ")", ";", "emit_insn", "(", "gen_memory_barrier", "(", ")", ")", ";", "label", "=", "gen_rtx_LABEL_REF", "(", "DImode", ",", "gen_label_rtx", "(", ")", ")", ";", "emit_label", "(", "XEXP", "(", "label", ",", "0", ")", ")", ";", "emit_load_locked", "(", "mode", ",", "retval", ",", "mem", ")", ";", "emit_move_insn", "(", "scratch", ",", "val", ")", ";", "emit_store_conditional", "(", "mode", ",", "cond", ",", "mem", ",", "scratch", ")", ";", "x", "=", "gen_rtx_EQ", "(", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_unlikely_jump", "(", "x", ",", "label", ")", ";", "}", "</s>"], "natrual_language": ["Expand", "an", "atomic", "exchange", "operation", "."], "TS_V_token": ["alpha", "0"], "File": "alpha3", "Func": "alpha_split_lock_test_and_set", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40609, "Length": 113}
{"ground_truth": ["<s>", "void", "alpha_split_tfmode_frobsign", "(", "rtx", "operands", "[", "3", "]", ",", "rtx", "(", "*", "operation", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ")", "{", "rtx", "high_bit", "=", "operands", "[", "2", "]", ";", "rtx", "scratch", ";", "int", "move", ";", "alpha_split_tfmode_pair", "(", "operands", ")", ";", "move", "=", "1", ";", "if", "(", "rtx_equal_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ")", ")", "move", "=", "0", ";", "else", "if", "(", "rtx_equal_p", "(", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ")", "{", "if", "(", "rtx_equal_p", "(", "operands", "[", "0", "]", ",", "high_bit", ")", ")", "move", "=", "2", ";", "else", "move", "=", "-", "1", ";", "}", "if", "(", "move", "<", "0", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ")", ";", "scratch", "=", "operands", "[", "move", "<", "2", "?", "1", ":", "3", "]", ";", "emit_insn", "(", "(", "*", "operation", ")", "(", "scratch", ",", "high_bit", ",", "operands", "[", "3", "]", ")", ")", ";", "if", "(", "move", ">", "0", ")", "{", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ")", ";", "if", "(", "move", ">", "1", ")", "emit_move_insn", "(", "operands", "[", "1", "]", ",", "scratch", ")", ";", "}", "}", "</s>"], "natrual_language": ["Implement", "negtf2", "or", "abstf2", ".", "Op0", "is", "destination", ",", "op1", "is", "source", ",", "op2", "is", "a", "register", "containing", "the", "sign", "bit", ",", "operation", "is", "the", "logical", "operation", "to", "be", "performed", "."], "TS_V_token": ["alpha", "3", "2", "1", "0", "2", "0", "1", "2", "0", "2", "1", "0", "0", "2", "2", "1", "3", "3", "0", "0", "2", "1", "1"], "File": "alpha3", "Func": "alpha_split_tfmode_frobsign", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40610, "Length": 193}
{"ground_truth": ["<s>", "void", "alpha_split_tfmode_pair", "(", "rtx", "operands", "[", "4", "]", ")", "{", "switch", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", ")", "{", "case", "REG", ":", "operands", "[", "3", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "operands", "[", "1", "]", ")", "+", "1", ")", ";", "operands", "[", "2", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "operands", "[", "1", "]", ")", ")", ";", "break", ";", "case", "MEM", ":", "operands", "[", "3", "]", "=", "adjust_address", "(", "operands", "[", "1", "]", ",", "DImode", ",", "8", ")", ";", "operands", "[", "2", "]", "=", "adjust_address", "(", "operands", "[", "1", "]", ",", "DImode", ",", "0", ")", ";", "break", ";", "case", "CONST_DOUBLE", ":", "gcc_assert", "(", "operands", "[", "1", "]", "==", "CONST0_RTX", "(", "TFmode", ")", ")", ";", "operands", "[", "2", "]", "=", "operands", "[", "3", "]", "=", "const0_rtx", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", ")", "{", "case", "REG", ":", "operands", "[", "1", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "operands", "[", "0", "]", ")", "+", "1", ")", ";", "operands", "[", "0", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "operands", "[", "0", "]", ")", ")", ";", "break", ";", "case", "MEM", ":", "operands", "[", "1", "]", "=", "adjust_address", "(", "operands", "[", "0", "]", ",", "DImode", ",", "8", ")", ";", "operands", "[", "0", "]", "=", "adjust_address", "(", "operands", "[", "0", "]", ",", "DImode", ",", "0", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Split", "a", "TFmode", "OP", "[", "1", "]", "into", "DImode", "OP", "[", "2,3", "]", "and", "likewise", "for", "OP", "[", "0", "]", "into", "OP", "[", "0,1", "]", ".", "Naturally", ",", "output", "operand", "ordering", "is", "little-endian", "."], "TS_V_token": ["alpha", "4", "1", "3", "1", "1", "2", "1", "3", "1", "8", "2", "1", "0", "1", "2", "3", "0", "1", "0", "1", "0", "0", "1", "0", "8", "0", "0", "0"], "File": "alpha3", "Func": "alpha_split_tfmode_pair", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40611, "Length": 241}
{"ground_truth": ["<s>", "rtx", "alpha_tablejump_addr_vec", "(", "rtx", "insn", ")", "{", "rtx", "tmp", ";", "tmp", "=", "JUMP_LABEL", "(", "insn", ")", ";", "if", "(", "!", "tmp", ")", "return", "NULL_RTX", ";", "tmp", "=", "NEXT_INSN", "(", "tmp", ")", ";", "if", "(", "!", "tmp", ")", "return", "NULL_RTX", ";", "if", "(", "GET_CODE", "(", "tmp", ")", "==", "JUMP_INSN", "&&", "GET_CODE", "(", "PATTERN", "(", "tmp", ")", ")", "==", "ADDR_DIFF_VEC", ")", "return", "PATTERN", "(", "tmp", ")", ";", "return", "NULL_RTX", ";", "}", "</s>"], "natrual_language": ["Return", "the", "ADDR_VEC", "associated", "with", "a", "tablejump", "insn", "."], "TS_V_token": ["alpha"], "File": "alpha3", "Func": "alpha_tablejump_addr_vec", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40612, "Length": 69}
{"ground_truth": ["<s>", "rtx", "alpha_tablejump_best_label", "(", "rtx", "insn", ")", "{", "rtx", "jump_table", "=", "alpha_tablejump_addr_vec", "(", "insn", ")", ";", "rtx", "best_label", "=", "NULL_RTX", ";", "if", "(", "jump_table", ")", "{", "int", "n_labels", "=", "XVECLEN", "(", "jump_table", ",", "1", ")", ";", "int", "best_count", "=", "-", "1", ";", "int", "i", ",", "j", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_labels", ";", "i", "++", ")", "{", "int", "count", "=", "1", ";", "for", "(", "j", "=", "i", "+", "1", ";", "j", "<", "n_labels", ";", "j", "++", ")", "if", "(", "XEXP", "(", "XVECEXP", "(", "jump_table", ",", "1", ",", "i", ")", ",", "0", ")", "==", "XEXP", "(", "XVECEXP", "(", "jump_table", ",", "1", ",", "j", ")", ",", "0", ")", ")", "count", "++", ";", "if", "(", "count", ">", "best_count", ")", "best_count", "=", "count", ",", "best_label", "=", "XVECEXP", "(", "jump_table", ",", "1", ",", "i", ")", ";", "}", "}", "return", "best_label", "?", "best_label", ":", "const0_rtx", ";", "}", "</s>"], "natrual_language": ["Return", "the", "label", "of", "the", "predicted", "edge", ",", "or", "CONST0_RTX", "if", "we", "do", "n't", "know", "."], "TS_V_token": ["alpha", "1", "1", "0", "1", "1", "1", "0", "1", "0", "1"], "File": "alpha3", "Func": "alpha_tablejump_best_label", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40613, "Length": 144}
{"ground_truth": ["<s>", "rtx", "alpha_use_linkage", "(", "rtx", "linkage", "ATTRIBUTE_UNUSED", ",", "tree", "cfundecl", "ATTRIBUTE_UNUSED", ",", "int", "lflag", "ATTRIBUTE_UNUSED", ",", "int", "rflag", "ATTRIBUTE_UNUSED", ")", "{", "return", "NULL_RTX", ";", "}", "</s>"], "natrual_language": ["Return", "a", "SYMBOL_REF", "representing", "the", "reference", "to", "the", ".linkage", "entry", "of", "function", "FUNC", "built", "for", "calls", "made", "from", "CFUNDECL", ".", "LFLAG", "is", "1", "if", "this", "is", "the", "reference", "to", "the", "linkage", "pointer", "value", ",", "0", "if", "this", "is", "the", "reference", "to", "the", "function", "entry", "value", ".", "RFLAG", "is", "1", "if", "this", "a", "reduced", "reference", "(", "code", "address", "only", ")", ",", "0", "if", "this", "is", "a", "full", "reference", "."], "TS_V_token": ["alpha"], "File": "alpha3", "Func": "alpha_use_linkage", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40614, "Length": 24}
{"ground_truth": ["<s>", "static", "bool", "alpha_vector_mode_supported_p", "(", "enum", "machine_mode", "mode", ")", "{", "return", "mode", "==", "V8QImode", "||", "mode", "==", "V4HImode", "||", "mode", "==", "V2SImode", ";", "}", "</s>"], "natrual_language": ["Alpha", "implements", "a", "couple", "of", "integer", "vector", "mode", "operations", "when", "TARGET_MAX", "is", "enabled", ".", "We", "do", "not", "check", "TARGET_MAX", "here", ",", "however", ",", "which", "allows", "the", "vectorizer", "to", "operate", "on", "e.g", ".", "move", "instructions", ",", "or", "when", "expand_vector_operations", "can", "do", "something", "useful", "."], "TS_V_token": ["alpha"], "File": "alpha3", "Func": "alpha_vector_mode_supported_p", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40615, "Length": 23}
{"ground_truth": ["<s>", "static", "bool", "decl_has_samegp", "(", "tree", "decl", ")", "{", "if", "(", "!", "(", "*", "targetm", ".", "binds_local_p", ")", "(", "decl", ")", ")", "return", "false", ";", "if", "(", "TARGET_EXPLICIT_RELOCS", "&&", "TARGET_SMALL_DATA", ")", "return", "true", ";", "return", "!", "TREE_PUBLIC", "(", "decl", ")", "||", "!", "DECL_EXTERNAL", "(", "decl", ")", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "the", "function", "DECL", "will", "share", "the", "same", "GP", "as", "any", "function", "in", "the", "current", "unit", "of", "translation", "."], "TS_V_token": ["alpha"], "File": "alpha3", "Func": "decl_has_samegp", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40616, "Length": 47}
{"ground_truth": ["<s>", "int", "direct_return", "(", "void", ")", "{", "return", "(", "!", "TARGET_ABI_OPEN_VMS", "&&", "!", "TARGET_ABI_UNICOSMK", "&&", "reload_completed", "&&", "alpha_sa_size", "(", ")", "==", "0", "&&", "get_frame_size", "(", ")", "==", "0", "&&", "current_function_outgoing_args_size", "==", "0", "&&", "current_function_pretend_args_size", "==", "0", ")", ";", "}", "</s>"], "natrual_language": ["Return", "non-zero", "if", "this", "function", "is", "known", "to", "have", "a", "null", "epilogue", "."], "TS_V_token": ["alpha", "0", "0", "0", "0"], "File": "alpha3", "Func": "direct_return", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40617, "Length": 38}
{"ground_truth": ["<s>", "static", "void", "emit_frame_store_1", "(", "rtx", "value", ",", "rtx", "base_reg", ",", "HOST_WIDE_INT", "frame_bias", ",", "HOST_WIDE_INT", "base_ofs", ",", "rtx", "frame_reg", ")", "{", "rtx", "addr", ",", "mem", ",", "insn", ";", "addr", "=", "plus_constant", "(", "base_reg", ",", "base_ofs", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "DImode", ",", "addr", ")", ";", "set_mem_alias_set", "(", "mem", ",", "alpha_sr_alias_set", ")", ";", "insn", "=", "emit_move_insn", "(", "mem", ",", "value", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "if", "(", "frame_bias", "||", "value", "!=", "frame_reg", ")", "{", "if", "(", "frame_bias", ")", "{", "addr", "=", "plus_constant", "(", "stack_pointer_rtx", ",", "frame_bias", "+", "base_ofs", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "DImode", ",", "addr", ")", ";", "}", "REG_NOTES", "(", "insn", ")", "=", "gen_rtx_EXPR_LIST", "(", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "mem", ",", "frame_reg", ")", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "}", "}", "</s>"], "natrual_language": ["Generates", "a", "store", "with", "the", "proper", "unwind", "info", "attached", ".", "VALUE", "is", "stored", "at", "BASE_REG+BASE_OFS", ".", "If", "FRAME_BIAS", "is", "nonzero", ",", "then", "BASE_REG", "contains", "SP+FRAME_BIAS", ",", "and", "that", "is", "the", "unwind", "info", "that", "should", "be", "generated", ".", "If", "FRAME_REG", "!", "=", "VALUE", ",", "then", "VALUE", "is", "being", "stored", "on", "behalf", "of", "FRAME_REG", ",", "and", "FRAME_REG", "should", "be", "present", "in", "the", "unwind", "."], "TS_V_token": ["alpha", "1"], "File": "alpha3", "Func": "emit_frame_store_1", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40618, "Length": 129}
{"ground_truth": ["<s>", "static", "rtx", "emit_insxl", "(", "enum", "machine_mode", "mode", ",", "rtx", "op1", ",", "rtx", "op2", ")", "{", "rtx", "ret", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "rtx", "(", "*", "fn", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "if", "(", "WORDS_BIG_ENDIAN", ")", "{", "if", "(", "mode", "==", "QImode", ")", "fn", "=", "gen_insbl_be", ";", "else", "fn", "=", "gen_inswl_be", ";", "}", "else", "{", "if", "(", "mode", "==", "QImode", ")", "fn", "=", "gen_insbl_le", ";", "else", "fn", "=", "gen_inswl_le", ";", "}", "emit_insn", "(", "fn", "(", "ret", ",", "op1", ",", "op2", ")", ")", ";", "return", "ret", ";", "}", "</s>"], "natrual_language": ["A", "subroutine", "of", "the", "atomic", "operation", "splitters", ".", "Emit", "an", "insxl", "instruction", "in", "MODE", "."], "TS_V_token": ["alpha"], "File": "alpha3", "Func": "emit_insxl", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40619, "Length": 91}
{"ground_truth": ["<s>", "static", "void", "emit_load_locked", "(", "enum", "machine_mode", "mode", ",", "rtx", "reg", ",", "rtx", "mem", ")", "{", "rtx", "(", "*", "fn", ")", "(", "rtx", ",", "rtx", ")", "=", "NULL", ";", "if", "(", "mode", "==", "SImode", ")", "fn", "=", "gen_load_locked_si", ";", "else", "if", "(", "mode", "==", "DImode", ")", "fn", "=", "gen_load_locked_di", ";", "emit_insn", "(", "fn", "(", "reg", ",", "mem", ")", ")", ";", "}", "</s>"], "natrual_language": ["A", "subroutine", "of", "the", "atomic", "operation", "splitters", ".", "Emit", "a", "load-locked", "instruction", "in", "MODE", ".", "For", "QI/HImode", ",", "possibly", "use", "a", "pattern", "than", "includes", "the", "zero_extend", "operation", "."], "TS_V_token": ["alpha"], "File": "alpha3", "Func": "emit_load_locked", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40620, "Length": 60}
{"ground_truth": ["<s>", "static", "void", "emit_store_conditional", "(", "enum", "machine_mode", "mode", ",", "rtx", "res", ",", "rtx", "mem", ",", "rtx", "val", ")", "{", "rtx", "(", "*", "fn", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", "=", "NULL", ";", "if", "(", "mode", "==", "SImode", ")", "fn", "=", "gen_store_conditional_si", ";", "else", "if", "(", "mode", "==", "DImode", ")", "fn", "=", "gen_store_conditional_di", ";", "emit_insn", "(", "fn", "(", "res", ",", "mem", ",", "val", ")", ")", ";", "}", "</s>"], "natrual_language": ["A", "subroutine", "of", "the", "atomic", "operation", "splitters", ".", "Emit", "a", "store-conditional", "instruction", "in", "MODE", "."], "TS_V_token": ["alpha"], "File": "alpha3", "Func": "emit_store_conditional", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40621, "Length": 67}
{"ground_truth": ["<s>", "static", "void", "emit_unlikely_jump", "(", "rtx", "cond", ",", "rtx", "label", ")", "{", "rtx", "very_unlikely", "=", "GEN_INT", "(", "REG_BR_PROB_BASE", "/", "100", "-", "1", ")", ";", "rtx", "x", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "cond", ",", "label", ",", "pc_rtx", ")", ";", "x", "=", "emit_jump_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "pc_rtx", ",", "x", ")", ")", ";", "REG_NOTES", "(", "x", ")", "=", "gen_rtx_EXPR_LIST", "(", "REG_BR_PROB", ",", "very_unlikely", ",", "NULL_RTX", ")", ";", "}", "</s>"], "natrual_language": ["Mark", "the", "previous", "jump", "instruction", "as", "unlikely", "."], "TS_V_token": ["alpha", "100", "1"], "File": "alpha3", "Func": "emit_unlikely_jump", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40622, "Length": 68}
{"ground_truth": ["<s>", "rtx", "function_arg", "(", "CUMULATIVE_ARGS", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "named", "ATTRIBUTE_UNUSED", ")", "{", "int", "basereg", ";", "int", "num_args", ";", "if", "(", "type", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "basereg", "=", "16", ";", "else", "{", "gcc_assert", "(", "!", "COMPLEX_MODE_P", "(", "mode", ")", ")", ";", "if", "(", "TARGET_FPREGS", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", "basereg", "=", "32", "+", "16", ";", "else", "basereg", "=", "16", ";", "}", "{", "if", "(", "mode", "==", "VOIDmode", ")", "return", "alpha_arg_info_reg_val", "(", "cum", ")", ";", "num_args", "=", "cum", ".", "num_args", ";", "if", "(", "num_args", ">=", "6", "||", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "return", "NULL_RTX", ";", "}", "{", "int", "size", ";", "if", "(", "mode", "==", "VOIDmode", ")", "{", "int", "i", ";", "HOST_WIDE_INT", "lo", ";", "HOST_WIDE_INT", "hi", ";", "rtx", "ciw", ";", "lo", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "cum", ".", "num_reg_words", "&&", "i", "<", "5", ";", "i", "++", ")", "if", "(", "cum", ".", "reg_args_type", "[", "i", "]", ")", "lo", "|=", "(", "1", "<<", "(", "7", "-", "i", ")", ")", ";", "if", "(", "cum", ".", "num_reg_words", "==", "6", "&&", "cum", ".", "reg_args_type", "[", "5", "]", ")", "lo", "|=", "7", ";", "else", "lo", "|=", "cum", ".", "num_reg_words", ";", "hi", "=", "(", "cum", ".", "num_args", "<<", "20", ")", "|", "cum", ".", "num_arg_words", ";", "lo", "=", "lo", "|", "(", "(", "HOST_WIDE_INT", ")", "cum", ".", "num_args", "<<", "52", ")", "|", "(", "(", "HOST_WIDE_INT", ")", "cum", ".", "num_arg_words", "<<", "32", ")", ";", "hi", "=", "0", ";", "ciw", "=", "immed_double_const", "(", "lo", ",", "hi", ",", "DImode", ")", ";", "return", "gen_rtx_UNSPEC", "(", "DImode", ",", "gen_rtvec", "(", "1", ",", "ciw", ")", ",", "UNSPEC_UMK_LOAD_CIW", ")", ";", "}", "size", "=", "ALPHA_ARG_SIZE", "(", "mode", ",", "type", ",", "named", ")", ";", "num_args", "=", "cum", ".", "num_reg_words", ";", "if", "(", "cum", ".", "force_stack", "||", "cum", ".", "num_reg_words", "+", "size", ">", "6", "||", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "return", "NULL_RTX", ";", "else", "if", "(", "type", "&&", "TYPE_MODE", "(", "type", ")", "==", "BLKmode", ")", "{", "rtx", "reg1", ",", "reg2", ";", "reg1", "=", "gen_rtx_REG", "(", "DImode", ",", "num_args", "+", "16", ")", ";", "reg1", "=", "gen_rtx_EXPR_LIST", "(", "DImode", ",", "reg1", ",", "const0_rtx", ")", ";", "if", "(", "size", "==", "0", ")", "return", "NULL_RTX", ";", "else", "if", "(", "size", "==", "1", ")", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "1", ",", "reg1", ")", ")", ";", "else", "{", "reg2", "=", "gen_rtx_REG", "(", "DImode", ",", "num_args", "+", "17", ")", ";", "reg2", "=", "gen_rtx_EXPR_LIST", "(", "DImode", ",", "reg2", ",", "GEN_INT", "(", "8", ")", ")", ";", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "2", ",", "reg1", ",", "reg2", ")", ")", ";", "}", "}", "}", "{", "if", "(", "cum", ">=", "6", ")", "return", "NULL_RTX", ";", "num_args", "=", "cum", ";", "if", "(", "type", "==", "void_type_node", ")", "basereg", "=", "16", ";", "else", "if", "(", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "return", "NULL_RTX", ";", "}", "return", "gen_rtx_REG", "(", "mode", ",", "num_args", "+", "basereg", ")", ";", "}", "</s>"], "natrual_language": ["Return", "an", "RTL", "expression", "containing", "the", "register", "for", "the", "given", "mode", ",", "or", "0", "if", "the", "argument", "is", "to", "be", "passed", "on", "the", "stack", ".", "INCOMING_P", "is", "nonzero", "if", "this", "is", "an", "incoming", "argument", "to", "the", "current", "function", "."], "TS_V_token": ["alpha", "16", "32", "16", "16", "6", "0", "0", "5", "1", "7", "6", "5", "7", "20", "52", "32", "0", "1", "6", "16", "0", "1", "1", "17", "8", "2", "6", "16"], "File": "alpha3", "Func": "function_arg", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40623, "Length": 487}
{"ground_truth": ["<s>", "rtx", "function_value", "(", "tree", "valtype", ",", "tree", "func", "ATTRIBUTE_UNUSED", ",", "enum", "machine_mode", "mode", ")", "{", "unsigned", "int", "regnum", ",", "dummy", ";", "enum", "mode_class", "class", ";", "gcc_assert", "(", "!", "valtype", "||", "!", "alpha_return_in_memory", "(", "valtype", ",", "func", ")", ")", ";", "if", "(", "valtype", ")", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "class", "=", "GET_MODE_CLASS", "(", "mode", ")", ";", "switch", "(", "class", ")", "{", "case", "MODE_INT", ":", "PROMOTE_MODE", "(", "mode", ",", "dummy", ",", "valtype", ")", ";", "case", "MODE_COMPLEX_INT", ":", "case", "MODE_VECTOR_INT", ":", "regnum", "=", "0", ";", "break", ";", "case", "MODE_FLOAT", ":", "regnum", "=", "32", ";", "break", ";", "case", "MODE_COMPLEX_FLOAT", ":", "{", "enum", "machine_mode", "cmode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "return", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "cmode", ",", "32", ")", ",", "const0_rtx", ")", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "cmode", ",", "33", ")", ",", "GEN_INT", "(", "GET_MODE_SIZE", "(", "cmode", ")", ")", ")", ")", ")", ";", "}", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "gen_rtx_REG", "(", "mode", ",", "regnum", ")", ";", "}", "</s>"], "natrual_language": ["Handle", "FUNCTION_VALUE", ",", "FUNCTION_OUTGOING_VALUE", ",", "and", "LIBCALL_VALUE", "macros", ".", "For", "v9", ",", "function", "return", "values", "are", "subject", "to", "the", "same", "rules", "as", "arguments", ",", "except", "that", "up", "to", "32", "bytes", "may", "be", "returned", "in", "registers", "."], "TS_V_token": ["alpha", "0", "32", "2", "32", "33"], "File": "alpha3", "Func": "function_value", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40624, "Length": 170}
{"ground_truth": ["<s>", "void", "get_aligned_mem", "(", "rtx", "ref", ",", "rtx", "*", "paligned_mem", ",", "rtx", "*", "pbitnum", ")", "{", "rtx", "base", ";", "HOST_WIDE_INT", "disp", ",", "offset", ";", "gcc_assert", "(", "GET_CODE", "(", "ref", ")", "==", "MEM", ")", ";", "if", "(", "reload_in_progress", "&&", "!", "memory_address_p", "(", "GET_MODE", "(", "ref", ")", ",", "XEXP", "(", "ref", ",", "0", ")", ")", ")", "{", "base", "=", "find_replacement", "(", "&", "XEXP", "(", "ref", ",", "0", ")", ")", ";", "gcc_assert", "(", "memory_address_p", "(", "GET_MODE", "(", "ref", ")", ",", "base", ")", ")", ";", "}", "else", "base", "=", "XEXP", "(", "ref", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", ")", "disp", "=", "INTVAL", "(", "XEXP", "(", "base", ",", "1", ")", ")", ",", "base", "=", "XEXP", "(", "base", ",", "0", ")", ";", "else", "disp", "=", "0", ";", "if", "(", "MEM_ALIGN", "(", "ref", ")", ">=", "32", ")", "offset", "=", "0", ";", "else", "offset", "=", "disp", "&", "3", ";", "*", "paligned_mem", "=", "widen_memory_access", "(", "ref", ",", "SImode", ",", "-", "offset", ")", ";", "if", "(", "WORDS_BIG_ENDIAN", ")", "offset", "=", "32", "-", "(", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "ref", ")", ")", "+", "offset", "*", "8", ")", ";", "else", "offset", "*=", "8", ";", "*", "pbitnum", "=", "GEN_INT", "(", "offset", ")", ";", "}", "</s>"], "natrual_language": ["REF", "is", "an", "alignable", "memory", "location", ".", "Place", "an", "aligned", "SImode", "reference", "into", "*", "PALIGNED_MEM", "and", "the", "number", "of", "bits", "to", "shift", "into", "*", "PBITNUM", ".", "SCRATCH", "is", "a", "free", "register", "for", "use", "in", "reloading", "out", "of", "range", "stack", "slots", "."], "TS_V_token": ["alpha", "0", "0", "0", "1", "0", "0", "32", "0", "3", "32", "8", "8"], "File": "alpha3", "Func": "get_aligned_mem", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40625, "Length": 195}
{"ground_truth": ["<s>", "static", "const", "char", "*", "get_some_local_dynamic_name", "(", "void", ")", "{", "rtx", "insn", ";", "if", "(", "cfun", "->", "machine", "->", "some_ld_name", ")", "return", "cfun", "->", "machine", "->", "some_ld_name", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "INSN_P", "(", "insn", ")", "&&", "for_each_rtx", "(", "&", "PATTERN", "(", "insn", ")", ",", "get_some_local_dynamic_name_1", ",", "0", ")", ")", "return", "cfun", "->", "machine", "->", "some_ld_name", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>"], "natrual_language": ["Locate", "some", "local-dynamic", "symbol", "still", "in", "use", "by", "this", "function", "so", "that", "we", "can", "print", "its", "name", "in", "local-dynamic", "base", "patterns", "."], "TS_V_token": ["alpha", "0"], "File": "alpha3", "Func": "get_some_local_dynamic_name", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40626, "Length": 76}
{"ground_truth": ["<s>", "static", "int", "get_some_local_dynamic_name_1", "(", "rtx", "*", "px", ",", "void", "*", "data", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "x", "=", "*", "px", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "==", "TLS_MODEL_LOCAL_DYNAMIC", ")", "{", "cfun", "->", "machine", "->", "some_ld_name", "=", "XSTR", "(", "x", ",", "0", ")", ";", "return", "1", ";", "}", "return", "0", ";", "}", "</s>"], "natrual_language": ["See", "'get_some_local_dynamic_name", "'", "."], "TS_V_token": ["alpha", "0", "1", "0"], "File": "alpha3", "Func": "get_some_local_dynamic_name_1", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40627, "Length": 58}
{"ground_truth": ["<s>", "rtx", "get_unaligned_address", "(", "rtx", "ref", ",", "int", "extra_offset", ")", "{", "rtx", "base", ";", "HOST_WIDE_INT", "offset", "=", "0", ";", "gcc_assert", "(", "GET_CODE", "(", "ref", ")", "==", "MEM", ")", ";", "if", "(", "reload_in_progress", "&&", "!", "memory_address_p", "(", "GET_MODE", "(", "ref", ")", ",", "XEXP", "(", "ref", ",", "0", ")", ")", ")", "{", "base", "=", "find_replacement", "(", "&", "XEXP", "(", "ref", ",", "0", ")", ")", ";", "gcc_assert", "(", "memory_address_p", "(", "GET_MODE", "(", "ref", ")", ",", "base", ")", ")", ";", "}", "else", "base", "=", "XEXP", "(", "ref", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", ")", "offset", "+=", "INTVAL", "(", "XEXP", "(", "base", ",", "1", ")", ")", ",", "base", "=", "XEXP", "(", "base", ",", "0", ")", ";", "return", "plus_constant", "(", "base", ",", "offset", "+", "extra_offset", ")", ";", "}", "</s>"], "natrual_language": ["Similar", ",", "but", "just", "get", "the", "address", ".", "Handle", "the", "two", "reload", "cases", ".", "Add", "EXTRA_OFFSET", "to", "the", "address", "we", "return", "."], "TS_V_token": ["alpha", "0", "0", "0", "0", "1", "0"], "File": "alpha3", "Func": "get_unaligned_address", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40628, "Length": 127}
{"ground_truth": ["<s>", "void", "print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "int", "basereg", "=", "31", ";", "HOST_WIDE_INT", "offset", "=", "0", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "AND", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "==", "CONST_INT", ")", "{", "offset", "=", "INTVAL", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "addr", ")", "==", "LO_SUM", ")", "{", "const", "char", "*", "reloc16", ",", "*", "reloclo", ";", "rtx", "op1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "op1", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "op1", ",", "0", ")", ")", "==", "UNSPEC", ")", "{", "op1", "=", "XEXP", "(", "op1", ",", "0", ")", ";", "switch", "(", "XINT", "(", "op1", ",", "1", ")", ")", "{", "case", "UNSPEC_DTPREL", ":", "reloc16", "=", "NULL", ";", "reloclo", "=", "(", "alpha_tls_size", "==", "16", "?", "\"dtprel\"", ":", "\"dtprello\"", ")", ";", "break", ";", "case", "UNSPEC_TPREL", ":", "reloc16", "=", "NULL", ";", "reloclo", "=", "(", "alpha_tls_size", "==", "16", "?", "\"tprel\"", ":", "\"tprello\"", ")", ";", "break", ";", "default", ":", "output_operand_lossage", "(", "\"unknown relocation unspec\"", ")", ";", "return", ";", "}", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "op1", ",", "0", ",", "0", ")", ")", ";", "}", "else", "{", "reloc16", "=", "\"gprel\"", ";", "reloclo", "=", "\"gprellow\"", ";", "output_addr_const", "(", "file", ",", "op1", ")", ";", "}", "if", "(", "offset", ")", "fprintf", "(", "file", ",", "\"+\"", "HOST_WIDE_INT_PRINT_DEC", ",", "offset", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "basereg", "=", "REGNO", "(", "addr", ")", ";", "break", ";", "case", "SUBREG", ":", "basereg", "=", "subreg_regno", "(", "addr", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "fprintf", "(", "file", ",", "\"($%d)\\t\\t!%s\"", ",", "basereg", ",", "(", "basereg", "==", "29", "?", "reloc16", ":", "reloclo", ")", ")", ";", "return", ";", "}", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "basereg", "=", "REGNO", "(", "addr", ")", ";", "break", ";", "case", "SUBREG", ":", "basereg", "=", "subreg_regno", "(", "addr", ")", ";", "break", ";", "case", "CONST_INT", ":", "offset", "=", "INTVAL", "(", "addr", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "fprintf", "(", "file", ",", "\"%s\"", ",", "XSTR", "(", "addr", ",", "0", ")", ")", ";", "return", ";", "case", "CONST", ":", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", ";", "fprintf", "(", "file", ",", "\"%s+\"", "HOST_WIDE_INT_PRINT_DEC", ",", "XSTR", "(", "XEXP", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ",", "0", ")", ",", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "1", ")", ")", ")", ";", "return", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", "\"($%d)\"", ",", "offset", ",", "basereg", ")", ";", "}", "</s>"], "natrual_language": ["Print", "the", "operand", "address", "represented", "by", "the", "rtx", "addr"], "TS_V_token": ["alpha", "31", "0", "0", "1", "1", "0", "1", "0", "0", "1", "16", "\"dtprel\"", "\"dtprello\"", "16", "\"tprel\"", "\"tprello\"", "\"unknown relocation unspec\"", "0", "0", "\"gprel\"", "\"gprellow\"", "\"+\"", "0", "\"($%d)\\t\\t!%s\"", "29", "\"%s\"", "0", "0", "0", "0", "\"%s+\"", "0", "0", "0", "0", "1", "\"($%d)\""], "File": "alpha3", "Func": "print_operand_address", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40629, "Length": 481}
{"ground_truth": ["<s>", "rtx", "resolve_reload_operand", "(", "rtx", "op", ")", "{", "if", "(", "reload_in_progress", ")", "{", "rtx", "tmp", "=", "op", ";", "if", "(", "GET_CODE", "(", "tmp", ")", "==", "SUBREG", ")", "tmp", "=", "SUBREG_REG", "(", "tmp", ")", ";", "if", "(", "GET_CODE", "(", "tmp", ")", "==", "REG", "&&", "REGNO", "(", "tmp", ")", ">=", "FIRST_PSEUDO_REGISTER", ")", "{", "op", "=", "reg_equiv_memory_loc", "[", "REGNO", "(", "tmp", ")", "]", ";", "if", "(", "op", "==", "0", ")", "return", "0", ";", "}", "}", "return", "op", ";", "}", "</s>"], "natrual_language": ["Used", "by", "aligned_memory_operand", "and", "unaligned_memory_operand", "to", "resolve", "what", "reload", "is", "going", "to", "do", "with", "OP", "if", "it", "'s", "a", "register", "."], "TS_V_token": ["alpha", "0", "0"], "File": "alpha3", "Func": "resolve_reload_operand", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40630, "Length": 75}
{"ground_truth": ["<s>", "enum", "reg_class", "secondary_reload_class", "(", "enum", "reg_class", "class", ",", "enum", "machine_mode", "mode", ",", "rtx", "x", ",", "int", "in", ")", "{", "if", "(", "(", "mode", "==", "QImode", "||", "mode", "==", "HImode", ")", "&&", "!", "TARGET_BWX", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", "||", "(", "GET_CODE", "(", "x", ")", "==", "REG", "&&", "REGNO", "(", "x", ")", ">=", "FIRST_PSEUDO_REGISTER", ")", "||", "(", "GET_CODE", "(", "x", ")", "==", "SUBREG", "&&", "(", "GET_CODE", "(", "SUBREG_REG", "(", "x", ")", ")", "==", "MEM", "||", "(", "GET_CODE", "(", "SUBREG_REG", "(", "x", ")", ")", "==", "REG", "&&", "REGNO", "(", "SUBREG_REG", "(", "x", ")", ")", ">=", "FIRST_PSEUDO_REGISTER", ")", ")", ")", ")", "{", "if", "(", "!", "in", "||", "!", "aligned_memory_operand", "(", "x", ",", "mode", ")", ")", "return", "GENERAL_REGS", ";", "}", "}", "if", "(", "class", "==", "FLOAT_REGS", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "AND", ")", "return", "GENERAL_REGS", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SUBREG", "&&", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", ">", "GET_MODE_SIZE", "(", "GET_MODE", "(", "SUBREG_REG", "(", "x", ")", ")", ")", ")", ")", "return", "GENERAL_REGS", ";", "if", "(", "in", "&&", "INTEGRAL_MODE_P", "(", "mode", ")", "&&", "!", "(", "memory_operand", "(", "x", ",", "mode", ")", "||", "x", "==", "const0_rtx", ")", ")", "return", "GENERAL_REGS", ";", "}", "</s>"], "natrual_language": ["Return", "the", "class", "of", "any", "secondary", "reload", "register", "that", "is", "needed", "to", "move", "IN", "into", "a", "register", "in", "class", "CLASS", "using", "mode", "MODE", ".", "Profiling", "has", "showed", "this", "routine", "and", "its", "descendants", "account", "for", "a", "significant", "amount", "of", "compile", "time", "(", "~7", "%", ")", ".", "So", "it", "has", "been", "optimized", "to", "reduce", "redundant", "computations", "and", "eliminate", "useless", "function", "calls", ".", "It", "might", "be", "worthwhile", "to", "try", "and", "make", "this", "a", "leaf", "function", "too", "."], "TS_V_token": ["alpha", "0"], "File": "alpha3", "Func": "secondary_reload_class", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40631, "Length": 213}
{"ground_truth": ["<s>", "static", "rtx", "set_frame_related_p", "(", "void", ")", "{", "rtx", "seq", "=", "get_insns", "(", ")", ";", "rtx", "insn", ";", "end_sequence", "(", ")", ";", "if", "(", "!", "seq", ")", "return", "NULL_RTX", ";", "if", "(", "INSN_P", "(", "seq", ")", ")", "{", "insn", "=", "seq", ";", "while", "(", "insn", "!=", "NULL_RTX", ")", "{", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "}", "seq", "=", "emit_insn", "(", "seq", ")", ";", "}", "else", "{", "seq", "=", "emit_insn", "(", "seq", ")", ";", "RTX_FRAME_RELATED_P", "(", "seq", ")", "=", "1", ";", "}", "return", "seq", ";", "}", "</s>"], "natrual_language": ["Helper", "function", "to", "set", "RTX_FRAME_RELATED_P", "on", "instructions", ",", "including", "sequences", "."], "TS_V_token": ["alpha", "1", "1"], "File": "alpha3", "Func": "set_frame_related_p", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40632, "Length": 92}
{"ground_truth": ["<s>", "static", "enum", "tls_model", "tls_symbolic_operand_type", "(", "rtx", "symbol", ")", "{", "enum", "tls_model", "model", ";", "if", "(", "GET_CODE", "(", "symbol", ")", "!=", "SYMBOL_REF", ")", "return", "0", ";", "model", "=", "SYMBOL_REF_TLS_MODEL", "(", "symbol", ")", ";", "if", "(", "model", "==", "TLS_MODEL_LOCAL_EXEC", "&&", "alpha_tls_size", "==", "64", ")", "model", "=", "TLS_MODEL_INITIAL_EXEC", ";", "return", "model", ";", "}", "</s>"], "natrual_language": ["Return", "the", "TLS", "model", "to", "use", "for", "SYMBOL", "."], "TS_V_token": ["alpha", "0", "64"], "File": "alpha3", "Func": "tls_symbolic_operand_type", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40633, "Length": 50}
{"ground_truth": ["<s>", "rtx", "unicosmk_add_call_info_word", "(", "rtx", "x", "ATTRIBUTE_UNUSED", ")", "{", "return", "NULL_RTX", ";", "}", "</s>"], "natrual_language": ["Add", "a", "call", "information", "word", "(", "CIW", ")", "to", "the", "list", "of", "the", "current", "function", "'s", "CIWs", "and", "return", "its", "index", ".", "X", "is", "a", "CONST_INT", "or", "CONST_DOUBLE", "representing", "the", "CIW", "."], "TS_V_token": ["alpha"], "File": "alpha3", "Func": "unicosmk_add_call_info_word", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40634, "Length": 12}
{"ground_truth": ["<s>", "void", "unicosmk_add_extern", "(", "const", "char", "*", "name", ")", "{", "struct", "unicosmk_extern_list", "*", "p", ";", "p", "=", "(", "struct", "unicosmk_extern_list", "*", ")", "xmalloc", "(", "sizeof", "(", "struct", "unicosmk_extern_list", ")", ")", ";", "p", "->", "next", "=", "unicosmk_extern_head", ";", "p", "->", "name", "=", "name", ";", "unicosmk_extern_head", "=", "p", ";", "}", "</s>"], "natrual_language": ["Record", "an", "extern", "."], "TS_V_token": ["alpha"], "File": "alpha3", "Func": "unicosmk_add_extern", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40635, "Length": 47}
{"ground_truth": ["<s>", "static", "void", "unicosmk_asm_named_section", "(", "const", "char", "*", "name", ",", "unsigned", "int", "flags", ",", "tree", "decl", "ATTRIBUTE_UNUSED", ")", "{", "const", "char", "*", "kind", ";", "fputs", "(", "\"\\t.endp\\n\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "flags", "&", "SECTION_MAIN", ")", "fputs", "(", "\"\\t.start\\tmain\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "flags", "&", "SECTION_CODE", ")", "kind", "=", "\"code\"", ";", "else", "if", "(", "flags", "&", "SECTION_PUBLIC", ")", "kind", "=", "\"common\"", ";", "else", "kind", "=", "\"data\"", ";", "if", "(", "current_section_align", "!=", "0", ")", "fprintf", "(", "asm_out_file", ",", "\"\\t.psect\\t%s,%d,%s\\n\"", ",", "name", ",", "current_section_align", ",", "kind", ")", ";", "else", "fprintf", "(", "asm_out_file", ",", "\"\\t.psect\\t%s,%s\\n\"", ",", "name", ",", "kind", ")", ";", "}", "</s>"], "natrual_language": ["Switch", "to", "an", "arbitrary", "section", "NAME", "with", "attributes", "as", "specified", "by", "FLAGS", ".", "ALIGN", "specifies", "any", "known", "alignment", "requirements", "for", "the", "section", ";", "0", "if", "the", "default", "should", "be", "used", "."], "TS_V_token": ["alpha", "\"\\t.endp\\n\\n\"", "\"\\t.start\\tmain\\n\"", "\"code\"", "\"common\"", "\"data\"", "0", "\"\\t.psect\\t%s,%d,%s\\n\"", "\"\\t.psect\\t%s,%s\\n\""], "File": "alpha3", "Func": "unicosmk_asm_named_section", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40636, "Length": 101}
{"ground_truth": ["<s>", "void", "unicosmk_defer_case_vector", "(", "rtx", "lab", ",", "rtx", "vec", ")", "{", "struct", "machine_function", "*", "machine", "=", "cfun", "->", "machine", ";", "vec", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "lab", ",", "vec", ")", ";", "machine", "->", "addr_list", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "vec", ",", "machine", "->", "addr_list", ")", ";", "}", "</s>"], "natrual_language": ["Add", "a", "case", "vector", "to", "the", "current", "function", "'s", "list", "of", "deferred", "case", "vectors", ".", "Case", "vectors", "have", "to", "be", "put", "into", "a", "separate", "section", "because", "CAM", "does", "not", "allow", "data", "definitions", "in", "code", "sections", "."], "TS_V_token": ["alpha"], "File": "alpha3", "Func": "unicosmk_defer_case_vector", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40637, "Length": 46}
{"ground_truth": ["<s>", "static", "void", "unicosmk_file_end", "(", "void", ")", "{", "fputs", "(", "\"\\t.endp\\n\\n\"", ",", "asm_out_file", ")", ";", "unicosmk_output_externs", "(", "asm_out_file", ")", ";", "unicosmk_output_dex", "(", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.end\\t\"", ",", "asm_out_file", ")", ";", "unicosmk_output_module_name", "(", "asm_out_file", ")", ";", "putc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "}", "</s>"], "natrual_language": ["Output", "text", "to", "appear", "at", "the", "end", "of", "an", "assembler", "file", ".", "This", "includes", "all", "pending", "extern", "declarations", "and", "DEX", "expressions", "."], "TS_V_token": ["alpha", "\"\\t.endp\\n\\n\"", "\"\\t.end\\t\""], "File": "alpha3", "Func": "unicosmk_file_end", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40638, "Length": 44}
{"ground_truth": ["<s>", "static", "void", "unicosmk_file_start", "(", "void", ")", "{", "int", "i", ";", "fputs", "(", "\"\\t.ident\\t\"", ",", "asm_out_file", ")", ";", "unicosmk_output_module_name", "(", "asm_out_file", ")", ";", "fputs", "(", "\"\\n\\n\"", ",", "asm_out_file", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "32", ";", "++", "i", ")", "fprintf", "(", "asm_out_file", ",", "\"$%d <- r%d\\n\"", ",", "i", ",", "i", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "32", ";", "++", "i", ")", "fprintf", "(", "asm_out_file", ",", "\"$f%d <- f%d\\n\"", ",", "i", ",", "i", ")", ";", "putc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.macro gcc@code@align n\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"gcc@n@bytes = 1 << n\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"gcc@here = . % gcc@n@bytes\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.if ne, gcc@here, 0\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.repeat (gcc@n@bytes - gcc@here) / 4\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\tbis r31,r31,r31\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.endr\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.endif\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.endm gcc@code@align\\n\\n\"", ",", "asm_out_file", ")", ";", "unicosmk_output_default_externs", "(", "asm_out_file", ")", ";", "fputs", "(", "\"\\n\\t.psect\\t$SG00000,data\\n\"", ",", "asm_out_file", ")", ";", "}", "</s>"], "natrual_language": ["Output", "text", "that", "to", "appear", "at", "the", "beginning", "of", "an", "assembler", "file", "."], "TS_V_token": ["alpha", "\"\\t.ident\\t\"", "\"\\n\\n\"", "0", "32", "\"$%d <- r%d\\n\"", "0", "32", "\"$f%d <- f%d\\n\"", "\"\\t.macro gcc@code@align n\\n\"", "\"gcc@n@bytes = 1 << n\\n\"", "\"gcc@here = . % gcc@n@bytes\\n\"", "\"\\t.if ne, gcc@here, 0\\n\"", "\"\\t.repeat (gcc@n@bytes - gcc@here) / 4\\n\"", "\"\\tbis r31,r31,r31\\n\"", "\"\\t.endr\\n\"", "\"\\t.endif\\n\"", "\"\\t.endm gcc@code@align\\n\\n\"", "\"\\n\\t.psect\\t$SG00000,data\\n\""], "File": "alpha3", "Func": "unicosmk_file_start", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40639, "Length": 160}
{"ground_truth": ["<s>", "static", "void", "unicosmk_gen_dsib", "(", "unsigned", "long", "*", "imaskP", "ATTRIBUTE_UNUSED", ")", "{", "}", "</s>"], "natrual_language": ["Set", "up", "the", "dynamic", "subprogram", "information", "block", "(", "DSIB", ")", "and", "update", "the", "frame", "pointer", "register", "(", "$", "15", ")", "for", "subroutines", "which", "have", "a", "frame", ".", "If", "the", "subroutine", "does", "n't", "have", "a", "frame", ",", "simply", "increment", "$", "15", "."], "TS_V_token": ["alpha"], "File": "alpha3", "Func": "unicosmk_gen_dsib", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40640, "Length": 12}
{"ground_truth": ["<s>", "int", "unicosmk_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "int", "fixed_size", ";", "fixed_size", "=", "alpha_sa_size", "(", ")", ";", "if", "(", "fixed_size", "!=", "0", ")", "fixed_size", "+=", "48", ";", "if", "(", "from", "==", "FRAME_POINTER_REGNUM", "&&", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", "return", "-", "fixed_size", ";", "else", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", "return", "0", ";", "else", "if", "(", "from", "==", "FRAME_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "return", "(", "ALPHA_ROUND", "(", "current_function_outgoing_args_size", ")", "+", "ALPHA_ROUND", "(", "get_frame_size", "(", ")", ")", ")", ";", "else", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "return", "(", "ALPHA_ROUND", "(", "fixed_size", ")", "+", "ALPHA_ROUND", "(", "get_frame_size", "(", ")", "+", "current_function_outgoing_args_size", ")", ")", ";", "else", "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": ["alpha", "0", "48", "0"], "File": "alpha3", "Func": "unicosmk_initial_elimination_offset", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40641, "Length": 117}
{"ground_truth": ["<s>", "static", "bool", "unicosmk_must_pass_in_stack", "(", "enum", "machine_mode", "mode", ",", "tree", "type", ")", "{", "if", "(", "type", "==", "NULL", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "TYPE_SIZE", "(", "type", ")", ")", "!=", "INTEGER_CST", ")", "return", "true", ";", "if", "(", "TREE_ADDRESSABLE", "(", "type", ")", ")", "return", "true", ";", "return", "ALPHA_ARG_SIZE", "(", "mode", ",", "type", ",", "0", ")", ">", "2", ";", "}", "</s>"], "natrual_language": ["This", "evaluates", "to", "true", "if", "we", "do", "not", "know", "how", "to", "pass", "TYPE", "solely", "in", "registers", ".", "This", "is", "the", "case", "for", "all", "arguments", "that", "do", "not", "fit", "in", "two", "registers", "."], "TS_V_token": ["alpha", "0", "2"], "File": "alpha3", "Func": "unicosmk_must_pass_in_stack", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40642, "Length": 59}
{"ground_truth": ["<s>", "static", "int", "unicosmk_need_dex", "(", "rtx", "x", "ATTRIBUTE_UNUSED", ")", "{", "return", "0", ";", "}", "</s>"], "natrual_language": ["Return", "the", "DEX", "number", "if", "X", "must", "be", "replaced", "by", "a", "DEX", "expression", "and", "0", "otherwise", "."], "TS_V_token": ["alpha", "0"], "File": "alpha3", "Func": "unicosmk_need_dex", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40643, "Length": 13}
{"ground_truth": ["<s>", "static", "void", "unicosmk_output_addr_vec", "(", "FILE", "*", "file", ",", "rtx", "vec", ")", "{", "rtx", "lab", "=", "XEXP", "(", "vec", ",", "0", ")", ";", "rtx", "body", "=", "XEXP", "(", "vec", ",", "1", ")", ";", "int", "vlen", "=", "XVECLEN", "(", "body", ",", "0", ")", ";", "int", "idx", ";", "(", "*", "targetm", ".", "asm_out", ".", "internal_label", ")", "(", "file", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "lab", ")", ")", ";", "for", "(", "idx", "=", "0", ";", "idx", "<", "vlen", ";", "idx", "++", ")", "{", "ASM_OUTPUT_ADDR_VEC_ELT", "(", "file", ",", "CODE_LABEL_NUMBER", "(", "XEXP", "(", "XVECEXP", "(", "body", ",", "0", ",", "idx", ")", ",", "0", ")", ")", ")", ";", "}", "}", "</s>"], "natrual_language": ["Output", "a", "case", "vector", "."], "TS_V_token": ["alpha", "0", "1", "0", "\"L\"", "0", "0", "0"], "File": "alpha3", "Func": "unicosmk_output_addr_vec", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40644, "Length": 102}
{"ground_truth": ["<s>", "void", "unicosmk_output_align", "(", "FILE", "*", "file", ",", "int", "align", ")", "{", "if", "(", "inside_function", ")", "fprintf", "(", "file", ",", "\"\\tgcc@code@align\\t%d\\n\"", ",", "align", ")", ";", "else", "fprintf", "(", "file", ",", "\"\\t.align\\t%d\\n\"", ",", "align", ")", ";", "}", "</s>"], "natrual_language": ["Output", "an", "alignment", "directive", ".", "We", "have", "to", "use", "the", "macro", "'gcc", "@", "code", "@", "align", "'", "in", "code", "sections", "because", ".align", "fill", "unused", "space", "with", "zeroes", "."], "TS_V_token": ["alpha", "\"\\tgcc@code@align\\t%d\\n\"", "\"\\t.align\\t%d\\n\""], "File": "alpha3", "Func": "unicosmk_output_align", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40645, "Length": 35}
{"ground_truth": ["<s>", "void", "unicosmk_output_common", "(", "FILE", "*", "file", ",", "const", "char", "*", "name", ",", "int", "size", ",", "int", "align", ")", "{", "tree", "name_tree", ";", "printf", "(", "\"T3E__: common %s\\n\"", ",", "name", ")", ";", "common_section", "(", ")", ";", "fputs", "(", "\"\\t.endp\\n\\n\\t.psect \"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "name", ")", ";", "fprintf", "(", "file", ",", "\",%d,common\\n\"", ",", "floor_log2", "(", "align", "/", "BITS_PER_UNIT", ")", ")", ";", "fprintf", "(", "file", ",", "\"\\t.byte\\t0:%d\\n\"", ",", "size", ")", ";", "name_tree", "=", "get_identifier", "(", "name", ")", ";", "TREE_ASM_WRITTEN", "(", "name_tree", ")", "=", "1", ";", "}", "</s>"], "natrual_language": ["Output", "the", "definition", "of", "a", "common", "variable", "."], "TS_V_token": ["alpha", "\"T3E__: common %s\\n\"", "\"\\t.endp\\n\\n\\t.psect \"", "\",%d,common\\n\"", "\"\\t.byte\\t0:%d\\n\"", "1"], "File": "alpha3", "Func": "unicosmk_output_common", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40646, "Length": 85}
{"ground_truth": ["<s>", "static", "void", "unicosmk_output_default_externs", "(", "FILE", "*", "file", ")", "{", "static", "const", "char", "*", "const", "externs", "[", "]", "=", "{", "\"__T3E_MISMATCH\"", "}", ";", "int", "i", ";", "int", "n", ";", "n", "=", "ARRAY_SIZE", "(", "externs", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "fprintf", "(", "file", ",", "\"\\t.extern\\t%s\\n\"", ",", "externs", "[", "i", "]", ")", ";", "}", "</s>"], "natrual_language": ["Output", "extern", "declarations", "which", "are", "required", "for", "every", "asm", "file", "."], "TS_V_token": ["alpha", "\"__T3E_MISMATCH\"", "0", "\"\\t.extern\\t%s\\n\""], "File": "alpha3", "Func": "unicosmk_output_default_externs", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40647, "Length": 61}
{"ground_truth": ["<s>", "static", "void", "unicosmk_output_deferred_case_vectors", "(", "FILE", "*", "file", ")", "{", "struct", "machine_function", "*", "machine", "=", "cfun", "->", "machine", ";", "rtx", "t", ";", "if", "(", "machine", "->", "addr_list", "==", "NULL_RTX", ")", "return", ";", "data_section", "(", ")", ";", "for", "(", "t", "=", "machine", "->", "addr_list", ";", "t", ";", "t", "=", "XEXP", "(", "t", ",", "1", ")", ")", "unicosmk_output_addr_vec", "(", "file", ",", "XEXP", "(", "t", ",", "0", ")", ")", ";", "}", "</s>"], "natrual_language": ["Output", "current", "function", "'s", "deferred", "case", "vectors", "."], "TS_V_token": ["alpha", "1", "0"], "File": "alpha3", "Func": "unicosmk_output_deferred_case_vectors", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40648, "Length": 67}
{"ground_truth": ["<s>", "static", "void", "unicosmk_output_dex", "(", "FILE", "*", "file", ")", "{", "struct", "unicosmk_dex", "*", "dex", ";", "int", "i", ";", "if", "(", "unicosmk_dex_list", "==", "NULL", ")", "return", ";", "fprintf", "(", "file", ",", "\"\\t.dexstart\\n\"", ")", ";", "i", "=", "unicosmk_dex_count", ";", "for", "(", "dex", "=", "unicosmk_dex_list", ";", "dex", ";", "dex", "=", "dex", "->", "next", ")", "{", "fprintf", "(", "file", ",", "\"\\tDEX (%d) = \"", ",", "i", ")", ";", "assemble_name", "(", "file", ",", "dex", "->", "name", ")", ";", "putc", "(", "'\\n'", ",", "file", ")", ";", "--", "i", ";", "}", "fprintf", "(", "file", ",", "\"\\t.dexend\\n\"", ")", ";", "}", "</s>"], "natrual_language": ["Output", "the", "DEX", "definitions", "for", "this", "file", "."], "TS_V_token": ["alpha", "\"\\t.dexstart\\n\"", "\"\\tDEX (%d) = \"", "\"\\t.dexend\\n\""], "File": "alpha3", "Func": "unicosmk_output_dex", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40649, "Length": 88}
{"ground_truth": ["<s>", "static", "void", "unicosmk_output_externs", "(", "FILE", "*", "file", ")", "{", "struct", "unicosmk_extern_list", "*", "p", ";", "const", "char", "*", "real_name", ";", "int", "len", ";", "tree", "name_tree", ";", "len", "=", "strlen", "(", "user_label_prefix", ")", ";", "for", "(", "p", "=", "unicosmk_extern_head", ";", "p", "!=", "0", ";", "p", "=", "p", "->", "next", ")", "{", "real_name", "=", "default_strip_name_encoding", "(", "p", "->", "name", ")", ";", "if", "(", "len", "&&", "p", "->", "name", "[", "0", "]", "==", "'*'", "&&", "!", "memcmp", "(", "real_name", ",", "user_label_prefix", ",", "len", ")", ")", "real_name", "+=", "len", ";", "name_tree", "=", "get_identifier", "(", "real_name", ")", ";", "if", "(", "!", "TREE_ASM_WRITTEN", "(", "name_tree", ")", ")", "{", "TREE_ASM_WRITTEN", "(", "name_tree", ")", "=", "1", ";", "fputs", "(", "\"\\t.extern\\t\"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "p", "->", "name", ")", ";", "putc", "(", "'\\n'", ",", "file", ")", ";", "}", "}", "}", "</s>"], "natrual_language": ["Output", "extern", "declarations", "for", "global", "symbols", "which", "are", "have", "been", "referenced", "but", "not", "defined", "."], "TS_V_token": ["alpha", "0", "0", "1", "\"\\t.extern\\t\""], "File": "alpha3", "Func": "unicosmk_output_externs", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40650, "Length": 134}
{"ground_truth": ["<s>", "static", "void", "unicosmk_output_module_name", "(", "FILE", "*", "file", ")", "{", "const", "char", "*", "name", "=", "lbasename", "(", "main_input_filename", ")", ";", "unsigned", "len", "=", "strlen", "(", "name", ")", ";", "char", "*", "clean_name", "=", "alloca", "(", "len", "+", "2", ")", ";", "char", "*", "ptr", "=", "clean_name", ";", "if", "(", "!", "ISALPHA", "(", "*", "name", ")", ")", "*", "ptr", "++", "=", "'$'", ";", "memcpy", "(", "ptr", ",", "name", ",", "len", "+", "1", ")", ";", "clean_symbol_name", "(", "clean_name", ")", ";", "fputs", "(", "clean_name", ",", "file", ")", ";", "}", "</s>"], "natrual_language": ["Output", "the", "module", "name", "for", ".ident", "and", ".end", "directives", ".", "We", "have", "to", "strip", "directories", "and", "add", "make", "sure", "that", "the", "module", "name", "starts", "with", "a", "letter", "or", "'", "$", "'", "."], "TS_V_token": ["alpha", "2", "1"], "File": "alpha3", "Func": "unicosmk_output_module_name", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40651, "Length": 83}
{"ground_truth": ["<s>", "static", "void", "unicosmk_output_ssib", "(", "FILE", "*", "file", ",", "const", "char", "*", "fnname", ")", "{", "int", "len", ";", "int", "i", ";", "rtx", "x", ";", "rtx", "ciw", ";", "struct", "machine_function", "*", "machine", "=", "cfun", "->", "machine", ";", "ssib_section", "(", ")", ";", "fprintf", "(", "file", ",", "\"\\t.endp\\n\\n\\t.psect\\t%s%s,data\\n\"", ",", "user_label_prefix", ",", "unicosmk_ssib_name", "(", ")", ")", ";", "len", "=", "strlen", "(", "fnname", ")", ";", "fprintf", "(", "file", ",", "\"\\t.quad\\t^X20008%2.2X28\\n\"", ",", "len", ")", ";", "fputs", "(", "\"\\t.quad\\t0\\n\"", ",", "file", ")", ";", "fputs", "(", "\"\\t.quad\\t\"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "fnname", ")", ";", "putc", "(", "'\\n'", ",", "file", ")", ";", "fputs", "(", "\"\\t.quad\\t0\\n\"", ",", "file", ")", ";", "fputs", "(", "\"\\t.quad\\t0\\n\"", ",", "file", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "len", ";", "i", "++", ")", "fprintf", "(", "file", ",", "\"\\t.byte\\t%d\\n\"", ",", "(", "int", ")", "(", "fnname", "[", "i", "]", ")", ")", ";", "if", "(", "(", "len", "%", "8", ")", "==", "0", ")", "fputs", "(", "\"\\t.quad\\t0\\n\"", ",", "file", ")", ";", "else", "fprintf", "(", "file", ",", "\"\\t.bits\\t%d : 0\\n\"", ",", "(", "8", "-", "(", "len", "%", "8", ")", ")", "*", "8", ")", ";", "for", "(", "x", "=", "machine", "->", "first_ciw", ";", "x", ";", "x", "=", "XEXP", "(", "x", ",", "1", ")", ")", "{", "ciw", "=", "XEXP", "(", "x", ",", "0", ")", ";", "fprintf", "(", "file", ",", "\"\\t.quad\\t\"", "HOST_WIDE_INT_PRINT_DOUBLE_HEX", "\"\\n\"", ",", "CONST_DOUBLE_HIGH", "(", "ciw", ")", ",", "CONST_DOUBLE_LOW", "(", "ciw", ")", ")", ";", "fprintf", "(", "file", ",", "\"\\t.quad\\t\"", "HOST_WIDE_INT_PRINT_HEX", "\"\\n\"", ",", "INTVAL", "(", "ciw", ")", ")", ";", "}", "}", "</s>"], "natrual_language": ["Output", "the", "static", "subroutine", "information", "block", "for", "the", "current", "function", "."], "TS_V_token": ["alpha", "\"\\t.endp\\n\\n\\t.psect\\t%s%s,data\\n\"", "\"\\t.quad\\t^X20008%2.2X28\\n\"", "\"\\t.quad\\t0\\n\"", "\"\\t.quad\\t\"", "\"\\t.quad\\t0\\n\"", "\"\\t.quad\\t0\\n\"", "0", "\"\\t.byte\\t%d\\n\"", "8", "0", "\"\\t.quad\\t0\\n\"", "\"\\t.bits\\t%d : 0\\n\"", "8", "8", "8", "1", "0", "\"\\t.quad\\t\"", "\"\\n\"", "\"\\t.quad\\t\"", "\"\\n\""], "File": "alpha3", "Func": "unicosmk_output_ssib", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40652, "Length": 241}
{"ground_truth": ["<s>", "static", "int", "unicosmk_special_name", "(", "const", "char", "*", "name", ")", "{", "if", "(", "name", "[", "0", "]", "==", "'*'", ")", "++", "name", ";", "if", "(", "name", "[", "0", "]", "==", "'$'", ")", "++", "name", ";", "if", "(", "name", "[", "0", "]", "!=", "'r'", "&&", "name", "[", "0", "]", "!=", "'f'", "&&", "name", "[", "0", "]", "!=", "'R'", "&&", "name", "[", "0", "]", "!=", "'F'", ")", "return", "0", ";", "switch", "(", "name", "[", "1", "]", ")", "{", "case", "'1'", ":", "case", "'2'", ":", "return", "(", "name", "[", "2", "]", "==", "'\\0'", "||", "(", "ISDIGIT", "(", "name", "[", "2", "]", ")", "&&", "name", "[", "3", "]", "==", "'\\0'", ")", ")", ";", "case", "'3'", ":", "return", "(", "name", "[", "2", "]", "==", "'\\0'", "||", "(", "(", "name", "[", "2", "]", "==", "'0'", "||", "name", "[", "2", "]", "==", "'1'", ")", "&&", "name", "[", "3", "]", "==", "'\\0'", ")", ")", ";", "default", ":", "return", "(", "ISDIGIT", "(", "name", "[", "1", "]", ")", "&&", "name", "[", "2", "]", "==", "'\\0'", ")", ";", "}", "}", "</s>"], "natrual_language": ["Check", "if", "NAME", "must", "be", "replaced", "by", "a", "DEX", "expression", "."], "TS_V_token": ["alpha", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "3", "2", "2", "2", "3", "1", "2"], "File": "alpha3", "Func": "unicosmk_special_name", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40653, "Length": 168}
{"ground_truth": ["<s>", "static", "const", "char", "*", "unicosmk_ssib_name", "(", "void", ")", "{", "static", "char", "name", "[", "256", "]", ";", "rtx", "x", ";", "const", "char", "*", "fnname", ";", "int", "len", ";", "x", "=", "DECL_RTL", "(", "cfun", "->", "decl", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "==", "MEM", ")", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", ";", "fnname", "=", "XSTR", "(", "x", ",", "0", ")", ";", "len", "=", "strlen", "(", "fnname", ")", ";", "if", "(", "len", "+", "SSIB_PREFIX_LEN", ">", "255", ")", "len", "=", "255", "-", "SSIB_PREFIX_LEN", ";", "strcpy", "(", "name", ",", "SSIB_PREFIX", ")", ";", "strncpy", "(", "name", "+", "SSIB_PREFIX_LEN", ",", "fnname", ",", "len", ")", ";", "name", "[", "len", "+", "SSIB_PREFIX_LEN", "]", "=", "0", ";", "return", "name", ";", "}", "</s>"], "natrual_language": ["Generate", "the", "name", "of", "the", "SSIB", "section", "for", "the", "current", "function", "."], "TS_V_token": ["alpha", "256", "0", "0", "255", "255", "0"], "File": "alpha3", "Func": "unicosmk_ssib_name", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40654, "Length": 126}
{"ground_truth": ["<s>", "static", "void", "unicosmk_unique_section", "(", "tree", "decl", ",", "int", "reloc", "ATTRIBUTE_UNUSED", ")", "{", "const", "char", "*", "name", ";", "int", "len", ";", "gcc_assert", "(", "decl", ")", ";", "name", "=", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ";", "name", "=", "default_strip_name_encoding", "(", "name", ")", ";", "len", "=", "strlen", "(", "name", ")", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "{", "char", "*", "string", ";", "string", "=", "alloca", "(", "len", "+", "6", ")", ";", "sprintf", "(", "string", ",", "\"code@%s\"", ",", "name", ")", ";", "DECL_SECTION_NAME", "(", "decl", ")", "=", "build_string", "(", "len", "+", "5", ",", "string", ")", ";", "}", "else", "if", "(", "TREE_PUBLIC", "(", "decl", ")", ")", "DECL_SECTION_NAME", "(", "decl", ")", "=", "build_string", "(", "len", ",", "name", ")", ";", "else", "{", "char", "*", "string", ";", "string", "=", "alloca", "(", "len", "+", "6", ")", ";", "sprintf", "(", "string", ",", "\"data@%s\"", ",", "name", ")", ";", "DECL_SECTION_NAME", "(", "decl", ")", "=", "build_string", "(", "len", "+", "5", ",", "string", ")", ";", "}", "}", "</s>"], "natrual_language": ["Generate", "a", "section", "name", "for", "decl", "and", "associate", "it", "with", "the", "declaration", "."], "TS_V_token": ["alpha", "6", "\"code@%s\"", "5", "6", "\"data@%s\"", "5"], "File": "alpha3", "Func": "unicosmk_unique_section", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40655, "Length": 156}
{"ground_truth": ["<s>", "static", "tree", "va_list_skip_additions", "(", "tree", "lhs", ")", "{", "tree", "rhs", ",", "stmt", ";", "if", "(", "TREE_CODE", "(", "lhs", ")", "!=", "SSA_NAME", ")", "return", "lhs", ";", "for", "(", ";", ";", ")", "{", "stmt", "=", "SSA_NAME_DEF_STMT", "(", "lhs", ")", ";", "if", "(", "TREE_CODE", "(", "stmt", ")", "==", "PHI_NODE", ")", "return", "stmt", ";", "if", "(", "TREE_CODE", "(", "stmt", ")", "!=", "MODIFY_EXPR", "||", "TREE_OPERAND", "(", "stmt", ",", "0", ")", "!=", "lhs", ")", "return", "lhs", ";", "rhs", "=", "TREE_OPERAND", "(", "stmt", ",", "1", ")", ";", "if", "(", "TREE_CODE", "(", "rhs", ")", "==", "WITH_SIZE_EXPR", ")", "rhs", "=", "TREE_OPERAND", "(", "rhs", ",", "0", ")", ";", "if", "(", "(", "TREE_CODE", "(", "rhs", ")", "!=", "NOP_EXPR", "&&", "TREE_CODE", "(", "rhs", ")", "!=", "CONVERT_EXPR", "&&", "(", "TREE_CODE", "(", "rhs", ")", "!=", "PLUS_EXPR", "||", "TREE_CODE", "(", "TREE_OPERAND", "(", "rhs", ",", "1", ")", ")", "!=", "INTEGER_CST", "||", "!", "host_integerp", "(", "TREE_OPERAND", "(", "rhs", ",", "1", ")", ",", "1", ")", ")", ")", "||", "TREE_CODE", "(", "TREE_OPERAND", "(", "rhs", ",", "0", ")", ")", "!=", "SSA_NAME", ")", "return", "rhs", ";", "lhs", "=", "TREE_OPERAND", "(", "rhs", ",", "0", ")", ";", "}", "}", "</s>"], "natrual_language": ["Helper", "function", "for", "alpha_stdarg_optimize_hook", ".", "Skip", "over", "casts", "and", "constant", "additions", "."], "TS_V_token": ["alpha", "0", "1", "0", "1", "1", "1", "0", "0"], "File": "alpha3", "Func": "va_list_skip_additions", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40656, "Length": 176}
{"ground_truth": ["<s>", "static", "void", "vms_asm_named_section", "(", "const", "char", "*", "name", ",", "unsigned", "int", "flags", ",", "tree", "decl", "ATTRIBUTE_UNUSED", ")", "{", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "fprintf", "(", "asm_out_file", ",", "\".section\\t%s\"", ",", "name", ")", ";", "if", "(", "flags", "&", "SECTION_VMS_OVERLAY", ")", "fprintf", "(", "asm_out_file", ",", "\",OVR\"", ")", ";", "if", "(", "flags", "&", "SECTION_VMS_GLOBAL", ")", "fprintf", "(", "asm_out_file", ",", "\",GBL\"", ")", ";", "if", "(", "flags", "&", "SECTION_VMS_INITIALIZE", ")", "fprintf", "(", "asm_out_file", ",", "\",NOMOD\"", ")", ";", "if", "(", "flags", "&", "SECTION_DEBUG", ")", "fprintf", "(", "asm_out_file", ",", "\",NOWRT\"", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "}", "</s>"], "natrual_language": ["Switch", "to", "an", "arbitrary", "section", "NAME", "with", "attributes", "as", "specified", "by", "FLAGS", ".", "ALIGN", "specifies", "any", "known", "alignment", "requirements", "for", "the", "section", ";", "0", "if", "the", "default", "should", "be", "used", "."], "TS_V_token": ["alpha", "\".section\\t%s\"", "\",OVR\"", "\",GBL\"", "\",NOMOD\"", "\",NOWRT\""], "File": "alpha3", "Func": "vms_asm_named_section", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40657, "Length": 94}
{"ground_truth": ["<s>", "static", "void", "vms_asm_out_constructor", "(", "rtx", "symbol", ",", "int", "priority", "ATTRIBUTE_UNUSED", ")", "{", "ctors_section", "(", ")", ";", "assemble_align", "(", "BITS_PER_WORD", ")", ";", "assemble_integer", "(", "symbol", ",", "UNITS_PER_WORD", ",", "BITS_PER_WORD", ",", "1", ")", ";", "}", "</s>"], "natrual_language": ["Record", "an", "element", "in", "the", "table", "of", "global", "constructors", ".", "SYMBOL", "is", "a", "SYMBOL_REF", "of", "the", "function", "to", "be", "called", ";", "PRIORITY", "is", "a", "number", "between", "0", "and", "MAX_INIT_PRIORITY", ".", "Differs", "from", "default_ctors_section_asm_out_constructor", "in", "that", "the", "width", "of", "the", ".ctors", "entry", "is", "always", "64", "bits", ",", "rather", "than", "the", "32", "bits", "used", "by", "a", "normal", "pointer", "."], "TS_V_token": ["alpha", "1"], "File": "alpha3", "Func": "vms_asm_out_constructor", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40658, "Length": 33}
{"ground_truth": ["<s>", "static", "int", "alpha_adjust_cost", "(", "rtx_insn", "*", "insn", ",", "rtx", "link", ",", "rtx_insn", "*", "dep_insn", ",", "int", "cost", ")", "{", "enum", "attr_type", "dep_insn_type", ";", "if", "(", "REG_NOTE_KIND", "(", "link", ")", "!=", "0", ")", "return", "cost", ";", "if", "(", "recog_memoized", "(", "insn", ")", "<", "0", "||", "recog_memoized", "(", "dep_insn", ")", "<", "0", ")", "return", "cost", ";", "dep_insn_type", "=", "get_attr_type", "(", "dep_insn", ")", ";", "if", "(", "dep_insn_type", "==", "TYPE_ILD", "||", "dep_insn_type", "==", "TYPE_FLD", "||", "dep_insn_type", "==", "TYPE_LDSYM", ")", "cost", "+=", "alpha_memory_latency", "-", "1", ";", "return", "cost", ";", "}", "</s>"], "natrual_language": ["Adjust", "the", "cost", "of", "a", "scheduling", "dependency", ".", "Return", "the", "new", "cost", "of", "a", "dependency", "LINK", "or", "INSN", "on", "DEP_INSN", ".", "COST", "is", "the", "current", "cost", "."], "TS_V_token": ["alpha", "0", "0", "0", "1"], "File": "alpha4", "Func": "alpha_adjust_cost", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40659, "Length": 85}
{"ground_truth": ["<s>", "static", "void", "alpha_align_insns_1", "(", "unsigned", "int", "max_align", ",", "rtx_insn", "*", "(", "*", "next_group", ")", "(", "rtx_insn", "*", ",", "int", "*", ",", "int", "*", ")", ",", "rtx", "(", "*", "next_nop", ")", "(", "int", "*", ")", ")", "{", "unsigned", "int", "align", ";", "int", "ofs", ";", "int", "prev_in_use", ",", "in_use", ",", "len", ",", "ldgp", ";", "rtx_insn", "*", "i", ",", "*", "next", ";", "shorten_branches", "(", "get_insns", "(", ")", ")", ";", "if", "(", "align_functions", "<", "4", ")", "align", "=", "4", ";", "else", "if", "(", "(", "unsigned", "int", ")", "align_functions", "<", "max_align", ")", "align", "=", "align_functions", ";", "else", "align", "=", "max_align", ";", "ofs", "=", "prev_in_use", "=", "0", ";", "i", "=", "get_insns", "(", ")", ";", "if", "(", "NOTE_P", "(", "i", ")", ")", "i", "=", "next_nonnote_insn", "(", "i", ")", ";", "ldgp", "=", "alpha_function_needs_gp", "?", "8", ":", "0", ";", "while", "(", "i", ")", "{", "next", "=", "(", "*", "next_group", ")", "(", "i", ",", "&", "in_use", ",", "&", "len", ")", ";", "if", "(", "LABEL_P", "(", "i", ")", ")", "{", "unsigned", "int", "new_align", "=", "1", "<<", "label_to_alignment", "(", "i", ")", ";", "if", "(", "new_align", ">=", "align", ")", "{", "align", "=", "new_align", "<", "max_align", "?", "new_align", ":", "max_align", ";", "ofs", "=", "0", ";", "}", "else", "if", "(", "ofs", "&", "(", "new_align", "-", "1", ")", ")", "ofs", "=", "(", "ofs", "|", "(", "new_align", "-", "1", ")", ")", "+", "1", ";", "gcc_assert", "(", "!", "len", ")", ";", "}", "else", "if", "(", "in_use", "==", "0", ")", "{", "if", "(", "len", "<", "0", ")", "{", "ofs", "=", "0", ";", "align", "=", "4", ";", "len", "=", "0", ";", "}", "}", "else", "if", "(", "(", "int", ")", "align", "<", "len", ")", "{", "unsigned", "int", "new_log_align", "=", "len", ">", "8", "?", "4", ":", "3", ";", "rtx_insn", "*", "prev", ",", "*", "where", ";", "where", "=", "prev", "=", "prev_nonnote_insn", "(", "i", ")", ";", "if", "(", "!", "where", "||", "!", "LABEL_P", "(", "where", ")", ")", "where", "=", "i", ";", "if", "(", "!", "(", "TARGET_EXPLICIT_RELOCS", "&&", "prev", "&&", "CALL_P", "(", "prev", ")", ")", ")", "{", "emit_insn_before", "(", "gen_realign", "(", "GEN_INT", "(", "new_log_align", ")", ")", ",", "where", ")", ";", "align", "=", "1", "<<", "new_log_align", ";", "ofs", "=", "0", ";", "}", "}", "else", "if", "(", "ldgp", ">", "0", ")", "ldgp", "-=", "len", ";", "else", "if", "(", "ofs", "+", "len", ">", "(", "int", ")", "align", ")", "{", "int", "nop_count", "=", "(", "align", "-", "ofs", ")", "/", "4", ";", "rtx_insn", "*", "where", ";", "where", "=", "prev_nonnote_insn", "(", "i", ")", ";", "if", "(", "where", ")", "{", "if", "(", "LABEL_P", "(", "where", ")", ")", "{", "rtx_insn", "*", "where2", "=", "prev_nonnote_insn", "(", "where", ")", ";", "if", "(", "where2", "&&", "JUMP_P", "(", "where2", ")", ")", "where", "=", "where2", ";", "}", "else", "if", "(", "NONJUMP_INSN_P", "(", "where", ")", ")", "where", "=", "i", ";", "}", "else", "where", "=", "i", ";", "do", "emit_insn_before", "(", "(", "*", "next_nop", ")", "(", "&", "prev_in_use", ")", ",", "where", ")", ";", "while", "(", "--", "nop_count", ")", ";", "ofs", "=", "0", ";", "}", "ofs", "=", "(", "ofs", "+", "len", ")", "&", "(", "align", "-", "1", ")", ";", "prev_in_use", "=", "in_use", ";", "i", "=", "next", ";", "}", "}", "</s>"], "natrual_language": ["The", "instruction", "group", "alignment", "main", "loop", "."], "TS_V_token": ["alpha", "4", "4", "0", "8", "0", "1", "0", "1", "1", "1", "0", "0", "0", "4", "0", "8", "4", "3", "1", "0", "0", "4", "0", "1"], "File": "alpha4", "Func": "alpha_align_insns_1", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40660, "Length": 497}
{"ground_truth": ["<s>", "enum", "avms_arg_type", "alpha_arg_type", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "SFmode", ":", "return", "TARGET_FLOAT_VAX", "?", "FF", ":", "FS", ";", "case", "DFmode", ":", "return", "TARGET_FLOAT_VAX", "?", "FD", ":", "FT", ";", "default", ":", "return", "I64", ";", "}", "}", "</s>"], "natrual_language": ["Return", "the", "VMS", "argument", "type", "corresponding", "to", "MODE", "."], "TS_V_token": ["alpha"], "File": "alpha4", "Func": "alpha_arg_type", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40661, "Length": 40}
{"ground_truth": ["<s>", "static", "void", "alpha_atomic_assign_expand_fenv", "(", "tree", "*", "hold", ",", "tree", "*", "clear", ",", "tree", "*", "update", ")", "{", "const", "unsigned", "HOST_WIDE_INT", "SWCR_STATUS_MASK", "=", "(", "0x3fUL", "<<", "17", ")", ";", "tree", "fenv_var", ",", "get_fpscr", ",", "set_fpscr", ",", "mask", ",", "ld_fenv", ",", "masked_fenv", ";", "tree", "new_fenv_var", ",", "reload_fenv", ",", "restore_fnenv", ";", "tree", "update_call", ",", "atomic_feraiseexcept", ",", "hold_fnclex", ";", "if", "(", "!", "TARGET_ABI_OSF", ")", "return", ";", "fenv_var", "=", "create_tmp_var", "(", "long_unsigned_type_node", ")", ";", "get_fpscr", "=", "build_fn_decl", "(", "\"__ieee_get_fp_control\"", ",", "build_function_type_list", "(", "long_unsigned_type_node", ",", "NULL", ")", ")", ";", "set_fpscr", "=", "build_fn_decl", "(", "\"__ieee_set_fp_control\"", ",", "build_function_type_list", "(", "void_type_node", ",", "NULL", ")", ")", ";", "mask", "=", "build_int_cst", "(", "long_unsigned_type_node", ",", "~", "SWCR_STATUS_MASK", ")", ";", "ld_fenv", "=", "build2", "(", "MODIFY_EXPR", ",", "long_unsigned_type_node", ",", "fenv_var", ",", "build_call_expr", "(", "get_fpscr", ",", "0", ")", ")", ";", "masked_fenv", "=", "build2", "(", "BIT_AND_EXPR", ",", "long_unsigned_type_node", ",", "fenv_var", ",", "mask", ")", ";", "hold_fnclex", "=", "build_call_expr", "(", "set_fpscr", ",", "1", ",", "masked_fenv", ")", ";", "*", "hold", "=", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "masked_fenv", ",", "ld_fenv", ")", ",", "hold_fnclex", ")", ";", "*", "clear", "=", "build_call_expr", "(", "set_fpscr", ",", "1", ",", "masked_fenv", ")", ";", "new_fenv_var", "=", "create_tmp_var", "(", "long_unsigned_type_node", ")", ";", "reload_fenv", "=", "build2", "(", "MODIFY_EXPR", ",", "long_unsigned_type_node", ",", "new_fenv_var", ",", "build_call_expr", "(", "get_fpscr", ",", "0", ")", ")", ";", "restore_fnenv", "=", "build_call_expr", "(", "set_fpscr", ",", "1", ",", "fenv_var", ")", ";", "atomic_feraiseexcept", "=", "builtin_decl_implicit", "(", "BUILT_IN_ATOMIC_FERAISEEXCEPT", ")", ";", "update_call", "=", "build_call_expr", "(", "atomic_feraiseexcept", ",", "1", ",", "fold_convert", "(", "integer_type_node", ",", "new_fenv_var", ")", ")", ";", "*", "update", "=", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "reload_fenv", ",", "restore_fnenv", ")", ",", "update_call", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_ATOMIC_ASSIGN_EXPAND_FENV", "."], "TS_V_token": ["alpha", "0x3fUL", "17", "\"__ieee_get_fp_control\"", "\"__ieee_set_fp_control\"", "0", "1", "1", "0", "1", "1"], "File": "alpha4", "Func": "alpha_atomic_assign_expand_fenv", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40662, "Length": 267}
{"ground_truth": ["<s>", "static", "void", "alpha_canonicalize_comparison", "(", "int", "*", "code", ",", "rtx", "*", "op0", ",", "rtx", "*", "op1", ",", "bool", "op0_preserve_value", ")", "{", "if", "(", "!", "op0_preserve_value", "&&", "(", "*", "code", "==", "GE", "||", "*", "code", "==", "GT", "||", "*", "code", "==", "GEU", "||", "*", "code", "==", "GTU", ")", "&&", "(", "REG_P", "(", "*", "op1", ")", "||", "*", "op1", "==", "const0_rtx", ")", ")", "{", "rtx", "tem", "=", "*", "op0", ";", "*", "op0", "=", "*", "op1", ";", "*", "op1", "=", "tem", ";", "*", "code", "=", "(", "int", ")", "swap_condition", "(", "(", "enum", "rtx_code", ")", "*", "code", ")", ";", "}", "if", "(", "(", "*", "code", "==", "LT", "||", "*", "code", "==", "LTU", ")", "&&", "CONST_INT_P", "(", "*", "op1", ")", "&&", "INTVAL", "(", "*", "op1", ")", "==", "256", ")", "{", "*", "code", "=", "*", "code", "==", "LT", "?", "LE", ":", "LEU", ";", "*", "op1", "=", "GEN_INT", "(", "255", ")", ";", "}", "}", "</s>"], "natrual_language": ["Canonicalize", "a", "comparison", "from", "one", "we", "do", "n't", "have", "to", "one", "we", "do", "have", "."], "TS_V_token": ["alpha", "256", "255"], "File": "alpha4", "Func": "alpha_canonicalize_comparison", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40663, "Length": 146}
{"ground_truth": ["<s>", "bool", "alpha_emit_setcc", "(", "rtx", "operands", "[", "]", ",", "machine_mode", "cmp_mode", ")", "{", "enum", "rtx_code", "cmp_code", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "1", "]", ")", ";", "rtx", "op0", "=", "operands", "[", "2", "]", ",", "op1", "=", "operands", "[", "3", "]", ";", "rtx", "tmp", ";", "if", "(", "cmp_mode", "==", "TFmode", ")", "{", "op0", "=", "alpha_emit_xfloating_compare", "(", "&", "code", ",", "op0", ",", "op1", ")", ";", "op1", "=", "const0_rtx", ";", "cmp_mode", "=", "DImode", ";", "}", "if", "(", "cmp_mode", "==", "DFmode", "&&", "!", "TARGET_FIX", ")", "return", "0", ";", "cmp_code", "=", "UNKNOWN", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "LE", ":", "case", "LT", ":", "case", "LEU", ":", "case", "LTU", ":", "case", "UNORDERED", ":", "if", "(", "cmp_mode", "==", "DFmode", ")", "cmp_code", "=", "code", ",", "code", "=", "NE", ";", "break", ";", "case", "NE", ":", "if", "(", "cmp_mode", "==", "DImode", "&&", "op1", "==", "const0_rtx", ")", "break", ";", "case", "ORDERED", ":", "cmp_code", "=", "reverse_condition", "(", "code", ")", ";", "code", "=", "EQ", ";", "break", ";", "case", "GE", ":", "case", "GT", ":", "case", "GEU", ":", "case", "GTU", ":", "if", "(", "cmp_mode", "==", "DImode", "&&", "op1", "==", "const0_rtx", ")", "break", ";", "code", "=", "swap_condition", "(", "code", ")", ";", "if", "(", "cmp_mode", "==", "DFmode", ")", "cmp_code", "=", "code", ",", "code", "=", "NE", ";", "std", "::", "swap", "(", "op0", ",", "op1", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "cmp_mode", "==", "DImode", ")", "{", "if", "(", "!", "register_operand", "(", "op0", ",", "DImode", ")", ")", "op0", "=", "force_reg", "(", "DImode", ",", "op0", ")", ";", "if", "(", "!", "reg_or_8bit_operand", "(", "op1", ",", "DImode", ")", ")", "op1", "=", "force_reg", "(", "DImode", ",", "op1", ")", ";", "}", "if", "(", "cmp_code", "!=", "UNKNOWN", ")", "{", "tmp", "=", "gen_reg_rtx", "(", "cmp_mode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "tmp", ",", "gen_rtx_fmt_ee", "(", "cmp_code", ",", "cmp_mode", ",", "op0", ",", "op1", ")", ")", ")", ";", "op0", "=", "cmp_mode", "!=", "DImode", "?", "gen_lowpart", "(", "DImode", ",", "tmp", ")", ":", "tmp", ";", "op1", "=", "const0_rtx", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "operands", "[", "0", "]", ",", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "op0", ",", "op1", ")", ")", ")", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Certain", "simplifications", "can", "be", "done", "to", "make", "invalid", "setcc", "operations", "valid", ".", "Return", "the", "final", "comparison", ",", "or", "NULL", "if", "we", "ca", "n't", "work", "."], "TS_V_token": ["alpha", "1", "2", "3", "0", "0"], "File": "alpha4", "Func": "alpha_emit_setcc", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40664, "Length": 352}
{"ground_truth": ["<s>", "static", "void", "alpha_emit_xfloating_libcall", "(", "rtx", "func", ",", "rtx", "target", ",", "rtx", "operands", "[", "]", ",", "int", "noperands", ",", "rtx", "equiv", ")", "{", "rtx", "usage", "=", "NULL_RTX", ",", "tmp", ",", "reg", ";", "int", "regno", "=", "16", ",", "i", ";", "start_sequence", "(", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "noperands", ";", "++", "i", ")", "{", "switch", "(", "GET_MODE", "(", "operands", "[", "i", "]", ")", ")", "{", "case", "TFmode", ":", "reg", "=", "gen_rtx_REG", "(", "TFmode", ",", "regno", ")", ";", "regno", "+=", "2", ";", "break", ";", "case", "DFmode", ":", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "regno", "+", "32", ")", ";", "regno", "+=", "1", ";", "break", ";", "case", "VOIDmode", ":", "gcc_assert", "(", "CONST_INT_P", "(", "operands", "[", "i", "]", ")", ")", ";", "case", "DImode", ":", "reg", "=", "gen_rtx_REG", "(", "DImode", ",", "regno", ")", ";", "regno", "+=", "1", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_move_insn", "(", "reg", ",", "operands", "[", "i", "]", ")", ";", "use_reg", "(", "&", "usage", ",", "reg", ")", ";", "}", "switch", "(", "GET_MODE", "(", "target", ")", ")", "{", "case", "TFmode", ":", "reg", "=", "gen_rtx_REG", "(", "TFmode", ",", "16", ")", ";", "break", ";", "case", "DFmode", ":", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "32", ")", ";", "break", ";", "case", "DImode", ":", "reg", "=", "gen_rtx_REG", "(", "DImode", ",", "0", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "tmp", "=", "gen_rtx_MEM", "(", "QImode", ",", "func", ")", ";", "tmp", "=", "emit_call_insn", "(", "GEN_CALL_VALUE", "(", "reg", ",", "tmp", ",", "const0_rtx", ",", "const0_rtx", ",", "const0_rtx", ")", ")", ";", "CALL_INSN_FUNCTION_USAGE", "(", "tmp", ")", "=", "usage", ";", "RTL_CONST_CALL_P", "(", "tmp", ")", "=", "1", ";", "tmp", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "emit_libcall_block", "(", "tmp", ",", "target", ",", "reg", ",", "equiv", ")", ";", "}", "</s>"], "natrual_language": ["Emit", "an", "X_floating", "library", "function", "call", ".", "Note", "that", "these", "functions", "do", "not", "follow", "normal", "calling", "conventions", ":", "TFmode", "arguments", "are", "passed", "in", "two", "integer", "registers", "(", "as", "opposed", "to", "indirect", ")", ";", "TFmode", "return", "values", "appear", "in", "R16+R17", ".", "FUNC", "is", "the", "function", "name", "to", "call", ".", "TARGET", "is", "where", "the", "output", "belongs", ".", "OPERANDS", "are", "the", "inputs", ".", "NOPERANDS", "is", "the", "count", "of", "inputs", ".", "EQUIV", "is", "the", "expression", "equivalent", "for", "the", "function", "."], "TS_V_token": ["alpha", "16", "0", "2", "32", "1", "1", "16", "32", "0", "1"], "File": "alpha4", "Func": "alpha_emit_xfloating_libcall", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40665, "Length": 283}
{"ground_truth": ["<s>", "static", "rtx", "alpha_expand_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "rtx", "subtarget", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "ignore", "ATTRIBUTE_UNUSED", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ";", "unsigned", "int", "fcode", "=", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ";", "tree", "arg", ";", "call_expr_arg_iterator", "iter", ";", "enum", "insn_code", "icode", ";", "rtx", "op", "[", "MAX_ARGS", "]", ",", "pat", ";", "int", "arity", ";", "bool", "nonvoid", ";", "if", "(", "fcode", ">=", "ALPHA_BUILTIN_max", ")", "internal_error", "(", "\"bad builtin fcode\"", ")", ";", "icode", "=", "code_for_builtin", "[", "fcode", "]", ";", "if", "(", "icode", "==", "0", ")", "internal_error", "(", "\"bad builtin fcode\"", ")", ";", "nonvoid", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "fndecl", ")", ")", "!=", "void_type_node", ";", "arity", "=", "0", ";", "FOR_EACH_CALL_EXPR_ARG", "(", "arg", ",", "iter", ",", "exp", ")", "{", "const", "struct", "insn_operand_data", "*", "insn_op", ";", "if", "(", "arg", "==", "error_mark_node", ")", "return", "NULL_RTX", ";", "if", "(", "arity", ">", "MAX_ARGS", ")", "return", "NULL_RTX", ";", "insn_op", "=", "&", "insn_data", "[", "icode", "]", ".", "operand", "[", "arity", "+", "nonvoid", "]", ";", "op", "[", "arity", "]", "=", "expand_expr", "(", "arg", ",", "NULL_RTX", ",", "insn_op", "->", "mode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "(", "*", "insn_op", "->", "predicate", ")", "(", "op", "[", "arity", "]", ",", "insn_op", "->", "mode", ")", ")", "op", "[", "arity", "]", "=", "copy_to_mode_reg", "(", "insn_op", "->", "mode", ",", "op", "[", "arity", "]", ")", ";", "arity", "++", ";", "}", "if", "(", "nonvoid", ")", "{", "machine_mode", "tmode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ";", "if", "(", "!", "target", "||", "GET_MODE", "(", "target", ")", "!=", "tmode", "||", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "predicate", ")", "(", "target", ",", "tmode", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "}", "switch", "(", "arity", ")", "{", "case", "0", ":", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ")", ";", "break", ";", "case", "1", ":", "if", "(", "nonvoid", ")", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op", "[", "0", "]", ")", ";", "else", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "op", "[", "0", "]", ")", ";", "break", ";", "case", "2", ":", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op", "[", "0", "]", ",", "op", "[", "1", "]", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "if", "(", "nonvoid", ")", "return", "target", ";", "else", "return", "const0_rtx", ";", "}", "</s>"], "natrual_language": ["Expand", "an", "expression", "EXP", "that", "calls", "a", "built-in", "function", ",", "with", "result", "going", "to", "TARGET", "if", "that", "'s", "convenient", "(", "and", "in", "mode", "MODE", "if", "that", "'s", "convenient", ")", ".", "SUBTARGET", "may", "be", "used", "as", "the", "target", "for", "computing", "one", "of", "EXP", "'s", "operands", ".", "IGNORE", "is", "nonzero", "if", "the", "value", "is", "to", "be", "ignored", "."], "TS_V_token": ["alpha", "0", "\"bad builtin fcode\"", "0", "\"bad builtin fcode\"", "0", "0", "0", "0", "1", "0", "0", "2", "0", "1"], "File": "alpha4", "Func": "alpha_expand_builtin", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40666, "Length": 397}
{"ground_truth": ["<s>", "bool", "alpha_expand_mov", "(", "machine_mode", "mode", ",", "rtx", "*", "operands", ")", "{", "rtx", "tmp", ";", "if", "(", "MEM_P", "(", "operands", "[", "0", "]", ")", "&&", "!", "reg_or_0_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "operands", "[", "1", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "if", "(", "mode", "==", "Pmode", "&&", "symbolic_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "{", "tmp", "=", "alpha_legitimize_address_1", "(", "operands", "[", "1", "]", ",", "operands", "[", "0", "]", ",", "mode", ")", ";", "if", "(", "tmp", ")", "{", "if", "(", "tmp", "==", "operands", "[", "0", "]", ")", "return", "true", ";", "operands", "[", "1", "]", "=", "tmp", ";", "return", "false", ";", "}", "}", "if", "(", "!", "CONSTANT_P", "(", "operands", "[", "1", "]", ")", "||", "input_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "return", "false", ";", "if", "(", "CONST_INT_P", "(", "operands", "[", "1", "]", ")", "||", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "CONST_DOUBLE", "||", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "CONST_VECTOR", ")", "{", "if", "(", "alpha_split_const_mov", "(", "mode", ",", "operands", ")", ")", "return", "true", ";", "}", "tmp", "=", "force_const_mem", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "if", "(", "tmp", "==", "NULL_RTX", ")", "return", "false", ";", "if", "(", "reload_in_progress", ")", "{", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "XEXP", "(", "tmp", ",", "0", ")", ")", ";", "operands", "[", "1", "]", "=", "replace_equiv_address", "(", "tmp", ",", "operands", "[", "0", "]", ")", ";", "}", "else", "operands", "[", "1", "]", "=", "validize_mem", "(", "tmp", ")", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Expand", "a", "move", "instruction", ";", "return", "true", "if", "all", "work", "is", "done", ".", "We", "do", "n't", "handle", "non-bwx", "subword", "loads", "here", "."], "TS_V_token": ["alpha", "0", "1", "1", "1", "1", "1", "0", "0", "1", "1", "1", "1", "1", "1", "1", "0", "0", "1", "0", "1"], "File": "alpha4", "Func": "alpha_expand_mov", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40667, "Length": 253}
{"ground_truth": ["<s>", "static", "void", "alpha_expand_unaligned_load_words", "(", "rtx", "*", "out_regs", ",", "rtx", "smem", ",", "HOST_WIDE_INT", "words", ",", "HOST_WIDE_INT", "ofs", ")", "{", "rtx", "const", "im8", "=", "GEN_INT", "(", "-", "8", ")", ";", "rtx", "ext_tmps", "[", "MAX_MOVE_WORDS", "]", ",", "data_regs", "[", "MAX_MOVE_WORDS", "+", "1", "]", ";", "rtx", "sreg", ",", "areg", ",", "tmp", ",", "smema", ";", "HOST_WIDE_INT", "i", ";", "smema", "=", "XEXP", "(", "smem", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "smema", ")", "==", "LO_SUM", ")", "smema", "=", "force_reg", "(", "Pmode", ",", "smema", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "words", ";", "++", "i", ")", "{", "data_regs", "[", "i", "]", "=", "out_regs", "[", "i", "]", ";", "ext_tmps", "[", "i", "]", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "}", "data_regs", "[", "words", "]", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "if", "(", "ofs", "!=", "0", ")", "smem", "=", "adjust_address", "(", "smem", ",", "GET_MODE", "(", "smem", ")", ",", "ofs", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "words", ";", "++", "i", ")", "{", "tmp", "=", "change_address", "(", "smem", ",", "DImode", ",", "gen_rtx_AND", "(", "DImode", ",", "plus_constant", "(", "DImode", ",", "smema", ",", "8", "*", "i", ")", ",", "im8", ")", ")", ";", "set_mem_alias_set", "(", "tmp", ",", "0", ")", ";", "emit_move_insn", "(", "data_regs", "[", "i", "]", ",", "tmp", ")", ";", "}", "tmp", "=", "change_address", "(", "smem", ",", "DImode", ",", "gen_rtx_AND", "(", "DImode", ",", "plus_constant", "(", "DImode", ",", "smema", ",", "8", "*", "words", "-", "1", ")", ",", "im8", ")", ")", ";", "set_mem_alias_set", "(", "tmp", ",", "0", ")", ";", "emit_move_insn", "(", "data_regs", "[", "words", "]", ",", "tmp", ")", ";", "sreg", "=", "copy_addr_to_reg", "(", "smema", ")", ";", "areg", "=", "expand_binop", "(", "DImode", ",", "and_optab", ",", "sreg", ",", "GEN_INT", "(", "7", ")", ",", "NULL", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "words", ";", "++", "i", ")", "{", "emit_insn", "(", "gen_extql", "(", "data_regs", "[", "i", "]", ",", "data_regs", "[", "i", "]", ",", "sreg", ")", ")", ";", "emit_insn", "(", "gen_extqh", "(", "ext_tmps", "[", "i", "]", ",", "data_regs", "[", "i", "+", "1", "]", ",", "sreg", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "ext_tmps", "[", "i", "]", ",", "gen_rtx_IF_THEN_ELSE", "(", "DImode", ",", "gen_rtx_EQ", "(", "DImode", ",", "areg", ",", "const0_rtx", ")", ",", "const0_rtx", ",", "ext_tmps", "[", "i", "]", ")", ")", ")", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "words", ";", "++", "i", ")", "{", "out_regs", "[", "i", "]", "=", "expand_binop", "(", "DImode", ",", "ior_optab", ",", "data_regs", "[", "i", "]", ",", "ext_tmps", "[", "i", "]", ",", "data_regs", "[", "i", "]", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "}", "}", "</s>"], "natrual_language": ["Load", "an", "integral", "number", "of", "consecutive", "unaligned", "quadwords", "."], "TS_V_token": ["alpha", "8", "1", "0", "0", "0", "0", "8", "0", "8", "1", "0", "7", "1", "0", "1", "0", "1"], "File": "alpha4", "Func": "alpha_expand_unaligned_load_words", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40668, "Length": 413}
{"ground_truth": ["<s>", "static", "void", "alpha_extract_integer", "(", "rtx", "x", ",", "HOST_WIDE_INT", "*", "p0", ",", "HOST_WIDE_INT", "*", "p1", ")", "{", "HOST_WIDE_INT", "i0", ",", "i1", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_VECTOR", ")", "x", "=", "simplify_subreg", "(", "DImode", ",", "x", ",", "GET_MODE", "(", "x", ")", ",", "0", ")", ";", "if", "(", "CONST_INT_P", "(", "x", ")", ")", "{", "i0", "=", "INTVAL", "(", "x", ")", ";", "i1", "=", "-", "(", "i0", "<", "0", ")", ";", "}", "else", "if", "(", "HOST_BITS_PER_WIDE_INT", ">=", "64", ")", "{", "i0", "=", "CONST_DOUBLE_LOW", "(", "x", ")", ";", "i1", "=", "-", "(", "i0", "<", "0", ")", ";", "}", "else", "{", "i0", "=", "CONST_DOUBLE_LOW", "(", "x", ")", ";", "i1", "=", "CONST_DOUBLE_HIGH", "(", "x", ")", ";", "}", "*", "p0", "=", "i0", ";", "*", "p1", "=", "i1", ";", "}", "</s>"], "natrual_language": ["Given", "an", "integral", "CONST_INT", ",", "CONST_DOUBLE", ",", "or", "CONST_VECTOR", ",", "return", "the", "low", "64", "bits", "."], "TS_V_token": ["alpha", "0", "0", "64", "0"], "File": "alpha4", "Func": "alpha_extract_integer", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40669, "Length": 124}
{"ground_truth": ["<s>", "static", "rtx", "alpha_function_arg", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "basereg", ";", "int", "num_args", ";", "if", "(", "type", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "basereg", "=", "16", ";", "else", "{", "gcc_assert", "(", "!", "COMPLEX_MODE_P", "(", "mode", ")", ")", ";", "if", "(", "TARGET_FPREGS", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", "basereg", "=", "32", "+", "16", ";", "else", "basereg", "=", "16", ";", "}", "{", "if", "(", "mode", "==", "VOIDmode", ")", "return", "alpha_arg_info_reg_val", "(", "*", "cum", ")", ";", "num_args", "=", "cum", "->", "num_args", ";", "if", "(", "num_args", ">=", "6", "||", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "return", "NULL_RTX", ";", "}", "{", "if", "(", "*", "cum", ">=", "6", ")", "return", "NULL_RTX", ";", "num_args", "=", "*", "cum", ";", "if", "(", "type", "==", "void_type_node", ")", "basereg", "=", "16", ";", "else", "if", "(", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "return", "NULL_RTX", ";", "}", "return", "gen_rtx_REG", "(", "mode", ",", "num_args", "+", "basereg", ")", ";", "}", "</s>"], "natrual_language": ["Determine", "where", "to", "put", "an", "argument", "to", "a", "function", ".", "Value", "is", "zero", "to", "push", "the", "argument", "on", "the", "stack", ",", "or", "a", "hard", "register", "in", "which", "to", "store", "the", "argument", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "CUM", "is", "a", "variable", "of", "type", "CUMULATIVE_ARGS", "which", "gives", "info", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "NAMED", "is", "nonzero", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", ".", "On", "Alpha", "the", "first", "6", "words", "of", "args", "are", "normally", "in", "registers", "and", "the", "rest", "are", "pushed", "."], "TS_V_token": ["alpha", "16", "32", "16", "16", "6", "6", "16"], "File": "alpha4", "Func": "alpha_function_arg", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40670, "Length": 176}
{"ground_truth": ["<s>", "static", "void", "alpha_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", ")", ";", "bool", "onstack", "=", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ";", "int", "increment", "=", "onstack", "?", "6", ":", "ALPHA_ARG_SIZE", "(", "mode", ",", "type", ",", "named", ")", ";", "*", "cum", "+=", "increment", ";", "if", "(", "!", "onstack", "&&", "cum", "->", "num_args", "<", "6", ")", "cum", "->", "atypes", "[", "cum", "->", "num_args", "]", "=", "alpha_arg_type", "(", "mode", ")", ";", "cum", "->", "num_args", "+=", "increment", ";", "}", "</s>"], "natrual_language": ["Update", "the", "data", "in", "CUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "(", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", ")"], "TS_V_token": ["alpha", "6", "6"], "File": "alpha4", "Func": "alpha_function_arg_advance", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40671, "Length": 94}
{"ground_truth": ["<s>", "HOST_WIDE_INT", "alpha_initial_elimination_offset", "(", "unsigned", "int", "from", ",", "unsigned", "int", "to", "ATTRIBUTE_UNUSED", ")", "{", "HOST_WIDE_INT", "ret", ";", "ret", "=", "alpha_sa_size", "(", ")", ";", "ret", "+=", "ALPHA_ROUND", "(", "crtl", "->", "outgoing_args_size", ")", ";", "switch", "(", "from", ")", "{", "case", "FRAME_POINTER_REGNUM", ":", "break", ";", "case", "ARG_POINTER_REGNUM", ":", "ret", "+=", "(", "ALPHA_ROUND", "(", "get_frame_size", "(", ")", "+", "crtl", "->", "args", ".", "pretend_args_size", ")", "-", "crtl", "->", "args", ".", "pretend_args_size", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "ret", ";", "}", "</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": ["alpha"], "File": "alpha4", "Func": "alpha_initial_elimination_offset", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40672, "Length": 80}
{"ground_truth": ["<s>", "static", "bool", "alpha_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "strict", ")", "{", "if", "(", "mode", "==", "DImode", "&&", "GET_CODE", "(", "x", ")", "==", "AND", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "-", "8", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SUBREG", "&&", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", "<", "GET_MODE_SIZE", "(", "GET_MODE", "(", "SUBREG_REG", "(", "x", ")", ")", ")", ")", ")", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "if", "(", "REG_P", "(", "x", ")", "&&", "(", "strict", "?", "STRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ":", "NONSTRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ")", ")", "return", "true", ";", "if", "(", "CONSTANT_ADDRESS_P", "(", "x", ")", ")", "return", "true", ";", "if", "(", "LINKAGE_SYMBOL_REF_P", "(", "x", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "rtx", "ofs", "=", "XEXP", "(", "x", ",", "1", ")", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SUBREG", "&&", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", "<", "GET_MODE_SIZE", "(", "GET_MODE", "(", "SUBREG_REG", "(", "x", ")", ")", ")", ")", ")", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "if", "(", "REG_P", "(", "x", ")", ")", "{", "if", "(", "!", "strict", "&&", "NONSTRICT_REG_OK_FP_BASE_P", "(", "x", ")", "&&", "CONST_INT_P", "(", "ofs", ")", ")", "return", "true", ";", "if", "(", "(", "strict", "?", "STRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ":", "NONSTRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ")", "&&", "CONSTANT_ADDRESS_P", "(", "ofs", ")", ")", "return", "true", ";", "}", "}", "else", "if", "(", "TARGET_EXPLICIT_RELOCS", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_WORD", ")", "{", "if", "(", "small_symbolic_operand", "(", "x", ",", "Pmode", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "LO_SUM", ")", "{", "rtx", "ofs", "=", "XEXP", "(", "x", ",", "1", ")", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SUBREG", "&&", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", "<", "GET_MODE_SIZE", "(", "GET_MODE", "(", "SUBREG_REG", "(", "x", ")", ")", ")", ")", ")", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "if", "(", "!", "(", "REG_P", "(", "x", ")", "&&", "(", "strict", "?", "STRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ":", "NONSTRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ")", ")", ")", "return", "false", ";", "if", "(", "local_symbolic_operand", "(", "ofs", ",", "Pmode", ")", "||", "dtp32_symbolic_operand", "(", "ofs", ",", "Pmode", ")", "||", "tp32_symbolic_operand", "(", "ofs", ",", "Pmode", ")", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["legitimate_address_p", "recognizes", "an", "RTL", "expression", "that", "is", "a", "valid", "memory", "address", "for", "an", "instruction", ".", "The", "MODE", "argument", "is", "the", "machine", "mode", "for", "the", "MEM", "expression", "that", "wants", "to", "use", "this", "address", ".", "For", "Alpha", ",", "we", "have", "either", "a", "constant", "address", "or", "the", "sum", "of", "a", "register", "and", "a", "constant", "address", ",", "or", "just", "a", "register", ".", "For", "DImode", ",", "any", "of", "those", "forms", "can", "be", "surrounded", "with", "an", "AND", "that", "clear", "the", "low-order", "three", "bits", ";", "this", "is", "an", "``", "unaligned", "''", "access", "."], "TS_V_token": ["alpha", "1", "1", "8", "0", "1", "0", "1", "0"], "File": "alpha4", "Func": "alpha_legitimate_address_p", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40673, "Length": 408}
{"ground_truth": ["<s>", "bool", "alpha_legitimate_constant_p", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "HOST_WIDE_INT", "i0", ",", "i1", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "LABEL_REF", ":", "case", "HIGH", ":", "return", "true", ";", "case", "CONST", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", "==", "CONST_INT", ")", "x", "=", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ";", "else", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "SYMBOL_REF", ")", "return", "true", ";", "case", "SYMBOL_REF", ":", "return", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "==", "0", ";", "case", "CONST_DOUBLE", ":", "if", "(", "x", "==", "CONST0_RTX", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", ")", "return", "false", ";", "goto", "do_integer", ";", "case", "CONST_VECTOR", ":", "if", "(", "x", "==", "CONST0_RTX", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_VECTOR_INT", ")", "return", "false", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "!=", "8", ")", "return", "false", ";", "goto", "do_integer", ";", "case", "CONST_INT", ":", "do_integer", ":", "if", "(", "TARGET_BUILD_CONSTANTS", ")", "return", "true", ";", "alpha_extract_integer", "(", "x", ",", "&", "i0", ",", "&", "i1", ")", ";", "if", "(", "HOST_BITS_PER_WIDE_INT", ">=", "64", "||", "i1", "==", "(", "-", "i0", "<", "0", ")", ")", "return", "alpha_emit_set_const_1", "(", "x", ",", "mode", ",", "i0", ",", "3", ",", "true", ")", "!=", "NULL", ";", "return", "false", ";", "default", ":", "return", "false", ";", "}", "}", "</s>"], "natrual_language": ["Implement", "LEGITIMATE_CONSTANT_P", ".", "This", "is", "all", "constants", "for", "which", "we", "are", "willing", "to", "load", "the", "value", "into", "a", "register", "via", "a", "move", "pattern", ".", "Normally", "this", "is", "all", "symbolic", "constants", ",", "integral", "constants", "that", "take", "three", "or", "fewer", "instructions", ",", "and", "floating-point", "zero", "."], "TS_V_token": ["alpha", "0", "0", "1", "0", "0", "0", "8", "64", "0", "3"], "File": "alpha4", "Func": "alpha_legitimate_constant_p", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40674, "Length": 241}
{"ground_truth": ["<s>", "rtx", "alpha_legitimize_reload_address", "(", "rtx", "x", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "opnum", ",", "int", "type", ",", "int", "ind_levels", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "push_reload", "(", "XEXP", "(", "x", ",", "0", ")", ",", "NULL_RTX", ",", "&", "XEXP", "(", "x", ",", "0", ")", ",", "NULL", ",", "BASE_REG_CLASS", ",", "GET_MODE", "(", "x", ")", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "(", "enum", "reload_type", ")", "type", ")", ";", "return", "x", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "<", "FIRST_PSEUDO_REGISTER", "&&", "REGNO_OK_FOR_BASE_P", "(", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "{", "HOST_WIDE_INT", "val", "=", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ";", "HOST_WIDE_INT", "low", "=", "(", "(", "val", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "HOST_WIDE_INT", "high", "=", "(", "(", "(", "val", "-", "low", ")", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "if", "(", "high", "+", "low", "!=", "val", ")", "return", "NULL_RTX", ";", "x", "=", "gen_rtx_PLUS", "(", "GET_MODE", "(", "x", ")", ",", "gen_rtx_PLUS", "(", "GET_MODE", "(", "x", ")", ",", "XEXP", "(", "x", ",", "0", ")", ",", "GEN_INT", "(", "high", ")", ")", ",", "GEN_INT", "(", "low", ")", ")", ";", "push_reload", "(", "XEXP", "(", "x", ",", "0", ")", ",", "NULL_RTX", ",", "&", "XEXP", "(", "x", ",", "0", ")", ",", "NULL", ",", "BASE_REG_CLASS", ",", "GET_MODE", "(", "x", ")", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "(", "enum", "reload_type", ")", "type", ")", ";", "return", "x", ";", "}", "return", "NULL_RTX", ";", "}", "</s>"], "natrual_language": ["Try", "a", "machine-dependent", "way", "of", "reloading", "an", "illegitimate", "address", "operand", ".", "If", "we", "find", "one", ",", "push", "the", "reload", "and", "return", "the", "new", "rtx", "."], "TS_V_token": ["alpha", "0", "0", "0", "0", "1", "1", "0", "0", "0", "0", "0", "0", "0", "1", "1", "0xffff", "0x8000", "0x8000", "0xffffffff", "0x80000000", "0x80000000", "0", "0", "0", "0", "0"], "File": "alpha4", "Func": "alpha_legitimize_reload_address", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40675, "Length": 331}
{"ground_truth": ["<s>", "static", "void", "alpha_output_mi_thunk_osf", "(", "FILE", "*", "file", ",", "tree", "thunk_fndecl", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "HOST_WIDE_INT", "hi", ",", "lo", ";", "rtx", "this_rtx", ",", "funexp", ";", "rtx_insn", "*", "insn", ";", "emit_insn", "(", "gen_prologue_ldgp", "(", ")", ")", ";", "emit_note", "(", "NOTE_INSN_PROLOGUE_END", ")", ";", "if", "(", "aggregate_value_p", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "function", ")", ")", ",", "function", ")", ")", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "17", ")", ";", "else", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "16", ")", ";", "lo", "=", "(", "(", "delta", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "hi", "=", "(", "(", "(", "delta", "-", "lo", ")", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "if", "(", "hi", "+", "lo", "==", "delta", ")", "{", "if", "(", "hi", ")", "emit_insn", "(", "gen_adddi3", "(", "this_rtx", ",", "this_rtx", ",", "GEN_INT", "(", "hi", ")", ")", ")", ";", "if", "(", "lo", ")", "emit_insn", "(", "gen_adddi3", "(", "this_rtx", ",", "this_rtx", ",", "GEN_INT", "(", "lo", ")", ")", ")", ";", "}", "else", "{", "rtx", "tmp", "=", "alpha_emit_set_long_const", "(", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ",", "delta", ",", "-", "(", "delta", "<", "0", ")", ")", ";", "emit_insn", "(", "gen_adddi3", "(", "this_rtx", ",", "this_rtx", ",", "tmp", ")", ")", ";", "}", "if", "(", "vcall_offset", ")", "{", "rtx", "tmp", ",", "tmp2", ";", "tmp", "=", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ";", "emit_move_insn", "(", "tmp", ",", "gen_rtx_MEM", "(", "Pmode", ",", "this_rtx", ")", ")", ";", "lo", "=", "(", "(", "vcall_offset", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "hi", "=", "(", "(", "(", "vcall_offset", "-", "lo", ")", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "if", "(", "hi", "+", "lo", "==", "vcall_offset", ")", "{", "if", "(", "hi", ")", "emit_insn", "(", "gen_adddi3", "(", "tmp", ",", "tmp", ",", "GEN_INT", "(", "hi", ")", ")", ")", ";", "}", "else", "{", "tmp2", "=", "alpha_emit_set_long_const", "(", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ",", "vcall_offset", ",", "-", "(", "vcall_offset", "<", "0", ")", ")", ";", "emit_insn", "(", "gen_adddi3", "(", "tmp", ",", "tmp", ",", "tmp2", ")", ")", ";", "lo", "=", "0", ";", "}", "if", "(", "lo", ")", "tmp2", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "tmp", ",", "GEN_INT", "(", "lo", ")", ")", ";", "else", "tmp2", "=", "tmp", ";", "emit_move_insn", "(", "tmp", ",", "gen_rtx_MEM", "(", "Pmode", ",", "tmp2", ")", ")", ";", "emit_insn", "(", "gen_adddi3", "(", "this_rtx", ",", "this_rtx", ",", "tmp", ")", ")", ";", "}", "if", "(", "!", "TREE_USED", "(", "function", ")", ")", "{", "assemble_external", "(", "function", ")", ";", "TREE_USED", "(", "function", ")", "=", "1", ";", "}", "funexp", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ";", "funexp", "=", "gen_rtx_MEM", "(", "FUNCTION_MODE", ",", "funexp", ")", ";", "insn", "=", "emit_call_insn", "(", "gen_sibcall", "(", "funexp", ",", "const0_rtx", ")", ")", ";", "SIBLING_CALL_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "get_insns", "(", ")", ";", "shorten_branches", "(", "insn", ")", ";", "final_start_function", "(", "insn", ",", "file", ",", "1", ")", ";", "final", "(", "insn", ",", "file", ",", "1", ")", ";", "final_end_function", "(", ")", ";", "}", "</s>"], "natrual_language": ["Emit", "a", "tail", "call", "to", "FUNCTION", "after", "adjusting", "THIS", "by", "DELTA", ".", "In", "order", "to", "avoid", "the", "hordes", "of", "differences", "between", "generated", "code", "with", "and", "without", "TARGET_EXPLICIT_RELOCS", ",", "and", "to", "avoid", "duplicating", "lots", "of", "code", "loading", "up", "large", "constants", ",", "generate", "rtl", "and", "emit", "it", "instead", "of", "going", "straight", "to", "text", ".", "Not", "sure", "why", "this", "idea", "has", "n't", "been", "explored", "before", "..."], "TS_V_token": ["alpha", "17", "16", "0xffff", "0x8000", "0x8000", "0xffffffff", "0x80000000", "0x80000000", "0", "0", "0", "0xffff", "0x8000", "0x8000", "0xffffffff", "0x80000000", "0x80000000", "1", "0", "0", "1", "0", "1", "1", "1"], "File": "alpha4", "Func": "alpha_output_mi_thunk_osf", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40676, "Length": 475}
{"ground_truth": ["<s>", "static", "void", "alpha_pad_function_end", "(", "void", ")", "{", "rtx_insn", "*", "insn", ",", "*", "next", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "!", "CALL_P", "(", "insn", ")", "||", "!", "(", "SIBLING_CALL_P", "(", "insn", ")", "||", "find_reg_note", "(", "insn", ",", "REG_NORETURN", ",", "NULL_RTX", ")", ")", ")", "continue", ";", "next", "=", "NEXT_INSN", "(", "insn", ")", ";", "if", "(", "next", "==", "NULL", ")", "continue", ";", "if", "(", "NOTE_P", "(", "next", ")", "&&", "NOTE_KIND", "(", "next", ")", "==", "NOTE_INSN_CALL_ARG_LOCATION", ")", "insn", "=", "next", ";", "next", "=", "next_active_insn", "(", "insn", ")", ";", "if", "(", "next", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "next", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SET", "&&", "GET_CODE", "(", "SET_SRC", "(", "pat", ")", ")", "==", "UNSPEC_VOLATILE", "&&", "XINT", "(", "SET_SRC", "(", "pat", ")", ",", "1", ")", "==", "UNSPECV_LDGP1", ")", "emit_insn_after", "(", "gen_unop", "(", ")", ",", "insn", ")", ";", "}", "}", "}", "</s>"], "natrual_language": ["Insert", "an", "unop", "between", "sibcall", "or", "noreturn", "function", "call", "and", "GP", "load", "."], "TS_V_token": ["alpha", "1"], "File": "alpha4", "Func": "alpha_pad_function_end", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40677, "Length": 155}
{"ground_truth": ["<s>", "static", "bool", "alpha_pass_by_reference", "(", "cumulative_args_t", "ca", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "return", "mode", "==", "TFmode", "||", "mode", "==", "TCmode", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "TYPE", "should", "be", "passed", "by", "invisible", "reference", "."], "TS_V_token": ["alpha"], "File": "alpha4", "Func": "alpha_pass_by_reference", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40678, "Length": 30}
{"ground_truth": ["<s>", "enum", "reg_class", "alpha_preferred_reload_class", "(", "rtx", "x", ",", "enum", "reg_class", "rclass", ")", "{", "if", "(", "x", "==", "CONST0_RTX", "(", "GET_MODE", "(", "x", ")", ")", ")", "return", "rclass", ";", "if", "(", "CONST_INT_P", "(", "x", ")", "||", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", "||", "GET_CODE", "(", "x", ")", "==", "CONST_VECTOR", ")", "{", "if", "(", "rclass", "==", "FLOAT_REGS", ")", "return", "NO_REGS", ";", "if", "(", "rclass", "==", "ALL_REGS", ")", "return", "GENERAL_REGS", ";", "return", "rclass", ";", "}", "if", "(", "CONSTANT_P", "(", "x", ")", ")", "return", "(", "rclass", "==", "ALL_REGS", "?", "GENERAL_REGS", ":", "rclass", ")", ";", "return", "rclass", ";", "}", "</s>"], "natrual_language": ["On", "the", "Alpha", ",", "all", "(", "non-symbolic", ")", "constants", "except", "zero", "go", "into", "a", "floating-point", "register", "via", "memory", ".", "Note", "that", "we", "can", "not", "return", "anything", "that", "is", "not", "a", "subset", "of", "CLASS", ",", "and", "that", "some", "symbolic", "constants", "can", "not", "be", "dropped", "to", "memory", "."], "TS_V_token": ["alpha"], "File": "alpha4", "Func": "alpha_preferred_reload_class", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40679, "Length": 93}
{"ground_truth": ["<s>", "static", "void", "alpha_reorg", "(", "void", ")", "{", "if", "(", "current_function_has_exception_handlers", "(", ")", ")", "alpha_pad_function_end", "(", ")", ";", "}", "</s>"], "natrual_language": ["Machine", "dependent", "reorg", "pass", "."], "TS_V_token": ["alpha"], "File": "alpha4", "Func": "alpha_reorg", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40680, "Length": 18}
{"ground_truth": ["<s>", "static", "void", "alpha_sa_mask", "(", "unsigned", "long", "*", "imaskP", ",", "unsigned", "long", "*", "fmaskP", ")", "{", "unsigned", "long", "imask", "=", "0", ";", "unsigned", "long", "fmask", "=", "0", ";", "unsigned", "int", "i", ";", "if", "(", "cfun", "->", "is_thunk", ")", "{", "*", "imaskP", "=", "0", ";", "*", "fmaskP", "=", "0", ";", "return", ";", "}", "if", "(", "TARGET_ABI_OPEN_VMS", "&&", "alpha_procedure_type", "==", "PT_STACK", ")", "imask", "|=", "(", "1UL", "<<", "HARD_FRAME_POINTER_REGNUM", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "if", "(", "!", "fixed_regs", "[", "i", "]", "&&", "!", "call_used_regs", "[", "i", "]", "&&", "df_regs_ever_live_p", "(", "i", ")", "&&", "i", "!=", "REG_RA", ")", "{", "if", "(", "i", "<", "32", ")", "imask", "|=", "(", "1UL", "<<", "i", ")", ";", "else", "fmask", "|=", "(", "1UL", "<<", "(", "i", "-", "32", ")", ")", ";", "}", "if", "(", "crtl", "->", "calls_eh_return", ")", "{", "for", "(", "i", "=", "0", ";", ";", "++", "i", ")", "{", "unsigned", "regno", "=", "EH_RETURN_DATA_REGNO", "(", "i", ")", ";", "if", "(", "regno", "==", "INVALID_REGNUM", ")", "break", ";", "imask", "|=", "1UL", "<<", "regno", ";", "}", "}", "if", "(", "imask", "||", "fmask", "||", "alpha_ra_ever_killed", "(", ")", ")", "imask", "|=", "(", "1UL", "<<", "REG_RA", ")", ";", "*", "imaskP", "=", "imask", ";", "*", "fmaskP", "=", "fmask", ";", "}", "</s>"], "natrual_language": ["Compute", "register", "masks", "for", "saved", "registers", "."], "TS_V_token": ["alpha", "0", "0", "0", "0", "1UL", "0", "32", "1UL", "1UL", "32", "0", "1UL", "1UL"], "File": "alpha4", "Func": "alpha_sa_mask", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40681, "Length": 203}
{"ground_truth": ["<s>", "static", "bool", "alpha_scalar_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "case", "HImode", ":", "case", "SImode", ":", "case", "DImode", ":", "case", "TImode", ":", "return", "true", ";", "case", "SFmode", ":", "case", "DFmode", ":", "return", "true", ";", "case", "TFmode", ":", "return", "TARGET_HAS_XFLOATING_LIBS", ";", "default", ":", "return", "false", ";", "}", "}", "</s>"], "natrual_language": ["The", "scalar", "modes", "supported", "differs", "from", "the", "default", "check-what-c-supports", "version", "in", "that", "sometimes", "TFmode", "is", "available", "even", "when", "long", "double", "indicates", "only", "DFmode", ".", "On", "unicosmk", ",", "we", "have", "the", "situation", "that", "HImode", "does", "n't", "map", "to", "any", "C", "type", ",", "but", "of", "course", "we", "still", "support", "that", "."], "TS_V_token": ["alpha"], "File": "alpha4", "Func": "alpha_scalar_mode_supported_p", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40682, "Length": 53}
{"ground_truth": ["<s>", "static", "void", "alpha_setup_incoming_varargs", "(", "cumulative_args_t", "pcum", ",", "machine_mode", "mode", ",", "tree", "type", ",", "int", "*", "pretend_size", ",", "int", "no_rtl", ")", "{", "CUMULATIVE_ARGS", "cum", "=", "*", "get_cumulative_args", "(", "pcum", ")", ";", "targetm", ".", "calls", ".", "function_arg_advance", "(", "pack_cumulative_args", "(", "&", "cum", ")", ",", "mode", ",", "type", ",", "true", ")", ";", "if", "(", "cum", ".", "num_args", "<", "6", ")", "{", "if", "(", "!", "no_rtl", ")", "{", "emit_move_insn", "(", "gen_rtx_REG", "(", "DImode", ",", "1", ")", ",", "virtual_incoming_args_rtx", ")", ";", "emit_insn", "(", "gen_arg_home", "(", ")", ")", ";", "}", "*", "pretend_size", "=", "7", "*", "UNITS_PER_WORD", ";", "}", "if", "(", "cum", ">=", "6", ")", "return", ";", "if", "(", "!", "no_rtl", ")", "{", "int", "count", ";", "alias_set_type", "set", "=", "get_varargs_alias_set", "(", ")", ";", "rtx", "tmp", ";", "count", "=", "cfun", "->", "va_list_gpr_size", "/", "UNITS_PER_WORD", ";", "if", "(", "count", ">", "6", "-", "cum", ")", "count", "=", "6", "-", "cum", ";", "gcc_assert", "(", "(", "VA_LIST_MAX_FPR_SIZE", "&", "3", ")", "==", "3", ")", ";", "if", "(", "cfun", "->", "va_list_fpr_size", "&", "1", ")", "{", "tmp", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "(", "cum", "+", "6", ")", "*", "UNITS_PER_WORD", ")", ")", ";", "MEM_NOTRAP_P", "(", "tmp", ")", "=", "1", ";", "set_mem_alias_set", "(", "tmp", ",", "set", ")", ";", "move_block_from_reg", "(", "16", "+", "cum", ",", "tmp", ",", "count", ")", ";", "}", "if", "(", "cfun", "->", "va_list_fpr_size", "&", "2", ")", "{", "tmp", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "cum", "*", "UNITS_PER_WORD", ")", ")", ";", "MEM_NOTRAP_P", "(", "tmp", ")", "=", "1", ";", "set_mem_alias_set", "(", "tmp", ",", "set", ")", ";", "move_block_from_reg", "(", "16", "+", "cum", "+", "TARGET_FPREGS", "*", "32", ",", "tmp", ",", "count", ")", ";", "}", "}", "*", "pretend_size", "=", "12", "*", "UNITS_PER_WORD", ";", "}", "</s>"], "natrual_language": ["Perform", "any", "needed", "actions", "needed", "for", "a", "function", "that", "is", "receiving", "a", "variable", "number", "of", "arguments", "."], "TS_V_token": ["alpha", "6", "1", "7", "6", "6", "6", "3", "3", "1", "6", "1", "16", "2", "1", "16", "32", "12"], "File": "alpha4", "Func": "alpha_setup_incoming_varargs", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40683, "Length": 275}
{"ground_truth": ["<s>", "void", "alpha_split_atomic_exchange", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "retval", ",", "mem", ",", "val", ",", "scratch", ";", "enum", "memmodel", "model", ";", "machine_mode", "mode", ";", "rtx", "label", ",", "x", ",", "cond", ";", "retval", "=", "operands", "[", "0", "]", ";", "mem", "=", "operands", "[", "1", "]", ";", "val", "=", "operands", "[", "2", "]", ";", "model", "=", "(", "enum", "memmodel", ")", "INTVAL", "(", "operands", "[", "3", "]", ")", ";", "scratch", "=", "operands", "[", "4", "]", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "cond", "=", "gen_lowpart", "(", "DImode", ",", "scratch", ")", ";", "alpha_pre_atomic_barrier", "(", "model", ")", ";", "label", "=", "gen_rtx_LABEL_REF", "(", "DImode", ",", "gen_label_rtx", "(", ")", ")", ";", "emit_label", "(", "XEXP", "(", "label", ",", "0", ")", ")", ";", "emit_load_locked", "(", "mode", ",", "retval", ",", "mem", ")", ";", "emit_move_insn", "(", "scratch", ",", "val", ")", ";", "emit_store_conditional", "(", "mode", ",", "cond", ",", "mem", ",", "scratch", ")", ";", "x", "=", "gen_rtx_EQ", "(", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_unlikely_jump", "(", "x", ",", "label", ")", ";", "alpha_post_atomic_barrier", "(", "model", ")", ";", "}", "</s>"], "natrual_language": ["Expand", "an", "atomic", "exchange", "operation", "."], "TS_V_token": ["alpha", "0", "1", "2", "3", "4", "0"], "File": "alpha4", "Func": "alpha_split_atomic_exchange", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40684, "Length": 167}
{"ground_truth": ["<s>", "void", "alpha_split_atomic_op", "(", "enum", "rtx_code", "code", ",", "rtx", "mem", ",", "rtx", "val", ",", "rtx", "before", ",", "rtx", "after", ",", "rtx", "scratch", ",", "enum", "memmodel", "model", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "rtx", "label", ",", "x", ",", "cond", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "scratch", ")", ")", ";", "alpha_pre_atomic_barrier", "(", "model", ")", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label", ")", ";", "label", "=", "gen_rtx_LABEL_REF", "(", "DImode", ",", "label", ")", ";", "if", "(", "before", "==", "NULL", ")", "before", "=", "scratch", ";", "emit_load_locked", "(", "mode", ",", "before", ",", "mem", ")", ";", "if", "(", "code", "==", "NOT", ")", "{", "x", "=", "gen_rtx_AND", "(", "mode", ",", "before", ",", "val", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "val", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_NOT", "(", "mode", ",", "val", ")", ";", "}", "else", "x", "=", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "before", ",", "val", ")", ";", "if", "(", "after", ")", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "after", ",", "copy_rtx", "(", "x", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "scratch", ",", "x", ")", ")", ";", "emit_store_conditional", "(", "mode", ",", "cond", ",", "mem", ",", "scratch", ")", ";", "x", "=", "gen_rtx_EQ", "(", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_unlikely_jump", "(", "x", ",", "label", ")", ";", "alpha_post_atomic_barrier", "(", "model", ")", ";", "}", "</s>"], "natrual_language": ["Expand", "an", "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", ".", "SCRATCH", "is", "a", "scratch", "register", "."], "TS_V_token": ["alpha"], "File": "alpha4", "Func": "alpha_split_atomic_op", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40685, "Length": 216}
{"ground_truth": ["<s>", "void", "alpha_split_compare_and_swap", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "cond", ",", "retval", ",", "mem", ",", "oldval", ",", "newval", ";", "bool", "is_weak", ";", "enum", "memmodel", "mod_s", ",", "mod_f", ";", "machine_mode", "mode", ";", "rtx", "label1", ",", "label2", ",", "x", ";", "cond", "=", "operands", "[", "0", "]", ";", "retval", "=", "operands", "[", "1", "]", ";", "mem", "=", "operands", "[", "2", "]", ";", "oldval", "=", "operands", "[", "3", "]", ";", "newval", "=", "operands", "[", "4", "]", ";", "is_weak", "=", "(", "operands", "[", "5", "]", "!=", "const0_rtx", ")", ";", "mod_s", "=", "(", "enum", "memmodel", ")", "INTVAL", "(", "operands", "[", "6", "]", ")", ";", "mod_f", "=", "(", "enum", "memmodel", ")", "INTVAL", "(", "operands", "[", "7", "]", ")", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "alpha_pre_atomic_barrier", "(", "mod_s", ")", ";", "label1", "=", "NULL_RTX", ";", "if", "(", "!", "is_weak", ")", "{", "label1", "=", "gen_rtx_LABEL_REF", "(", "DImode", ",", "gen_label_rtx", "(", ")", ")", ";", "emit_label", "(", "XEXP", "(", "label1", ",", "0", ")", ")", ";", "}", "label2", "=", "gen_rtx_LABEL_REF", "(", "DImode", ",", "gen_label_rtx", "(", ")", ")", ";", "emit_load_locked", "(", "mode", ",", "retval", ",", "mem", ")", ";", "x", "=", "gen_lowpart", "(", "DImode", ",", "retval", ")", ";", "if", "(", "oldval", "==", "const0_rtx", ")", "{", "emit_move_insn", "(", "cond", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_NE", "(", "DImode", ",", "x", ",", "const0_rtx", ")", ";", "}", "else", "{", "x", "=", "gen_rtx_EQ", "(", "DImode", ",", "x", ",", "oldval", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "cond", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_EQ", "(", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "}", "emit_unlikely_jump", "(", "x", ",", "label2", ")", ";", "emit_move_insn", "(", "cond", ",", "newval", ")", ";", "emit_store_conditional", "(", "mode", ",", "cond", ",", "mem", ",", "gen_lowpart", "(", "mode", ",", "cond", ")", ")", ";", "if", "(", "!", "is_weak", ")", "{", "x", "=", "gen_rtx_EQ", "(", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_unlikely_jump", "(", "x", ",", "label1", ")", ";", "}", "if", "(", "mod_f", "!=", "MEMMODEL_RELAXED", ")", "emit_label", "(", "XEXP", "(", "label2", ",", "0", ")", ")", ";", "alpha_post_atomic_barrier", "(", "mod_s", ")", ";", "if", "(", "mod_f", "==", "MEMMODEL_RELAXED", ")", "emit_label", "(", "XEXP", "(", "label2", ",", "0", ")", ")", ";", "}", "</s>"], "natrual_language": ["Expand", "a", "compare", "and", "swap", "operation", "."], "TS_V_token": ["alpha", "0", "1", "2", "3", "4", "5", "6", "7", "0", "0", "0"], "File": "alpha4", "Func": "alpha_split_compare_and_swap", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40686, "Length": 342}
{"ground_truth": ["<s>", "int", "alpha_split_conditional_move", "(", "enum", "rtx_code", "code", ",", "rtx", "dest", ",", "rtx", "cond", ",", "rtx", "t_rtx", ",", "rtx", "f_rtx", ")", "{", "HOST_WIDE_INT", "t", ",", "f", ",", "diff", ";", "machine_mode", "mode", ";", "rtx", "target", ",", "subtarget", ",", "tmp", ";", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "t", "=", "INTVAL", "(", "t_rtx", ")", ";", "f", "=", "INTVAL", "(", "f_rtx", ")", ";", "diff", "=", "t", "-", "f", ";", "if", "(", "(", "(", "code", "==", "NE", "||", "code", "==", "EQ", ")", "&&", "diff", "<", "0", ")", "||", "(", "code", "==", "GE", "||", "code", "==", "GT", ")", ")", "{", "code", "=", "reverse_condition", "(", "code", ")", ";", "diff", "=", "t", ",", "t", "=", "f", ",", "f", "=", "diff", ";", "diff", "=", "t", "-", "f", ";", "}", "subtarget", "=", "target", "=", "dest", ";", "if", "(", "mode", "!=", "DImode", ")", "{", "target", "=", "gen_lowpart", "(", "DImode", ",", "dest", ")", ";", "if", "(", "can_create_pseudo_p", "(", ")", ")", "subtarget", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "else", "subtarget", "=", "target", ";", "}", "if", "(", "f", "==", "0", "&&", "exact_log2", "(", "diff", ")", ">", "0", "&&", "(", "diff", "<=", "8", "||", "alpha_tune", "==", "PROCESSOR_EV6", ")", ")", "{", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "copy_rtx", "(", "subtarget", ")", ",", "tmp", ")", ")", ";", "tmp", "=", "gen_rtx_ASHIFT", "(", "DImode", ",", "copy_rtx", "(", "subtarget", ")", ",", "GEN_INT", "(", "exact_log2", "(", "t", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "target", ",", "tmp", ")", ")", ";", "}", "else", "if", "(", "f", "==", "0", "&&", "t", "==", "-", "1", ")", "{", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "copy_rtx", "(", "subtarget", ")", ",", "tmp", ")", ")", ";", "emit_insn", "(", "gen_negdi2", "(", "target", ",", "copy_rtx", "(", "subtarget", ")", ")", ")", ";", "}", "else", "if", "(", "diff", "==", "1", "||", "diff", "==", "4", "||", "diff", "==", "8", ")", "{", "rtx", "add_op", ";", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "copy_rtx", "(", "subtarget", ")", ",", "tmp", ")", ")", ";", "if", "(", "diff", "==", "1", ")", "emit_insn", "(", "gen_adddi3", "(", "target", ",", "copy_rtx", "(", "subtarget", ")", ",", "GEN_INT", "(", "f", ")", ")", ")", ";", "else", "{", "add_op", "=", "GEN_INT", "(", "f", ")", ";", "if", "(", "sext_add_operand", "(", "add_op", ",", "mode", ")", ")", "{", "tmp", "=", "gen_rtx_MULT", "(", "DImode", ",", "copy_rtx", "(", "subtarget", ")", ",", "GEN_INT", "(", "diff", ")", ")", ";", "tmp", "=", "gen_rtx_PLUS", "(", "DImode", ",", "tmp", ",", "add_op", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "target", ",", "tmp", ")", ")", ";", "}", "else", "return", "0", ";", "}", "}", "else", "return", "0", ";", "return", "1", ";", "}", "</s>"], "natrual_language": ["Simplify", "a", "conditional", "move", "of", "two", "constants", "into", "a", "setcc", "with", "arithmetic", ".", "This", "is", "done", "with", "a", "splitter", "since", "combine", "would", "just", "undo", "the", "work", "if", "done", "during", "code", "generation", ".", "It", "also", "catches", "cases", "we", "would", "n't", "have", "before", "cse", "."], "TS_V_token": ["alpha", "0", "0", "0", "8", "0", "1", "1", "4", "8", "1", "0", "0", "1"], "File": "alpha4", "Func": "alpha_split_conditional_move", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40687, "Length": 445}
{"ground_truth": ["<s>", "bool", "alpha_split_const_mov", "(", "machine_mode", "mode", ",", "rtx", "*", "operands", ")", "{", "HOST_WIDE_INT", "i0", ",", "i1", ";", "rtx", "temp", "=", "NULL_RTX", ";", "alpha_extract_integer", "(", "operands", "[", "1", "]", ",", "&", "i0", ",", "&", "i1", ")", ";", "if", "(", "HOST_BITS_PER_WIDE_INT", ">=", "64", "||", "i1", "==", "-", "(", "i0", "<", "0", ")", ")", "temp", "=", "alpha_emit_set_const", "(", "operands", "[", "0", "]", ",", "mode", ",", "i0", ",", "3", ",", "false", ")", ";", "if", "(", "!", "temp", "&&", "TARGET_BUILD_CONSTANTS", ")", "temp", "=", "alpha_emit_set_long_const", "(", "operands", "[", "0", "]", ",", "i0", ",", "i1", ")", ";", "if", "(", "temp", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "operands", "[", "0", "]", ",", "temp", ")", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "temp", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Operand", "1", "is", "known", "to", "be", "a", "constant", ",", "and", "should", "require", "more", "than", "one", "instruction", "to", "load", ".", "Emit", "that", "multi-part", "load", "."], "TS_V_token": ["alpha", "1", "64", "0", "0", "3", "0", "0", "0"], "File": "alpha4", "Func": "alpha_split_const_mov", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40688, "Length": 125}
{"ground_truth": ["<s>", "void", "alpha_split_tmode_pair", "(", "rtx", "operands", "[", "4", "]", ",", "machine_mode", "mode", ",", "bool", "fixup_overlap", ")", "{", "switch", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", ")", "{", "case", "REG", ":", "operands", "[", "3", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "operands", "[", "1", "]", ")", "+", "1", ")", ";", "operands", "[", "2", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "operands", "[", "1", "]", ")", ")", ";", "break", ";", "case", "MEM", ":", "operands", "[", "3", "]", "=", "adjust_address", "(", "operands", "[", "1", "]", ",", "DImode", ",", "8", ")", ";", "operands", "[", "2", "]", "=", "adjust_address", "(", "operands", "[", "1", "]", ",", "DImode", ",", "0", ")", ";", "break", ";", "case", "CONST_INT", ":", "case", "CONST_DOUBLE", ":", "gcc_assert", "(", "operands", "[", "1", "]", "==", "CONST0_RTX", "(", "mode", ")", ")", ";", "operands", "[", "2", "]", "=", "operands", "[", "3", "]", "=", "const0_rtx", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", ")", "{", "case", "REG", ":", "operands", "[", "1", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "operands", "[", "0", "]", ")", "+", "1", ")", ";", "operands", "[", "0", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "operands", "[", "0", "]", ")", ")", ";", "break", ";", "case", "MEM", ":", "operands", "[", "1", "]", "=", "adjust_address", "(", "operands", "[", "0", "]", ",", "DImode", ",", "8", ")", ";", "operands", "[", "0", "]", "=", "adjust_address", "(", "operands", "[", "0", "]", ",", "DImode", ",", "0", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "fixup_overlap", "&&", "reg_overlap_mentioned_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "3", "]", ")", ")", "{", "std", "::", "swap", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "std", "::", "swap", "(", "operands", "[", "2", "]", ",", "operands", "[", "3", "]", ")", ";", "}", "}", "</s>"], "natrual_language": ["Split", "a", "TImode", "or", "TFmode", "move", "from", "OP", "[", "1", "]", "to", "OP", "[", "0", "]", "into", "a", "pair", "of", "DImode", "moves", "from", "OP", "[", "2,3", "]", "to", "OP", "[", "0,1", "]", ".", "If", "FIXUP_OVERLAP", "is", "true", ",", "guarantee", "that", "the", "sequence", "set", "(", "OP", "[", "0", "]", "OP", "[", "2", "]", ")", "set", "(", "OP", "[", "1", "]", "OP", "[", "3", "]", ")", "is", "valid", ".", "Naturally", ",", "output", "operand", "ordering", "is", "little-endian", ".", "This", "is", "used", "by", "*", "movtf_internal", "and", "*", "movti_internal", "."], "TS_V_token": ["alpha", "4", "1", "3", "1", "1", "2", "1", "3", "1", "8", "2", "1", "0", "1", "2", "3", "0", "1", "0", "1", "0", "0", "1", "0", "8", "0", "0", "0", "0", "3", "0", "1", "2", "3"], "File": "alpha4", "Func": "alpha_split_tmode_pair", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40689, "Length": 299}
{"ground_truth": ["<s>", "static", "void", "alpha_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "chain_value", ")", "{", "rtx", "fnaddr", ",", "mem", ",", "word1", ",", "word2", ";", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "fnaddr", "=", "convert_memory_address", "(", "Pmode", ",", "fnaddr", ")", ";", "chain_value", "=", "convert_memory_address", "(", "Pmode", ",", "chain_value", ")", ";", "if", "(", "TARGET_ABI_OPEN_VMS", ")", "{", "const", "char", "*", "fnname", ";", "char", "*", "trname", ";", "fnname", "=", "XSTR", "(", "fnaddr", ",", "0", ")", ";", "trname", "=", "(", "char", "*", ")", "alloca", "(", "strlen", "(", "fnname", ")", "+", "5", ")", ";", "strcpy", "(", "trname", ",", "fnname", ")", ";", "strcat", "(", "trname", ",", "\"..tr\"", ")", ";", "fnname", "=", "ggc_alloc_string", "(", "trname", ",", "strlen", "(", "trname", ")", "+", "1", ")", ";", "word2", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "fnname", ")", ";", "word1", "=", "force_reg", "(", "DImode", ",", "gen_const_mem", "(", "DImode", ",", "fnaddr", ")", ")", ";", "word1", "=", "expand_and", "(", "DImode", ",", "word1", ",", "GEN_INT", "(", "HOST_WIDE_INT_C", "(", "0xffff0fff0000fff0", ")", ")", ",", "NULL", ")", ";", "}", "else", "{", "word1", "=", "GEN_INT", "(", "HOST_WIDE_INT_C", "(", "0xa77b0010a43b0018", ")", ")", ";", "word2", "=", "GEN_INT", "(", "HOST_WIDE_INT_C", "(", "0x47ff041f6bfb0000", ")", ")", ";", "}", "mem", "=", "adjust_address", "(", "m_tramp", ",", "DImode", ",", "0", ")", ";", "emit_move_insn", "(", "mem", ",", "word1", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "DImode", ",", "8", ")", ";", "emit_move_insn", "(", "mem", ",", "word2", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "16", ")", ";", "emit_move_insn", "(", "mem", ",", "fnaddr", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "24", ")", ";", "emit_move_insn", "(", "mem", ",", "chain_value", ")", ";", "if", "(", "TARGET_ABI_OSF", ")", "{", "emit_insn", "(", "gen_imb", "(", ")", ")", ";", "emit_library_call", "(", "init_one_libfunc", "(", "\"__enable_execute_stack\"", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "1", ",", "XEXP", "(", "m_tramp", ",", "0", ")", ",", "Pmode", ")", ";", "}", "}", "</s>"], "natrual_language": ["Emit", "RTL", "insns", "to", "initialize", "the", "variable", "parts", "of", "a", "trampoline", "at", "M_TRAMP", ".", "FNDECL", "is", "target", "function", "'s", "decl", ".", "CHAIN_VALUE", "is", "an", "rtx", "for", "the", "static", "chain", "value", "for", "the", "function", "."], "TS_V_token": ["alpha", "0", "0", "5", "\"..tr\"", "1", "0xffff0fff0000fff0", "0xa77b0010a43b0018", "0x47ff041f6bfb0000", "0", "8", "16", "24", "\"__enable_execute_stack\"", "1", "0"], "File": "alpha4", "Func": "alpha_trampoline_init", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40690, "Length": 295}
{"ground_truth": ["<s>", "rtx", "alpha_use_linkage", "(", "rtx", "func", ",", "bool", "lflag", ",", "bool", "rflag", ")", "{", "struct", "alpha_links", "*", "al", "=", "NULL", ";", "const", "char", "*", "name", "=", "XSTR", "(", "func", ",", "0", ")", ";", "if", "(", "cfun", "->", "machine", "->", "links", ")", "{", "alpha_links", "*", "*", "slot", "=", "cfun", "->", "machine", "->", "links", "->", "get", "(", "name", ")", ";", "if", "(", "slot", ")", "al", "=", "*", "slot", ";", "}", "else", "cfun", "->", "machine", "->", "links", "=", "hash_map", "<", "const", "char", "*", ",", "alpha_links", "*", ",", "string_traits", ">", "::", "create_ggc", "(", "64", ")", ";", "if", "(", "al", "==", "NULL", ")", "{", "size_t", "buf_len", ";", "char", "*", "linksym", ";", "tree", "id", ";", "if", "(", "name", "[", "0", "]", "==", "'*'", ")", "name", "++", ";", "id", "=", "maybe_get_identifier", "(", "name", ")", ";", "if", "(", "id", ")", "{", "while", "(", "IDENTIFIER_TRANSPARENT_ALIAS", "(", "id", ")", ")", "id", "=", "TREE_CHAIN", "(", "id", ")", ";", "name", "=", "IDENTIFIER_POINTER", "(", "id", ")", ";", "}", "buf_len", "=", "strlen", "(", "name", ")", "+", "8", "+", "9", ";", "linksym", "=", "(", "char", "*", ")", "alloca", "(", "buf_len", ")", ";", "snprintf", "(", "linksym", ",", "buf_len", ",", "\"$%d..%s..lk\"", ",", "cfun", "->", "funcdef_no", ",", "name", ")", ";", "al", "=", "ggc_alloc", "<", "alpha_links", ">", "(", ")", ";", "al", "->", "func", "=", "func", ";", "al", "->", "linkage", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "ggc_strdup", "(", "linksym", ")", ")", ";", "cfun", "->", "machine", "->", "links", "->", "put", "(", "ggc_strdup", "(", "name", ")", ",", "al", ")", ";", "}", "al", "->", "rkind", "=", "rflag", "?", "KIND_CODEADDR", ":", "KIND_LINKAGE", ";", "if", "(", "lflag", ")", "return", "gen_rtx_MEM", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "al", "->", "linkage", ",", "8", ")", ")", ";", "else", "return", "al", "->", "linkage", ";", "}", "</s>"], "natrual_language": ["Return", "a", "SYMBOL_REF", "representing", "the", "reference", "to", "the", ".linkage", "entry", "of", "function", "FUNC", "built", "for", "calls", "made", "from", "CFUNDECL", ".", "LFLAG", "is", "1", "if", "this", "is", "the", "reference", "to", "the", "linkage", "pointer", "value", ",", "0", "if", "this", "is", "the", "reference", "to", "the", "function", "entry", "value", ".", "RFLAG", "is", "1", "if", "this", "a", "reduced", "reference", "(", "code", "address", "only", ")", ",", "0", "if", "this", "is", "a", "full", "reference", "."], "TS_V_token": ["alpha", "0", "64", "0", "8", "9", "\"$%d..%s..lk\"", "8"], "File": "alpha4", "Func": "alpha_use_linkage", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40691, "Length": 275}
{"ground_truth": ["<s>", "static", "bool", "alpha_vms_can_eliminate", "(", "const", "int", "from", "ATTRIBUTE_UNUSED", ",", "const", "int", "to", ")", "{", "alpha_sa_size", "(", ")", ";", "switch", "(", "alpha_procedure_type", ")", "{", "case", "PT_NULL", ":", "return", "to", "==", "STACK_POINTER_REGNUM", ";", "case", "PT_REGISTER", ":", "case", "PT_STACK", ":", "return", "(", "to", "!=", "STACK_POINTER_REGNUM", "||", "vms_unwind_regno", "!=", "HARD_FRAME_POINTER_REGNUM", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>"], "natrual_language": ["Worker", "function", "for", "TARGET_CAN_ELIMINATE", "."], "TS_V_token": ["alpha"], "File": "alpha4", "Func": "alpha_vms_can_eliminate", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40692, "Length": 54}
{"ground_truth": ["<s>", "HOST_WIDE_INT", "alpha_vms_initial_elimination_offset", "(", "unsigned", "int", "from", ",", "unsigned", "int", "to", ")", "{", "HOST_WIDE_INT", "sa_size", "=", "alpha_sa_size", "(", ")", ";", "if", "(", "alpha_procedure_type", "==", "PT_NULL", ")", "return", "0", ";", "{", "HOST_WIDE_INT", "offset", ";", "HOST_WIDE_INT", "pv_save_size", "=", "alpha_procedure_type", "==", "PT_STACK", "?", "8", ":", "0", ";", "switch", "(", "from", ")", "{", "case", "FRAME_POINTER_REGNUM", ":", "offset", "=", "ALPHA_ROUND", "(", "sa_size", "+", "pv_save_size", ")", ";", "break", ";", "case", "ARG_POINTER_REGNUM", ":", "offset", "=", "(", "ALPHA_ROUND", "(", "sa_size", "+", "pv_save_size", "+", "get_frame_size", "(", ")", "+", "crtl", "->", "args", ".", "pretend_args_size", ")", "-", "crtl", "->", "args", ".", "pretend_args_size", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "to", "==", "STACK_POINTER_REGNUM", ")", "offset", "+=", "ALPHA_ROUND", "(", "crtl", "->", "outgoing_args_size", ")", ";", "return", "offset", ";", "}", "}", "</s>"], "natrual_language": ["FROM", "is", "to", "be", "eliminated", "for", "TO", ".", "Return", "the", "offset", "so", "that", "TO+offset", "designates", "the", "same", "location", "as", "FROM", "."], "TS_V_token": ["alpha", "0", "8", "0"], "File": "alpha4", "Func": "alpha_vms_initial_elimination_offset", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40693, "Length": 121}
{"ground_truth": ["<s>", "static", "HOST_WIDE_INT", "compute_frame_size", "(", "HOST_WIDE_INT", "size", ",", "HOST_WIDE_INT", "sa_size", ")", "{", "if", "(", "TARGET_ABI_OPEN_VMS", ")", "return", "ALPHA_ROUND", "(", "sa_size", "+", "(", "alpha_procedure_type", "==", "PT_STACK", "?", "8", ":", "0", ")", "+", "size", "+", "crtl", "->", "args", ".", "pretend_args_size", ")", ";", "else", "return", "ALPHA_ROUND", "(", "crtl", "->", "outgoing_args_size", ")", "+", "sa_size", "+", "ALPHA_ROUND", "(", "size", "+", "crtl", "->", "args", ".", "pretend_args_size", ")", ";", "}", "</s>"], "natrual_language": ["Typical", "stack", "layout", "should", "looks", "like", "this", "after", "the", "function", "'s", "prologue", ":", "|", "|", "--", "^", "|", "|", "\\", "|", "|", "|", "arguments", "saved", "|", "Increasing", "|", "|", "on", "the", "stack", "|", "addresses", "PARENT", "arg", "pointer", "-", ">", "|", "|", "/", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "-", "|", "|", "-", "space", "for", "argument", "split", "between", "regs", "&", "stack", "--", "CHILD", "|", "|", "\\", "<", "--", "(", "return", "address", "here", ")", "|", "|", "other", "call", "|", "|", "saved", "registers", "|", "|", "/", "--", "frame", "pointer", "-", ">", "|", "|", "\\", "___", "|", "|", "local", "|", "|", "|", "variables", "|f", "|", "|", "/", "|r", "--", "|a", "|", "|", "\\", "|m", "|", "|", "outgoing", "|e", "|", "|", "arguments", "|", "|", "Decreasing", "(", "hard", ")", "frame", "pointer", "|", "|", "/", "|", "|", "addresses", "and", "stack", "pointer", "-", ">", "|", "|", "/", "_|_", "|", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "V"], "TS_V_token": ["alpha", "8", "0"], "File": "alpha4", "Func": "compute_frame_size", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40694, "Length": 62}
{"ground_truth": ["<s>", "int", "direct_return", "(", "void", ")", "{", "return", "(", "TARGET_ABI_OSF", "&&", "reload_completed", "&&", "alpha_sa_size", "(", ")", "==", "0", "&&", "get_frame_size", "(", ")", "==", "0", "&&", "crtl", "->", "outgoing_args_size", "==", "0", "&&", "crtl", "->", "args", ".", "pretend_args_size", "==", "0", ")", ";", "}", "</s>"], "natrual_language": ["Return", "non-zero", "if", "this", "function", "is", "known", "to", "have", "a", "null", "epilogue", "."], "TS_V_token": ["alpha", "0", "0", "0", "0"], "File": "alpha4", "Func": "direct_return", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40695, "Length": 40}
{"ground_truth": ["<s>", "static", "void", "emit_frame_store_1", "(", "rtx", "value", ",", "rtx", "base_reg", ",", "HOST_WIDE_INT", "frame_bias", ",", "HOST_WIDE_INT", "base_ofs", ",", "rtx", "frame_reg", ")", "{", "rtx", "addr", ",", "mem", ";", "rtx_insn", "*", "insn", ";", "addr", "=", "plus_constant", "(", "Pmode", ",", "base_reg", ",", "base_ofs", ")", ";", "mem", "=", "gen_frame_mem", "(", "DImode", ",", "addr", ")", ";", "insn", "=", "emit_move_insn", "(", "mem", ",", "value", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "if", "(", "frame_bias", "||", "value", "!=", "frame_reg", ")", "{", "if", "(", "frame_bias", ")", "{", "addr", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "frame_bias", "+", "base_ofs", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "DImode", ",", "addr", ")", ";", "}", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "mem", ",", "frame_reg", ")", ")", ";", "}", "}", "</s>"], "natrual_language": ["Generates", "a", "store", "with", "the", "proper", "unwind", "info", "attached", ".", "VALUE", "is", "stored", "at", "BASE_REG+BASE_OFS", ".", "If", "FRAME_BIAS", "is", "nonzero", ",", "then", "BASE_REG", "contains", "SP+FRAME_BIAS", ",", "and", "that", "is", "the", "unwind", "info", "that", "should", "be", "generated", ".", "If", "FRAME_REG", "!", "=", "VALUE", ",", "then", "VALUE", "is", "being", "stored", "on", "behalf", "of", "FRAME_REG", ",", "and", "FRAME_REG", "should", "be", "present", "in", "the", "unwind", "."], "TS_V_token": ["alpha", "1"], "File": "alpha4", "Func": "emit_frame_store_1", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40696, "Length": 120}
{"ground_truth": ["<s>", "static", "rtx", "emit_insxl", "(", "machine_mode", "mode", ",", "rtx", "op1", ",", "rtx", "op2", ")", "{", "rtx", "ret", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "rtx", "(", "*", "fn", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "fn", "=", "gen_insbl", ";", "break", ";", "case", "HImode", ":", "fn", "=", "gen_inswl", ";", "break", ";", "case", "SImode", ":", "fn", "=", "gen_insll", ";", "break", ";", "case", "DImode", ":", "fn", "=", "gen_insql", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "op1", "=", "force_reg", "(", "mode", ",", "op1", ")", ";", "emit_insn", "(", "fn", "(", "ret", ",", "op1", ",", "op2", ")", ")", ";", "return", "ret", ";", "}", "</s>"], "natrual_language": ["A", "subroutine", "of", "the", "atomic", "operation", "splitters", ".", "Emit", "an", "insxl", "instruction", "in", "MODE", "."], "TS_V_token": ["alpha"], "File": "alpha4", "Func": "emit_insxl", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40697, "Length": 108}
{"ground_truth": ["<s>", "static", "void", "emit_load_locked", "(", "machine_mode", "mode", ",", "rtx", "reg", ",", "rtx", "mem", ")", "{", "rtx", "(", "*", "fn", ")", "(", "rtx", ",", "rtx", ")", "=", "NULL", ";", "if", "(", "mode", "==", "SImode", ")", "fn", "=", "gen_load_locked_si", ";", "else", "if", "(", "mode", "==", "DImode", ")", "fn", "=", "gen_load_locked_di", ";", "emit_insn", "(", "fn", "(", "reg", ",", "mem", ")", ")", ";", "}", "</s>"], "natrual_language": ["A", "subroutine", "of", "the", "atomic", "operation", "splitters", ".", "Emit", "a", "load-locked", "instruction", "in", "MODE", ".", "For", "QI/HImode", ",", "possibly", "use", "a", "pattern", "than", "includes", "the", "zero_extend", "operation", "."], "TS_V_token": ["alpha"], "File": "alpha4", "Func": "emit_load_locked", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40698, "Length": 59}
{"ground_truth": ["<s>", "static", "void", "emit_store_conditional", "(", "machine_mode", "mode", ",", "rtx", "res", ",", "rtx", "mem", ",", "rtx", "val", ")", "{", "rtx", "(", "*", "fn", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", "=", "NULL", ";", "if", "(", "mode", "==", "SImode", ")", "fn", "=", "gen_store_conditional_si", ";", "else", "if", "(", "mode", "==", "DImode", ")", "fn", "=", "gen_store_conditional_di", ";", "emit_insn", "(", "fn", "(", "res", ",", "mem", ",", "val", ")", ")", ";", "}", "</s>"], "natrual_language": ["A", "subroutine", "of", "the", "atomic", "operation", "splitters", ".", "Emit", "a", "store-conditional", "instruction", "in", "MODE", "."], "TS_V_token": ["alpha"], "File": "alpha4", "Func": "emit_store_conditional", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40699, "Length": 66}
{"ground_truth": ["<s>", "static", "void", "emit_unlikely_jump", "(", "rtx", "cond", ",", "rtx", "label", ")", "{", "int", "very_unlikely", "=", "REG_BR_PROB_BASE", "/", "100", "-", "1", ";", "rtx", "x", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "cond", ",", "label", ",", "pc_rtx", ")", ";", "x", "=", "emit_jump_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "pc_rtx", ",", "x", ")", ")", ";", "add_int_reg_note", "(", "x", ",", "REG_BR_PROB", ",", "very_unlikely", ")", ";", "}", "</s>"], "natrual_language": ["Mark", "the", "previous", "jump", "instruction", "as", "unlikely", "."], "TS_V_token": ["alpha", "100", "1"], "File": "alpha4", "Func": "emit_unlikely_jump", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40700, "Length": 60}
{"ground_truth": ["<s>", "rtx", "function_value", "(", "const_tree", "valtype", ",", "const_tree", "func", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ")", "{", "unsigned", "int", "regnum", ",", "dummy", "ATTRIBUTE_UNUSED", ";", "enum", "mode_class", "mclass", ";", "gcc_assert", "(", "!", "valtype", "||", "!", "alpha_return_in_memory", "(", "valtype", ",", "func", ")", ")", ";", "if", "(", "valtype", ")", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "mclass", "=", "GET_MODE_CLASS", "(", "mode", ")", ";", "switch", "(", "mclass", ")", "{", "case", "MODE_INT", ":", "if", "(", "!", "(", "TARGET_ABI_OPEN_VMS", "&&", "valtype", "&&", "AGGREGATE_TYPE_P", "(", "valtype", ")", ")", ")", "PROMOTE_MODE", "(", "mode", ",", "dummy", ",", "valtype", ")", ";", "case", "MODE_COMPLEX_INT", ":", "case", "MODE_VECTOR_INT", ":", "regnum", "=", "0", ";", "break", ";", "case", "MODE_FLOAT", ":", "regnum", "=", "32", ";", "break", ";", "case", "MODE_COMPLEX_FLOAT", ":", "{", "machine_mode", "cmode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "return", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "cmode", ",", "32", ")", ",", "const0_rtx", ")", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "cmode", ",", "33", ")", ",", "GEN_INT", "(", "GET_MODE_SIZE", "(", "cmode", ")", ")", ")", ")", ")", ";", "}", "case", "MODE_RANDOM", ":", "gcc_assert", "(", "TARGET_ABI_OPEN_VMS", "&&", "mode", "==", "BLKmode", ")", ";", "regnum", "=", "0", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "gen_rtx_REG", "(", "mode", ",", "regnum", ")", ";", "}", "</s>"], "natrual_language": ["Handle", "FUNCTION_VALUE", ",", "FUNCTION_OUTGOING_VALUE", ",", "and", "LIBCALL_VALUE", "macros", ".", "For", "v9", ",", "function", "return", "values", "are", "subject", "to", "the", "same", "rules", "as", "arguments", ",", "except", "that", "up", "to", "32", "bytes", "may", "be", "returned", "in", "registers", "."], "TS_V_token": ["alpha", "0", "32", "2", "32", "33", "0"], "File": "alpha4", "Func": "function_value", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40701, "Length": 201}
{"ground_truth": ["<s>", "void", "get_aligned_mem", "(", "rtx", "ref", ",", "rtx", "*", "paligned_mem", ",", "rtx", "*", "pbitnum", ")", "{", "rtx", "base", ";", "HOST_WIDE_INT", "disp", ",", "offset", ";", "gcc_assert", "(", "MEM_P", "(", "ref", ")", ")", ";", "if", "(", "reload_in_progress", "&&", "!", "memory_address_p", "(", "GET_MODE", "(", "ref", ")", ",", "XEXP", "(", "ref", ",", "0", ")", ")", ")", "{", "base", "=", "find_replacement", "(", "&", "XEXP", "(", "ref", ",", "0", ")", ")", ";", "gcc_assert", "(", "memory_address_p", "(", "GET_MODE", "(", "ref", ")", ",", "base", ")", ")", ";", "}", "else", "base", "=", "XEXP", "(", "ref", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", ")", "disp", "=", "INTVAL", "(", "XEXP", "(", "base", ",", "1", ")", ")", ",", "base", "=", "XEXP", "(", "base", ",", "0", ")", ";", "else", "disp", "=", "0", ";", "if", "(", "MEM_ALIGN", "(", "ref", ")", ">=", "32", ")", "offset", "=", "0", ";", "else", "offset", "=", "disp", "&", "3", ";", "gcc_assert", "(", "offset", "+", "GET_MODE_SIZE", "(", "GET_MODE", "(", "ref", ")", ")", "<=", "GET_MODE_SIZE", "(", "SImode", ")", ")", ";", "*", "paligned_mem", "=", "widen_memory_access", "(", "ref", ",", "SImode", ",", "-", "offset", ")", ";", "offset", "*=", "BITS_PER_UNIT", ";", "*", "pbitnum", "=", "GEN_INT", "(", "offset", ")", ";", "}", "</s>"], "natrual_language": ["REF", "is", "an", "alignable", "memory", "location", ".", "Place", "an", "aligned", "SImode", "reference", "into", "*", "PALIGNED_MEM", "and", "the", "number", "of", "bits", "to", "shift", "into", "*", "PBITNUM", ".", "SCRATCH", "is", "a", "free", "register", "for", "use", "in", "reloading", "out", "of", "range", "stack", "slots", "."], "TS_V_token": ["alpha", "0", "0", "0", "1", "0", "0", "32", "0", "3"], "File": "alpha4", "Func": "get_aligned_mem", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40702, "Length": 188}
{"ground_truth": ["<s>", "rtx", "get_unaligned_address", "(", "rtx", "ref", ")", "{", "rtx", "base", ";", "HOST_WIDE_INT", "offset", "=", "0", ";", "gcc_assert", "(", "MEM_P", "(", "ref", ")", ")", ";", "if", "(", "reload_in_progress", "&&", "!", "memory_address_p", "(", "GET_MODE", "(", "ref", ")", ",", "XEXP", "(", "ref", ",", "0", ")", ")", ")", "{", "base", "=", "find_replacement", "(", "&", "XEXP", "(", "ref", ",", "0", ")", ")", ";", "gcc_assert", "(", "memory_address_p", "(", "GET_MODE", "(", "ref", ")", ",", "base", ")", ")", ";", "}", "else", "base", "=", "XEXP", "(", "ref", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", ")", "offset", "+=", "INTVAL", "(", "XEXP", "(", "base", ",", "1", ")", ")", ",", "base", "=", "XEXP", "(", "base", ",", "0", ")", ";", "return", "plus_constant", "(", "Pmode", ",", "base", ",", "offset", ")", ";", "}", "</s>"], "natrual_language": ["Similar", ",", "but", "just", "get", "the", "address", ".", "Handle", "the", "two", "reload", "cases", ".", "Add", "EXTRA_OFFSET", "to", "the", "address", "we", "return", "."], "TS_V_token": ["alpha", "0", "0", "0", "0", "1", "0"], "File": "alpha4", "Func": "get_unaligned_address", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40703, "Length": 122}
{"ground_truth": ["<s>", "void", "print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "int", "basereg", "=", "31", ";", "HOST_WIDE_INT", "offset", "=", "0", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "AND", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ")", "{", "offset", "=", "INTVAL", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "addr", ")", "==", "LO_SUM", ")", "{", "const", "char", "*", "reloc16", ",", "*", "reloclo", ";", "rtx", "op1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "op1", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "op1", ",", "0", ")", ")", "==", "UNSPEC", ")", "{", "op1", "=", "XEXP", "(", "op1", ",", "0", ")", ";", "switch", "(", "XINT", "(", "op1", ",", "1", ")", ")", "{", "case", "UNSPEC_DTPREL", ":", "reloc16", "=", "NULL", ";", "reloclo", "=", "(", "alpha_tls_size", "==", "16", "?", "\"dtprel\"", ":", "\"dtprello\"", ")", ";", "break", ";", "case", "UNSPEC_TPREL", ":", "reloc16", "=", "NULL", ";", "reloclo", "=", "(", "alpha_tls_size", "==", "16", "?", "\"tprel\"", ":", "\"tprello\"", ")", ";", "break", ";", "default", ":", "output_operand_lossage", "(", "\"unknown relocation unspec\"", ")", ";", "return", ";", "}", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "op1", ",", "0", ",", "0", ")", ")", ";", "}", "else", "{", "reloc16", "=", "\"gprel\"", ";", "reloclo", "=", "\"gprellow\"", ";", "output_addr_const", "(", "file", ",", "op1", ")", ";", "}", "if", "(", "offset", ")", "fprintf", "(", "file", ",", "\"+\"", "HOST_WIDE_INT_PRINT_DEC", ",", "offset", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "basereg", "=", "REGNO", "(", "addr", ")", ";", "break", ";", "case", "SUBREG", ":", "basereg", "=", "subreg_regno", "(", "addr", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "fprintf", "(", "file", ",", "\"($%d)\\t\\t!%s\"", ",", "basereg", ",", "(", "basereg", "==", "29", "?", "reloc16", ":", "reloclo", ")", ")", ";", "return", ";", "}", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "basereg", "=", "REGNO", "(", "addr", ")", ";", "break", ";", "case", "SUBREG", ":", "basereg", "=", "subreg_regno", "(", "addr", ")", ";", "break", ";", "case", "CONST_INT", ":", "offset", "=", "INTVAL", "(", "addr", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "gcc_assert", "(", "TARGET_ABI_OPEN_VMS", "||", "this_is_asm_operands", ")", ";", "fprintf", "(", "file", ",", "\"%s\"", ",", "XSTR", "(", "addr", ",", "0", ")", ")", ";", "return", ";", "case", "CONST", ":", "gcc_assert", "(", "TARGET_ABI_OPEN_VMS", "||", "this_is_asm_operands", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", ";", "fprintf", "(", "file", ",", "\"%s+\"", "HOST_WIDE_INT_PRINT_DEC", ",", "XSTR", "(", "XEXP", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ",", "0", ")", ",", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "1", ")", ")", ")", ";", "return", ";", "default", ":", "output_operand_lossage", "(", "\"invalid operand address\"", ")", ";", "return", ";", "}", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", "\"($%d)\"", ",", "offset", ",", "basereg", ")", ";", "}", "</s>"], "natrual_language": ["Print", "the", "operand", "address", "represented", "by", "the", "rtx", "addr"], "TS_V_token": ["alpha", "31", "0", "0", "1", "1", "0", "1", "0", "0", "1", "16", "\"dtprel\"", "\"dtprello\"", "16", "\"tprel\"", "\"tprello\"", "\"unknown relocation unspec\"", "0", "0", "\"gprel\"", "\"gprellow\"", "\"+\"", "0", "\"($%d)\\t\\t!%s\"", "29", "\"%s\"", "0", "0", "0", "0", "\"%s+\"", "0", "0", "0", "0", "1", "\"invalid operand address\"", "\"($%d)\""], "File": "alpha4", "Func": "print_operand_address", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40704, "Length": 496}
{"ground_truth": ["<s>", "rtx", "resolve_reload_operand", "(", "rtx", "op", ")", "{", "if", "(", "reload_in_progress", ")", "{", "rtx", "tmp", "=", "op", ";", "if", "(", "GET_CODE", "(", "tmp", ")", "==", "SUBREG", ")", "tmp", "=", "SUBREG_REG", "(", "tmp", ")", ";", "if", "(", "REG_P", "(", "tmp", ")", "&&", "REGNO", "(", "tmp", ")", ">=", "FIRST_PSEUDO_REGISTER", ")", "{", "op", "=", "reg_equiv_memory_loc", "(", "REGNO", "(", "tmp", ")", ")", ";", "if", "(", "op", "==", "0", ")", "return", "0", ";", "}", "}", "return", "op", ";", "}", "</s>"], "natrual_language": ["Used", "by", "aligned_memory_operand", "and", "unaligned_memory_operand", "to", "resolve", "what", "reload", "is", "going", "to", "do", "with", "OP", "if", "it", "'s", "a", "register", "."], "TS_V_token": ["alpha", "0", "0"], "File": "alpha4", "Func": "resolve_reload_operand", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40705, "Length": 73}
{"ground_truth": ["<s>", "static", "gimple", "va_list_skip_additions", "(", "tree", "lhs", ")", "{", "gimple", "stmt", ";", "for", "(", ";", ";", ")", "{", "enum", "tree_code", "code", ";", "stmt", "=", "SSA_NAME_DEF_STMT", "(", "lhs", ")", ";", "if", "(", "gimple_code", "(", "stmt", ")", "==", "GIMPLE_PHI", ")", "return", "stmt", ";", "if", "(", "!", "is_gimple_assign", "(", "stmt", ")", "||", "gimple_assign_lhs", "(", "stmt", ")", "!=", "lhs", ")", "return", "NULL", ";", "if", "(", "TREE_CODE", "(", "gimple_assign_rhs1", "(", "stmt", ")", ")", "!=", "SSA_NAME", ")", "return", "stmt", ";", "code", "=", "gimple_assign_rhs_code", "(", "stmt", ")", ";", "if", "(", "!", "CONVERT_EXPR_CODE_P", "(", "code", ")", "&&", "(", "(", "code", "!=", "PLUS_EXPR", "&&", "code", "!=", "POINTER_PLUS_EXPR", ")", "||", "TREE_CODE", "(", "gimple_assign_rhs2", "(", "stmt", ")", ")", "!=", "INTEGER_CST", "||", "!", "tree_fits_uhwi_p", "(", "gimple_assign_rhs2", "(", "stmt", ")", ")", ")", ")", "return", "stmt", ";", "lhs", "=", "gimple_assign_rhs1", "(", "stmt", ")", ";", "}", "}", "</s>"], "natrual_language": ["Helper", "function", "for", "alpha_stdarg_optimize_hook", ".", "Skip", "over", "casts", "and", "constant", "additions", "."], "TS_V_token": ["alpha"], "File": "alpha4", "Func": "va_list_skip_additions", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40706, "Length": 131}
{"ground_truth": ["<s>", "static", "void", "alpha_emit_xfloating_libcall", "(", "rtx", "func", ",", "rtx", "target", ",", "rtx", "operands", "[", "]", ",", "int", "noperands", ",", "rtx", "equiv", ")", "{", "rtx", "usage", "=", "NULL_RTX", ",", "tmp", ",", "reg", ";", "int", "regno", "=", "16", ",", "i", ";", "start_sequence", "(", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "noperands", ";", "++", "i", ")", "{", "switch", "(", "GET_MODE", "(", "operands", "[", "i", "]", ")", ")", "{", "case", "TFmode", ":", "reg", "=", "gen_rtx_REG", "(", "TFmode", ",", "regno", ")", ";", "regno", "+=", "2", ";", "break", ";", "case", "DFmode", ":", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "regno", "+", "32", ")", ";", "regno", "+=", "1", ";", "break", ";", "case", "VOIDmode", ":", "gcc_assert", "(", "CONST_INT_P", "(", "operands", "[", "i", "]", ")", ")", ";", "case", "DImode", ":", "reg", "=", "gen_rtx_REG", "(", "DImode", ",", "regno", ")", ";", "regno", "+=", "1", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_move_insn", "(", "reg", ",", "operands", "[", "i", "]", ")", ";", "use_reg", "(", "&", "usage", ",", "reg", ")", ";", "}", "switch", "(", "GET_MODE", "(", "target", ")", ")", "{", "case", "TFmode", ":", "reg", "=", "gen_rtx_REG", "(", "TFmode", ",", "16", ")", ";", "break", ";", "case", "DFmode", ":", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "32", ")", ";", "break", ";", "case", "DImode", ":", "reg", "=", "gen_rtx_REG", "(", "DImode", ",", "0", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "tmp", "=", "gen_rtx_MEM", "(", "QImode", ",", "func", ")", ";", "tmp", "=", "emit_call_insn", "(", "gen_call_value", "(", "reg", ",", "tmp", ",", "const0_rtx", ",", "const0_rtx", ",", "const0_rtx", ")", ")", ";", "CALL_INSN_FUNCTION_USAGE", "(", "tmp", ")", "=", "usage", ";", "RTL_CONST_CALL_P", "(", "tmp", ")", "=", "1", ";", "tmp", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "emit_libcall_block", "(", "tmp", ",", "target", ",", "reg", ",", "equiv", ")", ";", "}", "</s>"], "natrual_language": ["Emit", "an", "X_floating", "library", "function", "call", ".", "Note", "that", "these", "functions", "do", "not", "follow", "normal", "calling", "conventions", ":", "TFmode", "arguments", "are", "passed", "in", "two", "integer", "registers", "(", "as", "opposed", "to", "indirect", ")", ";", "TFmode", "return", "values", "appear", "in", "R16+R17", ".", "FUNC", "is", "the", "function", "name", "to", "call", ".", "TARGET", "is", "where", "the", "output", "belongs", ".", "OPERANDS", "are", "the", "inputs", ".", "NOPERANDS", "is", "the", "count", "of", "inputs", ".", "EQUIV", "is", "the", "expression", "equivalent", "for", "the", "function", "."], "TS_V_token": ["alpha", "16", "0", "2", "32", "1", "1", "16", "32", "0", "1"], "File": "alpha5", "Func": "alpha_emit_xfloating_libcall", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40707, "Length": 283}
{"ground_truth": ["<s>", "static", "rtx", "alpha_function_arg", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "basereg", ";", "int", "num_args", ";", "if", "(", "type", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "basereg", "=", "16", ";", "else", "{", "gcc_checking_assert", "(", "!", "COMPLEX_MODE_P", "(", "mode", ")", ")", ";", "if", "(", "TARGET_FPREGS", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", "basereg", "=", "32", "+", "16", ";", "else", "basereg", "=", "16", ";", "}", "{", "if", "(", "mode", "==", "VOIDmode", ")", "return", "alpha_arg_info_reg_val", "(", "*", "cum", ")", ";", "num_args", "=", "cum", "->", "num_args", ";", "if", "(", "num_args", ">=", "6", "||", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "return", "NULL_RTX", ";", "}", "{", "if", "(", "*", "cum", ">=", "6", ")", "return", "NULL_RTX", ";", "num_args", "=", "*", "cum", ";", "if", "(", "type", "==", "void_type_node", ")", "basereg", "=", "16", ";", "else", "if", "(", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "return", "NULL_RTX", ";", "}", "return", "gen_rtx_REG", "(", "mode", ",", "num_args", "+", "basereg", ")", ";", "}", "</s>"], "natrual_language": ["Determine", "where", "to", "put", "an", "argument", "to", "a", "function", ".", "Value", "is", "zero", "to", "push", "the", "argument", "on", "the", "stack", ",", "or", "a", "hard", "register", "in", "which", "to", "store", "the", "argument", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "CUM", "is", "a", "variable", "of", "type", "CUMULATIVE_ARGS", "which", "gives", "info", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "NAMED", "is", "nonzero", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", ".", "On", "Alpha", "the", "first", "6", "words", "of", "args", "are", "normally", "in", "registers", "and", "the", "rest", "are", "pushed", "."], "TS_V_token": ["alpha", "16", "32", "16", "16", "6", "6", "16"], "File": "alpha5", "Func": "alpha_function_arg", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40708, "Length": 176}
{"ground_truth": ["<s>", "static", "void", "alpha_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", ")", ";", "bool", "onstack", "=", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ";", "int", "increment", "=", "onstack", "?", "6", ":", "ALPHA_ARG_SIZE", "(", "mode", ",", "type", ")", ";", "*", "cum", "+=", "increment", ";", "if", "(", "!", "onstack", "&&", "cum", "->", "num_args", "<", "6", ")", "cum", "->", "atypes", "[", "cum", "->", "num_args", "]", "=", "alpha_arg_type", "(", "mode", ")", ";", "cum", "->", "num_args", "+=", "increment", ";", "}", "</s>"], "natrual_language": ["Update", "the", "data", "in", "CUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "(", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", ")"], "TS_V_token": ["alpha", "6", "6"], "File": "alpha5", "Func": "alpha_function_arg_advance", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40709, "Length": 92}
{"ground_truth": ["<s>", "static", "void", "alpha_output_mi_thunk_osf", "(", "FILE", "*", "file", ",", "tree", "thunk_fndecl", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "HOST_WIDE_INT", "hi", ",", "lo", ";", "rtx", "this_rtx", ",", "funexp", ";", "rtx_insn", "*", "insn", ";", "emit_insn", "(", "gen_prologue_ldgp", "(", ")", ")", ";", "emit_note", "(", "NOTE_INSN_PROLOGUE_END", ")", ";", "if", "(", "aggregate_value_p", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "function", ")", ")", ",", "function", ")", ")", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "17", ")", ";", "else", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "16", ")", ";", "lo", "=", "(", "(", "delta", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "hi", "=", "(", "(", "(", "delta", "-", "lo", ")", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "if", "(", "hi", "+", "lo", "==", "delta", ")", "{", "if", "(", "hi", ")", "emit_insn", "(", "gen_adddi3", "(", "this_rtx", ",", "this_rtx", ",", "GEN_INT", "(", "hi", ")", ")", ")", ";", "if", "(", "lo", ")", "emit_insn", "(", "gen_adddi3", "(", "this_rtx", ",", "this_rtx", ",", "GEN_INT", "(", "lo", ")", ")", ")", ";", "}", "else", "{", "rtx", "tmp", "=", "alpha_emit_set_long_const", "(", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ",", "delta", ")", ";", "emit_insn", "(", "gen_adddi3", "(", "this_rtx", ",", "this_rtx", ",", "tmp", ")", ")", ";", "}", "if", "(", "vcall_offset", ")", "{", "rtx", "tmp", ",", "tmp2", ";", "tmp", "=", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ";", "emit_move_insn", "(", "tmp", ",", "gen_rtx_MEM", "(", "Pmode", ",", "this_rtx", ")", ")", ";", "lo", "=", "(", "(", "vcall_offset", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "hi", "=", "(", "(", "(", "vcall_offset", "-", "lo", ")", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "if", "(", "hi", "+", "lo", "==", "vcall_offset", ")", "{", "if", "(", "hi", ")", "emit_insn", "(", "gen_adddi3", "(", "tmp", ",", "tmp", ",", "GEN_INT", "(", "hi", ")", ")", ")", ";", "}", "else", "{", "tmp2", "=", "alpha_emit_set_long_const", "(", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ",", "vcall_offset", ")", ";", "emit_insn", "(", "gen_adddi3", "(", "tmp", ",", "tmp", ",", "tmp2", ")", ")", ";", "lo", "=", "0", ";", "}", "if", "(", "lo", ")", "tmp2", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "tmp", ",", "GEN_INT", "(", "lo", ")", ")", ";", "else", "tmp2", "=", "tmp", ";", "emit_move_insn", "(", "tmp", ",", "gen_rtx_MEM", "(", "Pmode", ",", "tmp2", ")", ")", ";", "emit_insn", "(", "gen_adddi3", "(", "this_rtx", ",", "this_rtx", ",", "tmp", ")", ")", ";", "}", "if", "(", "!", "TREE_USED", "(", "function", ")", ")", "{", "assemble_external", "(", "function", ")", ";", "TREE_USED", "(", "function", ")", "=", "1", ";", "}", "funexp", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ";", "funexp", "=", "gen_rtx_MEM", "(", "FUNCTION_MODE", ",", "funexp", ")", ";", "insn", "=", "emit_call_insn", "(", "gen_sibcall", "(", "funexp", ",", "const0_rtx", ")", ")", ";", "SIBLING_CALL_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "get_insns", "(", ")", ";", "shorten_branches", "(", "insn", ")", ";", "final_start_function", "(", "insn", ",", "file", ",", "1", ")", ";", "final", "(", "insn", ",", "file", ",", "1", ")", ";", "final_end_function", "(", ")", ";", "}", "</s>"], "natrual_language": ["Emit", "a", "tail", "call", "to", "FUNCTION", "after", "adjusting", "THIS", "by", "DELTA", ".", "In", "order", "to", "avoid", "the", "hordes", "of", "differences", "between", "generated", "code", "with", "and", "without", "TARGET_EXPLICIT_RELOCS", ",", "and", "to", "avoid", "duplicating", "lots", "of", "code", "loading", "up", "large", "constants", ",", "generate", "rtl", "and", "emit", "it", "instead", "of", "going", "straight", "to", "text", ".", "Not", "sure", "why", "this", "idea", "has", "n't", "been", "explored", "before", "..."], "TS_V_token": ["alpha", "17", "16", "0xffff", "0x8000", "0x8000", "0xffffffff", "0x80000000", "0x80000000", "0", "0", "0xffff", "0x8000", "0x8000", "0xffffffff", "0x80000000", "0x80000000", "1", "0", "1", "0", "1", "1", "1"], "File": "alpha5", "Func": "alpha_output_mi_thunk_osf", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40710, "Length": 461}
{"ground_truth": ["<s>", "static", "void", "alpha_override_options_after_change", "(", "void", ")", "{", "if", "(", "optimize", ">", "0", ")", "{", "if", "(", "align_loops", "<=", "0", ")", "align_loops", "=", "16", ";", "if", "(", "align_jumps", "<=", "0", ")", "align_jumps", "=", "16", ";", "}", "if", "(", "align_functions", "<=", "0", ")", "align_functions", "=", "16", ";", "}", "</s>"], "natrual_language": ["Implement", "targetm.override_options_after_change", "."], "TS_V_token": ["alpha", "0", "0", "16", "0", "16", "0", "16"], "File": "alpha5", "Func": "alpha_override_options_after_change", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40711, "Length": 46}
{"ground_truth": ["<s>", "void", "alpha_split_atomic_op", "(", "enum", "rtx_code", "code", ",", "rtx", "mem", ",", "rtx", "val", ",", "rtx", "before", ",", "rtx", "after", ",", "rtx", "scratch", ",", "enum", "memmodel", "model", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "rtx", "label", ",", "x", ",", "cond", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "scratch", ")", ")", ";", "alpha_pre_atomic_barrier", "(", "model", ")", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label", ")", ";", "label", "=", "gen_rtx_LABEL_REF", "(", "DImode", ",", "label", ")", ";", "if", "(", "before", "==", "NULL", ")", "before", "=", "scratch", ";", "emit_load_locked", "(", "mode", ",", "before", ",", "mem", ")", ";", "if", "(", "code", "==", "NOT", ")", "{", "x", "=", "gen_rtx_AND", "(", "mode", ",", "before", ",", "val", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "val", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_NOT", "(", "mode", ",", "val", ")", ";", "}", "else", "x", "=", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "before", ",", "val", ")", ";", "if", "(", "after", ")", "emit_insn", "(", "gen_rtx_SET", "(", "after", ",", "copy_rtx", "(", "x", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "scratch", ",", "x", ")", ")", ";", "emit_store_conditional", "(", "mode", ",", "cond", ",", "mem", ",", "scratch", ")", ";", "x", "=", "gen_rtx_EQ", "(", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_unlikely_jump", "(", "x", ",", "label", ")", ";", "alpha_post_atomic_barrier", "(", "model", ")", ";", "}", "</s>"], "natrual_language": ["Expand", "an", "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", ".", "SCRATCH", "is", "a", "scratch", "register", "."], "TS_V_token": ["alpha"], "File": "alpha5", "Func": "alpha_split_atomic_op", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40712, "Length": 210}
{"ground_truth": ["<s>", "void", "alpha_split_compare_and_swap", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "cond", ",", "retval", ",", "mem", ",", "oldval", ",", "newval", ";", "bool", "is_weak", ";", "enum", "memmodel", "mod_s", ",", "mod_f", ";", "machine_mode", "mode", ";", "rtx", "label1", ",", "label2", ",", "x", ";", "cond", "=", "operands", "[", "0", "]", ";", "retval", "=", "operands", "[", "1", "]", ";", "mem", "=", "operands", "[", "2", "]", ";", "oldval", "=", "operands", "[", "3", "]", ";", "newval", "=", "operands", "[", "4", "]", ";", "is_weak", "=", "(", "operands", "[", "5", "]", "!=", "const0_rtx", ")", ";", "mod_s", "=", "memmodel_from_int", "(", "INTVAL", "(", "operands", "[", "6", "]", ")", ")", ";", "mod_f", "=", "memmodel_from_int", "(", "INTVAL", "(", "operands", "[", "7", "]", ")", ")", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "alpha_pre_atomic_barrier", "(", "mod_s", ")", ";", "label1", "=", "NULL_RTX", ";", "if", "(", "!", "is_weak", ")", "{", "label1", "=", "gen_rtx_LABEL_REF", "(", "DImode", ",", "gen_label_rtx", "(", ")", ")", ";", "emit_label", "(", "XEXP", "(", "label1", ",", "0", ")", ")", ";", "}", "label2", "=", "gen_rtx_LABEL_REF", "(", "DImode", ",", "gen_label_rtx", "(", ")", ")", ";", "emit_load_locked", "(", "mode", ",", "retval", ",", "mem", ")", ";", "x", "=", "gen_lowpart", "(", "DImode", ",", "retval", ")", ";", "if", "(", "oldval", "==", "const0_rtx", ")", "{", "emit_move_insn", "(", "cond", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_NE", "(", "DImode", ",", "x", ",", "const0_rtx", ")", ";", "}", "else", "{", "x", "=", "gen_rtx_EQ", "(", "DImode", ",", "x", ",", "oldval", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "cond", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_EQ", "(", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "}", "emit_unlikely_jump", "(", "x", ",", "label2", ")", ";", "emit_move_insn", "(", "cond", ",", "newval", ")", ";", "emit_store_conditional", "(", "mode", ",", "cond", ",", "mem", ",", "gen_lowpart", "(", "mode", ",", "cond", ")", ")", ";", "if", "(", "!", "is_weak", ")", "{", "x", "=", "gen_rtx_EQ", "(", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_unlikely_jump", "(", "x", ",", "label1", ")", ";", "}", "if", "(", "!", "is_mm_relaxed", "(", "mod_f", ")", ")", "emit_label", "(", "XEXP", "(", "label2", ",", "0", ")", ")", ";", "alpha_post_atomic_barrier", "(", "mod_s", ")", ";", "if", "(", "is_mm_relaxed", "(", "mod_f", ")", ")", "emit_label", "(", "XEXP", "(", "label2", ",", "0", ")", ")", ";", "}", "</s>"], "natrual_language": ["Expand", "a", "compare", "and", "swap", "operation", "."], "TS_V_token": ["alpha", "0", "1", "2", "3", "4", "5", "6", "7", "0", "0", "0"], "File": "alpha5", "Func": "alpha_split_compare_and_swap", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40713, "Length": 341}
{"ground_truth": ["<s>", "int", "alpha_split_conditional_move", "(", "enum", "rtx_code", "code", ",", "rtx", "dest", ",", "rtx", "cond", ",", "rtx", "t_rtx", ",", "rtx", "f_rtx", ")", "{", "HOST_WIDE_INT", "t", ",", "f", ",", "diff", ";", "machine_mode", "mode", ";", "rtx", "target", ",", "subtarget", ",", "tmp", ";", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "t", "=", "INTVAL", "(", "t_rtx", ")", ";", "f", "=", "INTVAL", "(", "f_rtx", ")", ";", "diff", "=", "t", "-", "f", ";", "if", "(", "(", "(", "code", "==", "NE", "||", "code", "==", "EQ", ")", "&&", "diff", "<", "0", ")", "||", "(", "code", "==", "GE", "||", "code", "==", "GT", ")", ")", "{", "code", "=", "reverse_condition", "(", "code", ")", ";", "diff", "=", "t", ",", "t", "=", "f", ",", "f", "=", "diff", ";", "diff", "=", "t", "-", "f", ";", "}", "subtarget", "=", "target", "=", "dest", ";", "if", "(", "mode", "!=", "DImode", ")", "{", "target", "=", "gen_lowpart", "(", "DImode", ",", "dest", ")", ";", "if", "(", "can_create_pseudo_p", "(", ")", ")", "subtarget", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "else", "subtarget", "=", "target", ";", "}", "if", "(", "f", "==", "0", "&&", "exact_log2", "(", "diff", ")", ">", "0", "&&", "(", "diff", "<=", "8", "||", "alpha_tune", "==", "PROCESSOR_EV6", ")", ")", "{", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "copy_rtx", "(", "subtarget", ")", ",", "tmp", ")", ")", ";", "tmp", "=", "gen_rtx_ASHIFT", "(", "DImode", ",", "copy_rtx", "(", "subtarget", ")", ",", "GEN_INT", "(", "exact_log2", "(", "t", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "tmp", ")", ")", ";", "}", "else", "if", "(", "f", "==", "0", "&&", "t", "==", "-", "1", ")", "{", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "copy_rtx", "(", "subtarget", ")", ",", "tmp", ")", ")", ";", "emit_insn", "(", "gen_negdi2", "(", "target", ",", "copy_rtx", "(", "subtarget", ")", ")", ")", ";", "}", "else", "if", "(", "diff", "==", "1", "||", "diff", "==", "4", "||", "diff", "==", "8", ")", "{", "rtx", "add_op", ";", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "copy_rtx", "(", "subtarget", ")", ",", "tmp", ")", ")", ";", "if", "(", "diff", "==", "1", ")", "emit_insn", "(", "gen_adddi3", "(", "target", ",", "copy_rtx", "(", "subtarget", ")", ",", "GEN_INT", "(", "f", ")", ")", ")", ";", "else", "{", "add_op", "=", "GEN_INT", "(", "f", ")", ";", "if", "(", "sext_add_operand", "(", "add_op", ",", "mode", ")", ")", "{", "tmp", "=", "gen_rtx_MULT", "(", "DImode", ",", "copy_rtx", "(", "subtarget", ")", ",", "GEN_INT", "(", "diff", ")", ")", ";", "tmp", "=", "gen_rtx_PLUS", "(", "DImode", ",", "tmp", ",", "add_op", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "tmp", ")", ")", ";", "}", "else", "return", "0", ";", "}", "}", "else", "return", "0", ";", "return", "1", ";", "}", "</s>"], "natrual_language": ["Simplify", "a", "conditional", "move", "of", "two", "constants", "into", "a", "setcc", "with", "arithmetic", ".", "This", "is", "done", "with", "a", "splitter", "since", "combine", "would", "just", "undo", "the", "work", "if", "done", "during", "code", "generation", ".", "It", "also", "catches", "cases", "we", "would", "n't", "have", "before", "cse", "."], "TS_V_token": ["alpha", "0", "0", "0", "8", "0", "1", "1", "4", "8", "1", "0", "0", "1"], "File": "alpha5", "Func": "alpha_split_conditional_move", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40714, "Length": 435}
{"ground_truth": ["<s>", "static", "void", "emit_unlikely_jump", "(", "rtx", "cond", ",", "rtx", "label", ")", "{", "int", "very_unlikely", "=", "REG_BR_PROB_BASE", "/", "100", "-", "1", ";", "rtx", "x", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "cond", ",", "label", ",", "pc_rtx", ")", ";", "x", "=", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "x", ")", ")", ";", "add_int_reg_note", "(", "x", ",", "REG_BR_PROB", ",", "very_unlikely", ")", ";", "}", "</s>"], "natrual_language": ["Mark", "the", "previous", "jump", "instruction", "as", "unlikely", "."], "TS_V_token": ["alpha", "100", "1"], "File": "alpha5", "Func": "emit_unlikely_jump", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40715, "Length": 58}
{"ground_truth": ["<s>", "static", "void", "alpha_emit_xfloating_libcall", "(", "rtx", "func", ",", "rtx", "target", ",", "rtx", "operands", "[", "]", ",", "int", "noperands", ",", "rtx", "equiv", ")", "{", "rtx", "usage", "=", "NULL_RTX", ",", "reg", ";", "int", "regno", "=", "16", ",", "i", ";", "start_sequence", "(", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "noperands", ";", "++", "i", ")", "{", "switch", "(", "GET_MODE", "(", "operands", "[", "i", "]", ")", ")", "{", "case", "TFmode", ":", "reg", "=", "gen_rtx_REG", "(", "TFmode", ",", "regno", ")", ";", "regno", "+=", "2", ";", "break", ";", "case", "DFmode", ":", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "regno", "+", "32", ")", ";", "regno", "+=", "1", ";", "break", ";", "case", "VOIDmode", ":", "gcc_assert", "(", "CONST_INT_P", "(", "operands", "[", "i", "]", ")", ")", ";", "case", "DImode", ":", "reg", "=", "gen_rtx_REG", "(", "DImode", ",", "regno", ")", ";", "regno", "+=", "1", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_move_insn", "(", "reg", ",", "operands", "[", "i", "]", ")", ";", "use_reg", "(", "&", "usage", ",", "reg", ")", ";", "}", "switch", "(", "GET_MODE", "(", "target", ")", ")", "{", "case", "TFmode", ":", "reg", "=", "gen_rtx_REG", "(", "TFmode", ",", "16", ")", ";", "break", ";", "case", "DFmode", ":", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "32", ")", ";", "break", ";", "case", "DImode", ":", "reg", "=", "gen_rtx_REG", "(", "DImode", ",", "0", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "rtx", "mem", "=", "gen_rtx_MEM", "(", "QImode", ",", "func", ")", ";", "rtx_insn", "*", "tmp", "=", "emit_call_insn", "(", "gen_call_value", "(", "reg", ",", "mem", ",", "const0_rtx", ",", "const0_rtx", ",", "const0_rtx", ")", ")", ";", "CALL_INSN_FUNCTION_USAGE", "(", "tmp", ")", "=", "usage", ";", "RTL_CONST_CALL_P", "(", "tmp", ")", "=", "1", ";", "tmp", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "emit_libcall_block", "(", "tmp", ",", "target", ",", "reg", ",", "equiv", ")", ";", "}", "</s>"], "natrual_language": ["Emit", "an", "X_floating", "library", "function", "call", ".", "Note", "that", "these", "functions", "do", "not", "follow", "normal", "calling", "conventions", ":", "TFmode", "arguments", "are", "passed", "in", "two", "integer", "registers", "(", "as", "opposed", "to", "indirect", ")", ";", "TFmode", "return", "values", "appear", "in", "R16+R17", ".", "FUNC", "is", "the", "function", "name", "to", "call", ".", "TARGET", "is", "where", "the", "output", "belongs", ".", "OPERANDS", "are", "the", "inputs", ".", "NOPERANDS", "is", "the", "count", "of", "inputs", ".", "EQUIV", "is", "the", "expression", "equivalent", "for", "the", "function", "."], "TS_V_token": ["alpha", "16", "0", "2", "32", "1", "1", "16", "32", "0", "1"], "File": "alpha6", "Func": "alpha_emit_xfloating_libcall", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40716, "Length": 284}
{"ground_truth": ["<s>", "static", "bool", "alpha_pass_by_reference", "(", "cumulative_args_t", "ca", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "bool", "named", ")", "{", "if", "(", "mode", "==", "SFmode", "||", "mode", "==", "SCmode", ")", "return", "!", "named", ";", "return", "mode", "==", "TFmode", "||", "mode", "==", "TCmode", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "TYPE", "should", "be", "passed", "by", "invisible", "reference", "."], "TS_V_token": ["alpha"], "File": "alpha6", "Func": "alpha_pass_by_reference", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40717, "Length": 43}
{"ground_truth": ["<s>", "static", "void", "emit_unlikely_jump", "(", "rtx", "cond", ",", "rtx", "label", ")", "{", "int", "very_unlikely", "=", "REG_BR_PROB_BASE", "/", "100", "-", "1", ";", "rtx", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "cond", ",", "label", ",", "pc_rtx", ")", ";", "rtx_insn", "*", "insn", "=", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "x", ")", ")", ";", "add_int_reg_note", "(", "insn", ",", "REG_BR_PROB", ",", "very_unlikely", ")", ";", "}", "</s>"], "natrual_language": ["Mark", "the", "previous", "jump", "instruction", "as", "unlikely", "."], "TS_V_token": ["alpha", "100", "1"], "File": "alpha6", "Func": "emit_unlikely_jump", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40718, "Length": 58}
{"ground_truth": ["<s>", "static", "rtx_insn", "*", "alphaev4_next_group", "(", "rtx_insn", "*", "insn", ",", "int", "*", "pin_use", ",", "int", "*", "plen", ")", "{", "int", "len", ",", "in_use", ";", "len", "=", "in_use", "=", "0", ";", "if", "(", "!", "INSN_P", "(", "insn", ")", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", ")", "goto", "next_and_done", ";", "while", "(", "1", ")", "{", "enum", "alphaev4_pipe", "pipe", ";", "pipe", "=", "alphaev4_insn_pipe", "(", "insn", ")", ";", "switch", "(", "pipe", ")", "{", "case", "EV4_STOP", ":", "if", "(", "in_use", ")", "goto", "done", ";", "if", "(", "recog_memoized", "(", "insn", ")", "<", "0", ")", "len", "=", "-", "1", ";", "else", "len", "=", "get_attr_length", "(", "insn", ")", ";", "goto", "next_and_done", ";", "case", "EV4_IBX", ":", "if", "(", "in_use", "&", "EV4_IB0", ")", "{", "if", "(", "in_use", "&", "EV4_IB1", ")", "goto", "done", ";", "in_use", "|=", "EV4_IB1", ";", "}", "else", "in_use", "|=", "EV4_IB0", "|", "EV4_IBX", ";", "break", ";", "case", "EV4_IB0", ":", "if", "(", "in_use", "&", "EV4_IB0", ")", "{", "if", "(", "!", "(", "in_use", "&", "EV4_IBX", ")", "||", "(", "in_use", "&", "EV4_IB1", ")", ")", "goto", "done", ";", "in_use", "|=", "EV4_IB1", ";", "}", "in_use", "|=", "EV4_IB0", ";", "break", ";", "case", "EV4_IB1", ":", "if", "(", "in_use", "&", "EV4_IB1", ")", "goto", "done", ";", "in_use", "|=", "EV4_IB1", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "len", "+=", "4", ";", "if", "(", "JUMP_P", "(", "insn", ")", ")", "goto", "next_and_done", ";", "next", ":", "insn", "=", "next_nonnote_insn", "(", "insn", ")", ";", "if", "(", "!", "insn", "||", "!", "INSN_P", "(", "insn", ")", ")", "goto", "done", ";", "if", "(", "GET_MODE", "(", "insn", ")", "==", "TImode", ")", "goto", "done", ";", "if", "(", "GET_CODE", "(", "insn", ")", "==", "CLOBBER", "||", "GET_CODE", "(", "insn", ")", "==", "USE", ")", "goto", "next", ";", "}", "next_and_done", ":", "insn", "=", "next_nonnote_insn", "(", "insn", ")", ";", "done", ":", "*", "plen", "=", "len", ";", "*", "pin_use", "=", "in_use", ";", "return", "insn", ";", "}", "</s>"], "natrual_language": ["IN_USE", "is", "a", "mask", "of", "the", "slots", "currently", "filled", "within", "the", "insn", "group", ".", "The", "mask", "bits", "come", "from", "alphaev4_pipe", "above", ".", "If", "EV4_IBX", "is", "set", ",", "then", "the", "insn", "in", "EV4_IB0", "can", "be", "swapped", "by", "the", "hardware", "into", "EV4_IB1", ".", "LEN", "is", ",", "of", "course", ",", "the", "length", "of", "the", "group", "in", "bytes", "."], "TS_V_token": ["alpha", "0", "1", "0", "1", "4"], "File": "alpha", "Func": "alphaev4_next_group", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40719, "Length": 307}
{"ground_truth": ["<s>", "static", "rtx_insn", "*", "alphaev5_next_group", "(", "rtx_insn", "*", "insn", ",", "int", "*", "pin_use", ",", "int", "*", "plen", ")", "{", "int", "len", ",", "in_use", ";", "len", "=", "in_use", "=", "0", ";", "if", "(", "!", "INSN_P", "(", "insn", ")", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", ")", "goto", "next_and_done", ";", "while", "(", "1", ")", "{", "enum", "alphaev5_pipe", "pipe", ";", "pipe", "=", "alphaev5_insn_pipe", "(", "insn", ")", ";", "switch", "(", "pipe", ")", "{", "case", "EV5_STOP", ":", "if", "(", "in_use", ")", "goto", "done", ";", "if", "(", "recog_memoized", "(", "insn", ")", "<", "0", ")", "len", "=", "-", "1", ";", "else", "len", "=", "get_attr_length", "(", "insn", ")", ";", "goto", "next_and_done", ";", "case", "EV5_E01", ":", "if", "(", "in_use", "&", "EV5_E0", ")", "{", "if", "(", "in_use", "&", "EV5_E1", ")", "goto", "done", ";", "in_use", "|=", "EV5_E1", ";", "}", "else", "in_use", "|=", "EV5_E0", "|", "EV5_E01", ";", "break", ";", "case", "EV5_E0", ":", "if", "(", "in_use", "&", "EV5_E0", ")", "{", "if", "(", "!", "(", "in_use", "&", "EV5_E01", ")", "||", "(", "in_use", "&", "EV5_E1", ")", ")", "goto", "done", ";", "in_use", "|=", "EV5_E1", ";", "}", "in_use", "|=", "EV5_E0", ";", "break", ";", "case", "EV5_E1", ":", "if", "(", "in_use", "&", "EV5_E1", ")", "goto", "done", ";", "in_use", "|=", "EV5_E1", ";", "break", ";", "case", "EV5_FAM", ":", "if", "(", "in_use", "&", "EV5_FA", ")", "{", "if", "(", "in_use", "&", "EV5_FM", ")", "goto", "done", ";", "in_use", "|=", "EV5_FM", ";", "}", "else", "in_use", "|=", "EV5_FA", "|", "EV5_FAM", ";", "break", ";", "case", "EV5_FA", ":", "if", "(", "in_use", "&", "EV5_FA", ")", "goto", "done", ";", "in_use", "|=", "EV5_FA", ";", "break", ";", "case", "EV5_FM", ":", "if", "(", "in_use", "&", "EV5_FM", ")", "goto", "done", ";", "in_use", "|=", "EV5_FM", ";", "break", ";", "case", "EV5_NONE", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "len", "+=", "4", ";", "if", "(", "JUMP_P", "(", "insn", ")", ")", "goto", "next_and_done", ";", "next", ":", "insn", "=", "next_nonnote_insn", "(", "insn", ")", ";", "if", "(", "!", "insn", "||", "!", "INSN_P", "(", "insn", ")", ")", "goto", "done", ";", "if", "(", "GET_MODE", "(", "insn", ")", "==", "TImode", ")", "goto", "done", ";", "if", "(", "GET_CODE", "(", "insn", ")", "==", "CLOBBER", "||", "GET_CODE", "(", "insn", ")", "==", "USE", ")", "goto", "next", ";", "}", "next_and_done", ":", "insn", "=", "next_nonnote_insn", "(", "insn", ")", ";", "done", ":", "*", "plen", "=", "len", ";", "*", "pin_use", "=", "in_use", ";", "return", "insn", ";", "}", "</s>"], "natrual_language": ["IN_USE", "is", "a", "mask", "of", "the", "slots", "currently", "filled", "within", "the", "insn", "group", ".", "The", "mask", "bits", "come", "from", "alphaev5_pipe", "above", ".", "If", "EV5_E01", "is", "set", ",", "then", "the", "insn", "in", "EV5_E0", "can", "be", "swapped", "by", "the", "hardware", "into", "EV5_E1", ".", "LEN", "is", ",", "of", "course", ",", "the", "length", "of", "the", "group", "in", "bytes", "."], "TS_V_token": ["alpha", "0", "1", "0", "1", "4"], "File": "alpha", "Func": "alphaev5_next_group", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40720, "Length": 381}
{"ground_truth": ["<s>", "static", "void", "alpha_add_builtins", "(", "const", "struct", "alpha_builtin_def", "*", "p", ",", "size_t", "count", ",", "tree", "ftype", ")", "{", "size_t", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "count", ";", "++", "i", ",", "++", "p", ")", "if", "(", "(", "target_flags", "&", "p", "->", "target_mask", ")", "==", "p", "->", "target_mask", ")", "alpha_builtin_function", "(", "p", "->", "name", ",", "ftype", ",", "p", "->", "code", ",", "(", "p", "->", "is_const", "?", "ECF_CONST", ":", "0", ")", "|", "ECF_NOTHROW", ")", ";", "}", "</s>"], "natrual_language": ["Helper", "function", "of", "alpha_init_builtins", ".", "Add", "the", "COUNT", "built-in", "functions", "pointed", "to", "by", "P", ",", "with", "function", "type", "FTYPE", "."], "TS_V_token": ["alpha", "0", "0"], "File": "alpha", "Func": "alpha_add_builtins", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40721, "Length": 76}
{"ground_truth": ["<s>", "static", "int", "alpha_adjust_cost", "(", "rtx_insn", "*", "insn", ",", "int", "dep_type", ",", "rtx_insn", "*", "dep_insn", ",", "int", "cost", ",", "unsigned", "int", ")", "{", "enum", "attr_type", "dep_insn_type", ";", "if", "(", "dep_type", "!=", "0", ")", "return", "cost", ";", "if", "(", "recog_memoized", "(", "insn", ")", "<", "0", "||", "recog_memoized", "(", "dep_insn", ")", "<", "0", ")", "return", "cost", ";", "dep_insn_type", "=", "get_attr_type", "(", "dep_insn", ")", ";", "if", "(", "dep_insn_type", "==", "TYPE_ILD", "||", "dep_insn_type", "==", "TYPE_FLD", "||", "dep_insn_type", "==", "TYPE_LDSYM", ")", "cost", "+=", "alpha_memory_latency", "-", "1", ";", "return", "cost", ";", "}", "</s>"], "natrual_language": ["Adjust", "the", "cost", "of", "a", "scheduling", "dependency", ".", "Return", "the", "new", "cost", "of", "a", "dependency", "LINK", "or", "INSN", "on", "DEP_INSN", ".", "COST", "is", "the", "current", "cost", "."], "TS_V_token": ["alpha", "0", "0", "0", "1"], "File": "alpha", "Func": "alpha_adjust_cost", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40722, "Length": 85}
{"ground_truth": ["<s>", "static", "void", "alpha_align_insns", "(", "void", ")", "{", "if", "(", "alpha_tune", "==", "PROCESSOR_EV4", ")", "alpha_align_insns_1", "(", "8", ",", "alphaev4_next_group", ",", "alphaev4_next_nop", ")", ";", "else", "if", "(", "alpha_tune", "==", "PROCESSOR_EV5", ")", "alpha_align_insns_1", "(", "16", ",", "alphaev5_next_group", ",", "alphaev5_next_nop", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>"], "natrual_language": ["The", "instruction", "group", "alignment", "main", "loop", "."], "TS_V_token": ["alpha", "8", "16"], "File": "alpha", "Func": "alpha_align_insns", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40723, "Length": 44}
{"ground_truth": ["<s>", "rtx", "alpha_arg_info_reg_val", "(", "CUMULATIVE_ARGS", "cum", ")", "{", "unsigned", "HOST_WIDE_INT", "regval", "=", "cum", ".", "num_args", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "6", ";", "i", "++", ")", "regval", "|=", "(", "(", "int", ")", "cum", ".", "atypes", "[", "i", "]", ")", "<<", "(", "i", "*", "3", "+", "8", ")", ";", "return", "GEN_INT", "(", "regval", ")", ";", "}", "</s>"], "natrual_language": ["Return", "an", "rtx", "for", "an", "integer", "representing", "the", "VMS", "Argument", "Information", "register", "value", "."], "TS_V_token": ["alpha", "0", "6", "3", "8"], "File": "alpha", "Func": "alpha_arg_info_reg_val", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40724, "Length": 60}
{"ground_truth": ["<s>", "enum", "avms_arg_type", "alpha_arg_type", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_SFmode", ":", "return", "TARGET_FLOAT_VAX", "?", "FF", ":", "FS", ";", "case", "E_DFmode", ":", "return", "TARGET_FLOAT_VAX", "?", "FD", ":", "FT", ";", "default", ":", "return", "I64", ";", "}", "}", "</s>"], "natrual_language": ["Return", "the", "VMS", "argument", "type", "corresponding", "to", "MODE", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "alpha_arg_type", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40725, "Length": 40}
{"ground_truth": ["<s>", "static", "void", "alpha_atomic_assign_expand_fenv", "(", "tree", "*", "hold", ",", "tree", "*", "clear", ",", "tree", "*", "update", ")", "{", "const", "unsigned", "HOST_WIDE_INT", "SWCR_STATUS_MASK", "=", "(", "0x3fUL", "<<", "17", ")", ";", "tree", "fenv_var", ",", "get_fpscr", ",", "set_fpscr", ",", "mask", ",", "ld_fenv", ",", "masked_fenv", ";", "tree", "new_fenv_var", ",", "reload_fenv", ",", "restore_fnenv", ";", "tree", "update_call", ",", "atomic_feraiseexcept", ",", "hold_fnclex", ";", "if", "(", "!", "TARGET_ABI_OSF", ")", "return", ";", "fenv_var", "=", "create_tmp_var_raw", "(", "long_unsigned_type_node", ")", ";", "get_fpscr", "=", "build_fn_decl", "(", "\"__ieee_get_fp_control\"", ",", "build_function_type_list", "(", "long_unsigned_type_node", ",", "NULL", ")", ")", ";", "set_fpscr", "=", "build_fn_decl", "(", "\"__ieee_set_fp_control\"", ",", "build_function_type_list", "(", "void_type_node", ",", "NULL", ")", ")", ";", "mask", "=", "build_int_cst", "(", "long_unsigned_type_node", ",", "~", "SWCR_STATUS_MASK", ")", ";", "ld_fenv", "=", "build4", "(", "TARGET_EXPR", ",", "long_unsigned_type_node", ",", "fenv_var", ",", "build_call_expr", "(", "get_fpscr", ",", "0", ")", ",", "NULL_TREE", ",", "NULL_TREE", ")", ";", "masked_fenv", "=", "build2", "(", "BIT_AND_EXPR", ",", "long_unsigned_type_node", ",", "fenv_var", ",", "mask", ")", ";", "hold_fnclex", "=", "build_call_expr", "(", "set_fpscr", ",", "1", ",", "masked_fenv", ")", ";", "*", "hold", "=", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "masked_fenv", ",", "ld_fenv", ")", ",", "hold_fnclex", ")", ";", "*", "clear", "=", "build_call_expr", "(", "set_fpscr", ",", "1", ",", "masked_fenv", ")", ";", "new_fenv_var", "=", "create_tmp_var_raw", "(", "long_unsigned_type_node", ")", ";", "reload_fenv", "=", "build4", "(", "TARGET_EXPR", ",", "long_unsigned_type_node", ",", "new_fenv_var", ",", "build_call_expr", "(", "get_fpscr", ",", "0", ")", ",", "NULL_TREE", ",", "NULL_TREE", ")", ";", "restore_fnenv", "=", "build_call_expr", "(", "set_fpscr", ",", "1", ",", "fenv_var", ")", ";", "atomic_feraiseexcept", "=", "builtin_decl_implicit", "(", "BUILT_IN_ATOMIC_FERAISEEXCEPT", ")", ";", "update_call", "=", "build_call_expr", "(", "atomic_feraiseexcept", ",", "1", ",", "fold_convert", "(", "integer_type_node", ",", "new_fenv_var", ")", ")", ";", "*", "update", "=", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "reload_fenv", ",", "restore_fnenv", ")", ",", "update_call", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_ATOMIC_ASSIGN_EXPAND_FENV", "."], "TS_V_token": ["alpha", "0x3fUL", "17", "\"__ieee_get_fp_control\"", "\"__ieee_set_fp_control\"", "0", "1", "1", "0", "1", "1"], "File": "alpha", "Func": "alpha_atomic_assign_expand_fenv", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40726, "Length": 275}
{"ground_truth": ["<s>", "static", "tree", "alpha_builtin_decl", "(", "unsigned", "code", ",", "bool", "initialize_p", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "code", ">=", "ALPHA_BUILTIN_max", ")", "return", "error_mark_node", ";", "return", "alpha_builtins", "[", "code", "]", ";", "}", "</s>"], "natrual_language": ["Return", "the", "alpha", "builtin", "for", "CODE", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "alpha_builtin_decl", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40727, "Length": 28}
{"ground_truth": ["<s>", "static", "void", "alpha_builtin_function", "(", "const", "char", "*", "name", ",", "tree", "ftype", ",", "enum", "alpha_builtin", "code", ",", "unsigned", "ecf", ")", "{", "tree", "decl", "=", "add_builtin_function", "(", "name", ",", "ftype", ",", "(", "int", ")", "code", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "if", "(", "ecf", "&", "ECF_CONST", ")", "TREE_READONLY", "(", "decl", ")", "=", "1", ";", "if", "(", "ecf", "&", "ECF_NOTHROW", ")", "TREE_NOTHROW", "(", "decl", ")", "=", "1", ";", "alpha_builtins", "[", "(", "int", ")", "code", "]", "=", "decl", ";", "}", "</s>"], "natrual_language": ["Helper", "function", "of", "alpha_init_builtins", ".", "Add", "the", "built-in", "specified", "by", "NAME", ",", "TYPE", ",", "CODE", ",", "and", "ECF", "."], "TS_V_token": ["alpha", "1", "1"], "File": "alpha", "Func": "alpha_builtin_function", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40728, "Length": 78}
{"ground_truth": ["<s>", "static", "bool", "alpha_cannot_copy_insn_p", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "!", "reload_completed", "||", "!", "TARGET_EXPLICIT_RELOCS", ")", "return", "false", ";", "if", "(", "recog_memoized", "(", "insn", ")", ">=", "0", ")", "return", "get_attr_cannot_copy", "(", "insn", ")", ";", "else", "return", "false", ";", "}", "</s>"], "natrual_language": ["Indicate", "that", "INSN", "can", "not", "be", "duplicated", ".", "This", "is", "true", "for", "any", "insn", "that", "we", "'ve", "marked", "with", "gpdisp", "relocs", ",", "since", "those", "have", "to", "stay", "in", "1-1", "correspondence", "with", "one", "another", ".", "Technically", "we", "could", "copy", "them", "if", "we", "could", "set", "up", "a", "mapping", "from", "one", "sequence", "number", "to", "another", ",", "across", "the", "set", "of", "insns", "to", "be", "duplicated", ".", "This", "seems", "overly", "complicated", "and", "error-prone", "since", "interblock", "motion", "from", "sched-ebb", "could", "move", "one", "of", "the", "pair", "of", "insns", "to", "a", "different", "block", ".", "Also", "can", "not", "allow", "jsr", "insns", "to", "be", "duplicated", ".", "If", "they", "throw", "exceptions", ",", "then", "they", "'ll", "be", "in", "a", "different", "block", "from", "their", "ldgp", ".", "Which", "could", "lead", "the", "bb", "reorder", "code", "to", "think", "that", "it", "would", "be", "ok", "to", "copy", "just", "the", "block", "containing", "the", "call", "and", "branch", "to", "the", "block", "containing", "the", "ldgp", "."], "TS_V_token": ["alpha", "0"], "File": "alpha", "Func": "alpha_cannot_copy_insn_p", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40729, "Length": 40}
{"ground_truth": ["<s>", "static", "bool", "alpha_cannot_force_const_mem", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "return", "code", "==", "SYMBOL_REF", "||", "code", "==", "LABEL_REF", "||", "code", "==", "CONST", ";", "}", "</s>"], "natrual_language": ["Primarily", "this", "is", "required", "for", "TLS", "symbols", ",", "but", "given", "that", "our", "move", "patterns", "*", "ought", "*", "to", "be", "able", "to", "handle", "any", "symbol", "at", "any", "time", ",", "we", "should", "never", "be", "spilling", "symbolic", "operands", "to", "the", "constant", "pool", ",", "ever", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "alpha_cannot_force_const_mem", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40730, "Length": 35}
{"ground_truth": ["<s>", "static", "void", "alpha_canonicalize_comparison", "(", "int", "*", "code", ",", "rtx", "*", "op0", ",", "rtx", "*", "op1", ",", "bool", "op0_preserve_value", ")", "{", "if", "(", "!", "op0_preserve_value", "&&", "(", "*", "code", "==", "GE", "||", "*", "code", "==", "GT", "||", "*", "code", "==", "GEU", "||", "*", "code", "==", "GTU", ")", "&&", "(", "REG_P", "(", "*", "op1", ")", "||", "*", "op1", "==", "const0_rtx", ")", ")", "{", "std", "::", "swap", "(", "*", "op0", ",", "*", "op1", ")", ";", "*", "code", "=", "(", "int", ")", "swap_condition", "(", "(", "enum", "rtx_code", ")", "*", "code", ")", ";", "}", "if", "(", "(", "*", "code", "==", "LT", "||", "*", "code", "==", "LTU", ")", "&&", "CONST_INT_P", "(", "*", "op1", ")", "&&", "INTVAL", "(", "*", "op1", ")", "==", "256", ")", "{", "*", "code", "=", "*", "code", "==", "LT", "?", "LE", ":", "LEU", ";", "*", "op1", "=", "GEN_INT", "(", "255", ")", ";", "}", "}", "</s>"], "natrual_language": ["Canonicalize", "a", "comparison", "from", "one", "we", "do", "n't", "have", "to", "one", "we", "do", "have", "."], "TS_V_token": ["alpha", "256", "255"], "File": "alpha", "Func": "alpha_canonicalize_comparison", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40731, "Length": 140}
{"ground_truth": ["<s>", "static", "bool", "alpha_can_change_mode_class", "(", "machine_mode", "from", ",", "machine_mode", "to", ",", "reg_class_t", "rclass", ")", "{", "return", "(", "GET_MODE_SIZE", "(", "from", ")", "==", "GET_MODE_SIZE", "(", "to", ")", "||", "!", "reg_classes_intersect_p", "(", "FLOAT_REGS", ",", "rclass", ")", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_CAN_CHANGE_MODE_CLASS", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "alpha_can_change_mode_class", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40732, "Length": 36}
{"ground_truth": ["<s>", "static", "void", "alpha_compute_frame_layout", "(", "void", ")", "{", "unsigned", "HOST_WIDE_INT", "sa_mask", "=", "0", ";", "HOST_WIDE_INT", "frame_size", ";", "int", "sa_size", ";", "if", "(", "!", "cfun", "->", "is_thunk", ")", "{", "if", "(", "TARGET_ABI_OPEN_VMS", "&&", "alpha_procedure_type", "==", "PT_STACK", ")", "sa_mask", "|=", "HOST_WIDE_INT_1U", "<<", "HARD_FRAME_POINTER_REGNUM", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "if", "(", "!", "call_used_or_fixed_reg_p", "(", "i", ")", "&&", "df_regs_ever_live_p", "(", "i", ")", "&&", "i", "!=", "REG_RA", ")", "sa_mask", "|=", "HOST_WIDE_INT_1U", "<<", "i", ";", "if", "(", "crtl", "->", "calls_eh_return", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", ";", "++", "i", ")", "{", "unsigned", "regno", "=", "EH_RETURN_DATA_REGNO", "(", "i", ")", ";", "if", "(", "regno", "==", "INVALID_REGNUM", ")", "break", ";", "sa_mask", "|=", "HOST_WIDE_INT_1U", "<<", "regno", ";", "}", "}", "if", "(", "sa_mask", "||", "alpha_ra_ever_killed", "(", ")", ")", "sa_mask", "|=", "HOST_WIDE_INT_1U", "<<", "REG_RA", ";", "}", "sa_size", "=", "popcount_hwi", "(", "sa_mask", ")", ";", "frame_size", "=", "get_frame_size", "(", ")", ";", "if", "(", "TARGET_ABI_OPEN_VMS", ")", "{", "if", "(", "(", "sa_mask", ">>", "REG_RA", ")", "&", "1", "||", "frame_pointer_needed", ")", "alpha_procedure_type", "=", "PT_STACK", ";", "else", "if", "(", "frame_size", "!=", "0", ")", "alpha_procedure_type", "=", "PT_REGISTER", ";", "else", "alpha_procedure_type", "=", "PT_NULL", ";", "if", "(", "alpha_procedure_type", "==", "PT_STACK", ")", "sa_size", "-=", "2", ";", "vms_base_regno", "=", "(", "frame_pointer_needed", "||", "cfun", "->", "has_nonlocal_label", "||", "alpha_procedure_type", "==", "PT_STACK", "||", "crtl", "->", "outgoing_args_size", ")", "?", "REG_PV", ":", "HARD_FRAME_POINTER_REGNUM", ";", "vms_save_fp_regno", "=", "-", "1", ";", "if", "(", "vms_base_regno", "==", "HARD_FRAME_POINTER_REGNUM", ")", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "32", ";", "i", "++", ")", "if", "(", "!", "fixed_regs", "[", "i", "]", "&&", "call_used_or_fixed_reg_p", "(", "i", ")", "&&", "!", "df_regs_ever_live_p", "(", "i", ")", ")", "{", "vms_save_fp_regno", "=", "i", ";", "break", ";", "}", "if", "(", "(", "vms_save_fp_regno", "==", "-", "1", "&&", "alpha_procedure_type", "==", "PT_REGISTER", ")", "||", "cfun", "->", "machine", "->", "uses_condition_handler", ")", "vms_base_regno", "=", "REG_PV", ",", "alpha_procedure_type", "=", "PT_STACK", ";", "else", "if", "(", "alpha_procedure_type", "==", "PT_NULL", ")", "vms_base_regno", "=", "REG_PV", ";", "vms_unwind_regno", "=", "(", "vms_base_regno", "==", "REG_PV", "?", "HARD_FRAME_POINTER_REGNUM", ":", "STACK_POINTER_REGNUM", ")", ";", "if", "(", "alpha_procedure_type", "==", "PT_STACK", ")", "sa_size", "+=", "2", "+", "cfun", "->", "machine", "->", "uses_condition_handler", ";", "}", "else", "{", "if", "(", "sa_size", "&", "1", ")", "sa_size", "++", ";", "}", "sa_size", "*=", "8", ";", "if", "(", "TARGET_ABI_OPEN_VMS", ")", "frame_size", "=", "ALPHA_ROUND", "(", "sa_size", "+", "(", "alpha_procedure_type", "==", "PT_STACK", "?", "8", ":", "0", ")", "+", "frame_size", "+", "crtl", "->", "args", ".", "pretend_args_size", ")", ";", "else", "frame_size", "=", "(", "ALPHA_ROUND", "(", "crtl", "->", "outgoing_args_size", ")", "+", "sa_size", "+", "ALPHA_ROUND", "(", "frame_size", "+", "crtl", "->", "args", ".", "pretend_args_size", ")", ")", ";", "cfun", "->", "machine", "->", "sa_mask", "=", "sa_mask", ";", "cfun", "->", "machine", "->", "sa_size", "=", "sa_size", ";", "cfun", "->", "machine", "->", "frame_size", "=", "frame_size", ";", "}", "</s>"], "natrual_language": ["Compute", "register", "masks", "for", "saved", "registers", ",", "register", "save", "area", "size", ",", "and", "total", "frame", "size", "."], "TS_V_token": ["alpha", "0", "0", "0", "1", "0", "2", "1", "0", "32", "1", "2", "1", "8", "8", "0"], "File": "alpha", "Func": "alpha_compute_frame_layout", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40733, "Length": 432}
{"ground_truth": ["<s>", "static", "int", "alpha_compute_xfloating_mode_arg", "(", "enum", "rtx_code", "code", ",", "enum", "alpha_fp_rounding_mode", "round", ")", "{", "int", "mode", ";", "switch", "(", "round", ")", "{", "case", "ALPHA_FPRM_NORM", ":", "mode", "=", "2", ";", "break", ";", "case", "ALPHA_FPRM_MINF", ":", "mode", "=", "1", ";", "break", ";", "case", "ALPHA_FPRM_CHOP", ":", "mode", "=", "0", ";", "break", ";", "case", "ALPHA_FPRM_DYN", ":", "mode", "=", "4", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "code", "==", "FLOAT_TRUNCATE", "&&", "alpha_fptm", "==", "ALPHA_FPTM_N", ")", "mode", "|=", "0x10000", ";", "return", "mode", ";", "}", "</s>"], "natrual_language": ["Most", "X_floating", "operations", "take", "the", "rounding", "mode", "as", "an", "argument", ".", "Compute", "that", "here", "."], "TS_V_token": ["alpha", "2", "1", "0", "4", "0x10000"], "File": "alpha", "Func": "alpha_compute_xfloating_mode_arg", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40734, "Length": 82}
{"ground_truth": ["<s>", "static", "void", "alpha_conditional_register_usage", "(", "void", ")", "{", "int", "i", ";", "if", "(", "!", "TARGET_FPREGS", ")", "for", "(", "i", "=", "32", ";", "i", "<", "63", ";", "i", "++", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "1", ";", "}", "</s>"], "natrual_language": ["On", "the", "Alpha", ",", "we", "use", "this", "to", "disable", "the", "floating-point", "registers", "when", "they", "do", "n't", "exist", "."], "TS_V_token": ["alpha", "32", "63", "1"], "File": "alpha", "Func": "alpha_conditional_register_usage", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40735, "Length": 41}
{"ground_truth": ["<s>", "static", "int", "alpha_elf_reloc_rw_mask", "(", "void", ")", "{", "return", "flag_pic", "?", "3", ":", "2", ";", "}", "</s>"], "natrual_language": ["Since", "we", "do", "n't", "have", "a", ".dynbss", "section", ",", "we", "should", "not", "allow", "global", "relocations", "in", "the", ".rodata", "section", "."], "TS_V_token": ["alpha", "3", "2"], "File": "alpha", "Func": "alpha_elf_reloc_rw_mask", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40736, "Length": 15}
{"ground_truth": ["<s>", "static", "section", "*", "alpha_elf_select_rtx_section", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "unsigned", "HOST_WIDE_INT", "align", ")", "{", "if", "(", "TARGET_SMALL_DATA", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<=", "g_switch_value", ")", "return", "sdata_section", ";", "else", "return", "default_elf_select_rtx_section", "(", "mode", ",", "x", ",", "align", ")", ";", "}", "</s>"], "natrual_language": ["Switch", "to", "the", "section", "to", "which", "we", "should", "output", "X", ".", "The", "only", "thing", "special", "we", "do", "here", "is", "to", "honor", "small", "data", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "alpha_elf_select_rtx_section", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40737, "Length": 42}
{"ground_truth": ["<s>", "bool", "alpha_emit_setcc", "(", "rtx", "operands", "[", "]", ",", "machine_mode", "cmp_mode", ")", "{", "enum", "rtx_code", "cmp_code", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "1", "]", ")", ";", "rtx", "op0", "=", "operands", "[", "2", "]", ",", "op1", "=", "operands", "[", "3", "]", ";", "rtx", "tmp", ";", "if", "(", "cmp_mode", "==", "TFmode", ")", "{", "op0", "=", "alpha_emit_xfloating_compare", "(", "&", "code", ",", "op0", ",", "op1", ")", ";", "op1", "=", "const0_rtx", ";", "cmp_mode", "=", "DImode", ";", "}", "if", "(", "cmp_mode", "==", "DFmode", "&&", "!", "TARGET_FIX", ")", "return", "0", ";", "cmp_code", "=", "UNKNOWN", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "LE", ":", "case", "LT", ":", "case", "LEU", ":", "case", "LTU", ":", "case", "UNORDERED", ":", "if", "(", "cmp_mode", "==", "DFmode", ")", "cmp_code", "=", "code", ",", "code", "=", "NE", ";", "break", ";", "case", "NE", ":", "if", "(", "cmp_mode", "==", "DImode", "&&", "op1", "==", "const0_rtx", ")", "break", ";", "case", "ORDERED", ":", "cmp_code", "=", "reverse_condition", "(", "code", ")", ";", "code", "=", "EQ", ";", "break", ";", "case", "GE", ":", "case", "GT", ":", "case", "GEU", ":", "case", "GTU", ":", "if", "(", "cmp_mode", "==", "DImode", "&&", "op1", "==", "const0_rtx", ")", "break", ";", "code", "=", "swap_condition", "(", "code", ")", ";", "if", "(", "cmp_mode", "==", "DFmode", ")", "cmp_code", "=", "code", ",", "code", "=", "NE", ";", "std", "::", "swap", "(", "op0", ",", "op1", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "cmp_mode", "==", "DImode", ")", "{", "if", "(", "!", "register_operand", "(", "op0", ",", "DImode", ")", ")", "op0", "=", "force_reg", "(", "DImode", ",", "op0", ")", ";", "if", "(", "!", "reg_or_8bit_operand", "(", "op1", ",", "DImode", ")", ")", "op1", "=", "force_reg", "(", "DImode", ",", "op1", ")", ";", "}", "if", "(", "cmp_code", "!=", "UNKNOWN", ")", "{", "tmp", "=", "gen_reg_rtx", "(", "cmp_mode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "tmp", ",", "gen_rtx_fmt_ee", "(", "cmp_code", ",", "cmp_mode", ",", "op0", ",", "op1", ")", ")", ")", ";", "op0", "=", "cmp_mode", "!=", "DImode", "?", "gen_lowpart", "(", "DImode", ",", "tmp", ")", ":", "tmp", ";", "op1", "=", "const0_rtx", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "op0", ",", "op1", ")", ")", ")", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Certain", "simplifications", "can", "be", "done", "to", "make", "invalid", "setcc", "operations", "valid", ".", "Return", "the", "final", "comparison", ",", "or", "NULL", "if", "we", "ca", "n't", "work", "."], "TS_V_token": ["alpha", "1", "2", "3", "0", "0"], "File": "alpha", "Func": "alpha_emit_setcc", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40738, "Length": 348}
{"ground_truth": ["<s>", "static", "rtx", "alpha_emit_set_const", "(", "rtx", "target", ",", "machine_mode", "mode", ",", "HOST_WIDE_INT", "c", ",", "int", "n", ",", "bool", "no_output", ")", "{", "machine_mode", "orig_mode", "=", "mode", ";", "rtx", "orig_target", "=", "target", ";", "rtx", "result", "=", "0", ";", "int", "i", ";", "if", "(", "!", "can_create_pseudo_p", "(", ")", "&&", "mode", "==", "SImode", "&&", "REG_P", "(", "target", ")", "&&", "REGNO", "(", "target", ")", "<", "FIRST_PSEUDO_REGISTER", ")", "{", "result", "=", "alpha_emit_set_const_1", "(", "target", ",", "mode", ",", "c", ",", "1", ",", "no_output", ")", ";", "if", "(", "result", ")", "return", "result", ";", "target", "=", "no_output", "?", "NULL", ":", "gen_lowpart", "(", "DImode", ",", "target", ")", ";", "mode", "=", "DImode", ";", "}", "else", "if", "(", "mode", "==", "V8QImode", "||", "mode", "==", "V4HImode", "||", "mode", "==", "V2SImode", ")", "{", "target", "=", "no_output", "?", "NULL", ":", "gen_lowpart", "(", "DImode", ",", "target", ")", ";", "mode", "=", "DImode", ";", "}", "for", "(", "i", "=", "1", ";", "i", "<=", "n", ";", "i", "++", ")", "{", "result", "=", "alpha_emit_set_const_1", "(", "target", ",", "mode", ",", "c", ",", "i", ",", "no_output", ")", ";", "if", "(", "result", ")", "{", "rtx_insn", "*", "insn", ";", "rtx", "set", ";", "if", "(", "no_output", ")", "return", "result", ";", "insn", "=", "get_last_insn", "(", ")", ";", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "!", "CONSTANT_P", "(", "SET_SRC", "(", "set", ")", ")", ")", "set_unique_reg_note", "(", "get_last_insn", "(", ")", ",", "REG_EQUAL", ",", "GEN_INT", "(", "c", ")", ")", ";", "break", ";", "}", "}", "if", "(", "result", ")", "{", "if", "(", "result", "==", "target", ")", "result", "=", "orig_target", ";", "else", "if", "(", "mode", "!=", "orig_mode", ")", "result", "=", "gen_lowpart", "(", "orig_mode", ",", "result", ")", ";", "}", "return", "result", ";", "}", "</s>"], "natrual_language": ["Try", "to", "output", "insns", "to", "set", "TARGET", "equal", "to", "the", "constant", "C", "if", "it", "can", "be", "done", "in", "less", "than", "N", "insns", ".", "Do", "all", "computations", "in", "MODE", ".", "Returns", "the", "place", "where", "the", "output", "has", "been", "placed", "if", "it", "can", "be", "done", "and", "the", "insns", "have", "been", "emitted", ".", "If", "it", "would", "take", "more", "than", "N", "insns", ",", "zero", "is", "returned", "and", "no", "insns", "and", "emitted", "."], "TS_V_token": ["alpha", "0", "1", "1"], "File": "alpha", "Func": "alpha_emit_set_const", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40739, "Length": 262}
{"ground_truth": ["<s>", "static", "rtx", "alpha_emit_set_long_const", "(", "rtx", "target", ",", "HOST_WIDE_INT", "c1", ")", "{", "HOST_WIDE_INT", "d1", ",", "d2", ",", "d3", ",", "d4", ";", "d1", "=", "(", "(", "c1", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "c1", "-=", "d1", ";", "d2", "=", "(", "(", "c1", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "c1", "=", "(", "c1", "-", "d2", ")", ">>", "32", ";", "d3", "=", "(", "(", "c1", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "c1", "-=", "d3", ";", "d4", "=", "(", "(", "c1", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "gcc_assert", "(", "c1", "==", "d4", ")", ";", "if", "(", "d4", ")", "{", "emit_move_insn", "(", "target", ",", "GEN_INT", "(", "d4", ")", ")", ";", "if", "(", "d3", ")", "emit_move_insn", "(", "target", ",", "gen_rtx_PLUS", "(", "DImode", ",", "target", ",", "GEN_INT", "(", "d3", ")", ")", ")", ";", "}", "else", "emit_move_insn", "(", "target", ",", "GEN_INT", "(", "d3", ")", ")", ";", "emit_move_insn", "(", "target", ",", "gen_rtx_ASHIFT", "(", "DImode", ",", "target", ",", "GEN_INT", "(", "32", ")", ")", ")", ";", "if", "(", "d2", ")", "emit_move_insn", "(", "target", ",", "gen_rtx_PLUS", "(", "DImode", ",", "target", ",", "GEN_INT", "(", "d2", ")", ")", ")", ";", "if", "(", "d1", ")", "emit_move_insn", "(", "target", ",", "gen_rtx_PLUS", "(", "DImode", ",", "target", ",", "GEN_INT", "(", "d1", ")", ")", ")", ";", "return", "target", ";", "}", "</s>"], "natrual_language": ["Having", "failed", "to", "find", "a", "3", "insn", "sequence", "in", "alpha_emit_set_const", ",", "fall", "back", "to", "a", "straight", "forward", "decomposition", ".", "We", "do", "this", "to", "avoid", "exponential", "run", "times", "encountered", "when", "looking", "for", "longer", "sequences", "with", "alpha_emit_set_const", "."], "TS_V_token": ["alpha", "0xffff", "0x8000", "0x8000", "0xffffffff", "0x80000000", "0x80000000", "32", "0xffff", "0x8000", "0x8000", "0xffffffff", "0x80000000", "0x80000000", "32"], "File": "alpha", "Func": "alpha_emit_set_long_const", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40740, "Length": 212}
{"ground_truth": ["<s>", "void", "alpha_emit_xfloating_arith", "(", "enum", "rtx_code", "code", ",", "rtx", "operands", "[", "]", ")", "{", "rtx", "func", ";", "int", "mode", ";", "rtx", "out_operands", "[", "3", "]", ";", "func", "=", "alpha_lookup_xfloating_lib_func", "(", "code", ")", ";", "mode", "=", "alpha_compute_xfloating_mode_arg", "(", "code", ",", "alpha_fprm", ")", ";", "out_operands", "[", "0", "]", "=", "operands", "[", "1", "]", ";", "out_operands", "[", "1", "]", "=", "operands", "[", "2", "]", ";", "out_operands", "[", "2", "]", "=", "GEN_INT", "(", "mode", ")", ";", "alpha_emit_xfloating_libcall", "(", "func", ",", "operands", "[", "0", "]", ",", "out_operands", ",", "3", ",", "gen_rtx_fmt_ee", "(", "code", ",", "TFmode", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ")", ";", "}", "</s>"], "natrual_language": ["Emit", "an", "X_floating", "library", "function", "call", "for", "arithmetic", "(", "+", ",", "-", ",", "*", ",", "/", ")", "."], "TS_V_token": ["alpha", "3", "0", "1", "1", "2", "2", "0", "3", "1", "2"], "File": "alpha", "Func": "alpha_emit_xfloating_arith", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40741, "Length": 103}
{"ground_truth": ["<s>", "static", "rtx", "alpha_emit_xfloating_compare", "(", "enum", "rtx_code", "*", "pcode", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "enum", "rtx_code", "cmp_code", ",", "res_code", ";", "rtx", "func", ",", "out", ",", "operands", "[", "2", "]", ",", "note", ";", "cmp_code", "=", "*", "pcode", ";", "switch", "(", "cmp_code", ")", "{", "case", "UNORDERED", ":", "cmp_code", "=", "EQ", ";", "res_code", "=", "LT", ";", "break", ";", "case", "ORDERED", ":", "cmp_code", "=", "EQ", ";", "res_code", "=", "GE", ";", "break", ";", "case", "NE", ":", "res_code", "=", "NE", ";", "break", ";", "case", "EQ", ":", "case", "LT", ":", "case", "GT", ":", "case", "LE", ":", "case", "GE", ":", "res_code", "=", "GT", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "*", "pcode", "=", "res_code", ";", "func", "=", "alpha_lookup_xfloating_lib_func", "(", "cmp_code", ")", ";", "operands", "[", "0", "]", "=", "op0", ";", "operands", "[", "1", "]", "=", "op1", ";", "out", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "note", "=", "gen_rtx_fmt_ee", "(", "cmp_code", ",", "VOIDmode", ",", "op0", ",", "op1", ")", ";", "note", "=", "gen_rtx_UNSPEC", "(", "DImode", ",", "gen_rtvec", "(", "1", ",", "note", ")", ",", "UNSPEC_XFLT_COMPARE", ")", ";", "alpha_emit_xfloating_libcall", "(", "func", ",", "out", ",", "operands", ",", "2", ",", "note", ")", ";", "return", "out", ";", "}", "</s>"], "natrual_language": ["Emit", "an", "X_floating", "library", "function", "call", "for", "a", "comparison", "."], "TS_V_token": ["alpha", "2", "0", "1", "1", "2"], "File": "alpha", "Func": "alpha_emit_xfloating_compare", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40742, "Length": 186}
{"ground_truth": ["<s>", "void", "alpha_emit_xfloating_cvt", "(", "enum", "rtx_code", "orig_code", ",", "rtx", "operands", "[", "]", ")", "{", "int", "noperands", "=", "1", ",", "mode", ";", "rtx", "out_operands", "[", "2", "]", ";", "rtx", "func", ";", "enum", "rtx_code", "code", "=", "orig_code", ";", "if", "(", "code", "==", "UNSIGNED_FIX", ")", "code", "=", "FIX", ";", "func", "=", "alpha_lookup_xfloating_lib_func", "(", "code", ")", ";", "out_operands", "[", "0", "]", "=", "operands", "[", "1", "]", ";", "switch", "(", "code", ")", "{", "case", "FIX", ":", "mode", "=", "alpha_compute_xfloating_mode_arg", "(", "code", ",", "ALPHA_FPRM_CHOP", ")", ";", "out_operands", "[", "1", "]", "=", "GEN_INT", "(", "mode", ")", ";", "noperands", "=", "2", ";", "break", ";", "case", "FLOAT_TRUNCATE", ":", "mode", "=", "alpha_compute_xfloating_mode_arg", "(", "code", ",", "alpha_fprm", ")", ";", "out_operands", "[", "1", "]", "=", "GEN_INT", "(", "mode", ")", ";", "noperands", "=", "2", ";", "break", ";", "default", ":", "break", ";", "}", "alpha_emit_xfloating_libcall", "(", "func", ",", "operands", "[", "0", "]", ",", "out_operands", ",", "noperands", ",", "gen_rtx_fmt_e", "(", "orig_code", ",", "GET_MODE", "(", "operands", "[", "0", "]", ")", ",", "operands", "[", "1", "]", ")", ")", ";", "}", "</s>"], "natrual_language": ["Emit", "an", "X_floating", "library", "function", "call", "for", "a", "conversion", "."], "TS_V_token": ["alpha", "1", "2", "0", "1", "1", "2", "1", "2", "0", "0", "1"], "File": "alpha", "Func": "alpha_emit_xfloating_cvt", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40743, "Length": 161}
{"ground_truth": ["<s>", "static", "void", "alpha_emit_xfloating_libcall", "(", "rtx", "func", ",", "rtx", "target", ",", "rtx", "operands", "[", "]", ",", "int", "noperands", ",", "rtx", "equiv", ")", "{", "rtx", "usage", "=", "NULL_RTX", ",", "reg", ";", "int", "regno", "=", "16", ",", "i", ";", "start_sequence", "(", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "noperands", ";", "++", "i", ")", "{", "switch", "(", "GET_MODE", "(", "operands", "[", "i", "]", ")", ")", "{", "case", "E_TFmode", ":", "reg", "=", "gen_rtx_REG", "(", "TFmode", ",", "regno", ")", ";", "regno", "+=", "2", ";", "break", ";", "case", "E_DFmode", ":", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "regno", "+", "32", ")", ";", "regno", "+=", "1", ";", "break", ";", "case", "E_VOIDmode", ":", "gcc_assert", "(", "CONST_INT_P", "(", "operands", "[", "i", "]", ")", ")", ";", "case", "E_DImode", ":", "reg", "=", "gen_rtx_REG", "(", "DImode", ",", "regno", ")", ";", "regno", "+=", "1", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_move_insn", "(", "reg", ",", "operands", "[", "i", "]", ")", ";", "use_reg", "(", "&", "usage", ",", "reg", ")", ";", "}", "switch", "(", "GET_MODE", "(", "target", ")", ")", "{", "case", "E_TFmode", ":", "reg", "=", "gen_rtx_REG", "(", "TFmode", ",", "16", ")", ";", "break", ";", "case", "E_DFmode", ":", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "32", ")", ";", "break", ";", "case", "E_DImode", ":", "reg", "=", "gen_rtx_REG", "(", "DImode", ",", "0", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "rtx", "mem", "=", "gen_rtx_MEM", "(", "QImode", ",", "func", ")", ";", "rtx_insn", "*", "tmp", "=", "emit_call_insn", "(", "gen_call_value", "(", "reg", ",", "mem", ",", "const0_rtx", ",", "const0_rtx", ",", "const0_rtx", ")", ")", ";", "CALL_INSN_FUNCTION_USAGE", "(", "tmp", ")", "=", "usage", ";", "RTL_CONST_CALL_P", "(", "tmp", ")", "=", "1", ";", "tmp", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "emit_libcall_block", "(", "tmp", ",", "target", ",", "reg", ",", "equiv", ")", ";", "}", "</s>"], "natrual_language": ["Emit", "an", "X_floating", "library", "function", "call", ".", "Note", "that", "these", "functions", "do", "not", "follow", "normal", "calling", "conventions", ":", "TFmode", "arguments", "are", "passed", "in", "two", "integer", "registers", "(", "as", "opposed", "to", "indirect", ")", ";", "TFmode", "return", "values", "appear", "in", "R16+R17", ".", "FUNC", "is", "the", "function", "name", "to", "call", ".", "TARGET", "is", "where", "the", "output", "belongs", ".", "OPERANDS", "are", "the", "inputs", ".", "NOPERANDS", "is", "the", "count", "of", "inputs", ".", "EQUIV", "is", "the", "expression", "equivalent", "for", "the", "function", "."], "TS_V_token": ["alpha", "16", "0", "2", "32", "1", "1", "16", "32", "0", "1"], "File": "alpha", "Func": "alpha_emit_xfloating_libcall", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40744, "Length": 284}
{"ground_truth": ["<s>", "void", "alpha_end_function", "(", "FILE", "*", "file", ",", "const", "char", "*", "fnname", ",", "tree", "decl", "ATTRIBUTE_UNUSED", ")", "{", "rtx_insn", "*", "insn", ";", "insn", "=", "get_last_insn", "(", ")", ";", "if", "(", "!", "INSN_P", "(", "insn", ")", ")", "insn", "=", "prev_active_insn", "(", "insn", ")", ";", "if", "(", "insn", "&&", "CALL_P", "(", "insn", ")", ")", "output_asm_insn", "(", "get_insn_template", "(", "CODE_FOR_nop", ",", "NULL", ")", ",", "NULL", ")", ";", "alpha_write_linkage", "(", "file", ",", "fnname", ")", ";", "if", "(", "TARGET_ABI_OPEN_VMS", "||", "!", "flag_inhibit_size_directive", ")", "{", "fputs", "(", "\"\\t.end \"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "fnname", ")", ";", "putc", "(", "'\\n'", ",", "file", ")", ";", "}", "inside_function", "=", "FALSE", ";", "}", "</s>"], "natrual_language": ["Output", "the", "rest", "of", "the", "textual", "info", "surrounding", "the", "epilogue", "."], "TS_V_token": ["alpha", "\"\\t.end \""], "File": "alpha", "Func": "alpha_end_function", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40745, "Length": 105}
{"ground_truth": ["<s>", "static", "rtx", "alpha_expand_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "rtx", "subtarget", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "ignore", "ATTRIBUTE_UNUSED", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ";", "unsigned", "int", "fcode", "=", "DECL_MD_FUNCTION_CODE", "(", "fndecl", ")", ";", "tree", "arg", ";", "call_expr_arg_iterator", "iter", ";", "enum", "insn_code", "icode", ";", "rtx", "op", "[", "MAX_ARGS", "]", ",", "pat", ";", "int", "arity", ";", "bool", "nonvoid", ";", "if", "(", "fcode", ">=", "ALPHA_BUILTIN_max", ")", "internal_error", "(", "\"bad builtin fcode\"", ")", ";", "icode", "=", "code_for_builtin", "[", "fcode", "]", ";", "if", "(", "icode", "==", "0", ")", "internal_error", "(", "\"bad builtin fcode\"", ")", ";", "nonvoid", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "fndecl", ")", ")", "!=", "void_type_node", ";", "arity", "=", "0", ";", "FOR_EACH_CALL_EXPR_ARG", "(", "arg", ",", "iter", ",", "exp", ")", "{", "const", "struct", "insn_operand_data", "*", "insn_op", ";", "if", "(", "arg", "==", "error_mark_node", ")", "return", "NULL_RTX", ";", "if", "(", "arity", ">", "MAX_ARGS", ")", "return", "NULL_RTX", ";", "insn_op", "=", "&", "insn_data", "[", "icode", "]", ".", "operand", "[", "arity", "+", "nonvoid", "]", ";", "op", "[", "arity", "]", "=", "expand_expr", "(", "arg", ",", "NULL_RTX", ",", "insn_op", "->", "mode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "(", "*", "insn_op", "->", "predicate", ")", "(", "op", "[", "arity", "]", ",", "insn_op", "->", "mode", ")", ")", "op", "[", "arity", "]", "=", "copy_to_mode_reg", "(", "insn_op", "->", "mode", ",", "op", "[", "arity", "]", ")", ";", "arity", "++", ";", "}", "if", "(", "nonvoid", ")", "{", "machine_mode", "tmode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ";", "if", "(", "!", "target", "||", "GET_MODE", "(", "target", ")", "!=", "tmode", "||", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "predicate", ")", "(", "target", ",", "tmode", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "}", "switch", "(", "arity", ")", "{", "case", "0", ":", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ")", ";", "break", ";", "case", "1", ":", "if", "(", "nonvoid", ")", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op", "[", "0", "]", ")", ";", "else", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "op", "[", "0", "]", ")", ";", "break", ";", "case", "2", ":", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op", "[", "0", "]", ",", "op", "[", "1", "]", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "if", "(", "nonvoid", ")", "return", "target", ";", "else", "return", "const0_rtx", ";", "}", "</s>"], "natrual_language": ["Expand", "an", "expression", "EXP", "that", "calls", "a", "built-in", "function", ",", "with", "result", "going", "to", "TARGET", "if", "that", "'s", "convenient", "(", "and", "in", "mode", "MODE", "if", "that", "'s", "convenient", ")", ".", "SUBTARGET", "may", "be", "used", "as", "the", "target", "for", "computing", "one", "of", "EXP", "'s", "operands", ".", "IGNORE", "is", "nonzero", "if", "the", "value", "is", "to", "be", "ignored", "."], "TS_V_token": ["alpha", "0", "\"bad builtin fcode\"", "0", "\"bad builtin fcode\"", "0", "0", "0", "0", "1", "0", "0", "2", "0", "1"], "File": "alpha", "Func": "alpha_expand_builtin", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40746, "Length": 397}
{"ground_truth": ["<s>", "void", "alpha_expand_builtin_establish_vms_condition_handler", "(", "rtx", "target", ",", "rtx", "handler", ")", "{", "rtx", "handler_slot_address", "=", "plus_constant", "(", "Pmode", ",", "hard_frame_pointer_rtx", ",", "VMS_COND_HANDLER_FP_OFFSET", ")", ";", "rtx", "handler_slot", "=", "gen_rtx_MEM", "(", "DImode", ",", "handler_slot_address", ")", ";", "emit_move_insn", "(", "target", ",", "handler_slot", ")", ";", "emit_move_insn", "(", "handler_slot", ",", "handler", ")", ";", "cfun", "->", "machine", "->", "uses_condition_handler", "=", "true", ";", "}", "</s>"], "natrual_language": ["Expand", "code", "to", "store", "the", "currently", "installed", "user", "VMS", "condition", "handler", "into", "TARGET", "and", "install", "HANDLER", "as", "the", "new", "condition", "handler", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "alpha_expand_builtin_establish_vms_condition_handler", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40747, "Length": 55}
{"ground_truth": ["<s>", "void", "alpha_expand_builtin_revert_vms_condition_handler", "(", "rtx", "target", ")", "{", "alpha_expand_builtin_establish_vms_condition_handler", "(", "target", ",", "const0_rtx", ")", ";", "}", "</s>"], "natrual_language": ["Expand", "code", "to", "store", "the", "current", "VMS", "condition", "handler", "into", "TARGET", "and", "nullify", "it", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "alpha_expand_builtin_revert_vms_condition_handler", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40748, "Length": 15}
{"ground_truth": ["<s>", "bool", "alpha_expand_mov", "(", "machine_mode", "mode", ",", "rtx", "*", "operands", ")", "{", "rtx", "tmp", ";", "if", "(", "MEM_P", "(", "operands", "[", "0", "]", ")", "&&", "!", "reg_or_0_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "operands", "[", "1", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "if", "(", "mode", "==", "Pmode", "&&", "symbolic_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "{", "tmp", "=", "alpha_legitimize_address_1", "(", "operands", "[", "1", "]", ",", "operands", "[", "0", "]", ",", "mode", ")", ";", "if", "(", "tmp", ")", "{", "if", "(", "tmp", "==", "operands", "[", "0", "]", ")", "return", "true", ";", "operands", "[", "1", "]", "=", "tmp", ";", "return", "false", ";", "}", "}", "if", "(", "!", "CONSTANT_P", "(", "operands", "[", "1", "]", ")", "||", "input_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "return", "false", ";", "if", "(", "CONST_INT_P", "(", "operands", "[", "1", "]", ")", "||", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "CONST_VECTOR", ")", "{", "if", "(", "alpha_split_const_mov", "(", "mode", ",", "operands", ")", ")", "return", "true", ";", "}", "tmp", "=", "force_const_mem", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "if", "(", "tmp", "==", "NULL_RTX", ")", "return", "false", ";", "if", "(", "reload_in_progress", ")", "{", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "XEXP", "(", "tmp", ",", "0", ")", ")", ";", "operands", "[", "1", "]", "=", "replace_equiv_address", "(", "tmp", ",", "operands", "[", "0", "]", ")", ";", "}", "else", "operands", "[", "1", "]", "=", "validize_mem", "(", "tmp", ")", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Expand", "a", "move", "instruction", ";", "return", "true", "if", "all", "work", "is", "done", ".", "We", "do", "n't", "handle", "non-bwx", "subword", "loads", "here", "."], "TS_V_token": ["alpha", "0", "1", "1", "1", "1", "1", "0", "0", "1", "1", "1", "1", "1", "1", "0", "0", "1", "0", "1"], "File": "alpha", "Func": "alpha_expand_mov", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40749, "Length": 243}
{"ground_truth": ["<s>", "void", "alpha_expand_movmisalign", "(", "machine_mode", "mode", ",", "rtx", "*", "operands", ")", "{", "if", "(", "MEM_P", "(", "operands", "[", "1", "]", ")", ")", "{", "rtx", "tmp", ";", "if", "(", "register_operand", "(", "operands", "[", "0", "]", ",", "mode", ")", ")", "tmp", "=", "operands", "[", "0", "]", ";", "else", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "alpha_expand_unaligned_load", "(", "tmp", ",", "operands", "[", "1", "]", ",", "8", ",", "0", ",", "0", ")", ";", "if", "(", "tmp", "!=", "operands", "[", "0", "]", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "tmp", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "operands", "[", "0", "]", ")", ")", "{", "if", "(", "!", "reg_or_0_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "operands", "[", "1", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "alpha_expand_unaligned_store", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "8", ",", "0", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "the", "movmisalign", "patterns", ".", "One", "of", "the", "operands", "is", "a", "memory", "that", "is", "not", "naturally", "aligned", ".", "Emit", "instructions", "to", "load", "it", "."], "TS_V_token": ["alpha", "1", "0", "0", "1", "8", "0", "0", "0", "0", "0", "1", "1", "1", "0", "1", "8", "0"], "File": "alpha", "Func": "alpha_expand_movmisalign", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40750, "Length": 152}
{"ground_truth": ["<s>", "static", "void", "alpha_expand_unaligned_load_words", "(", "rtx", "*", "out_regs", ",", "rtx", "smem", ",", "HOST_WIDE_INT", "words", ",", "HOST_WIDE_INT", "ofs", ")", "{", "rtx", "const", "im8", "=", "GEN_INT", "(", "-", "8", ")", ";", "rtx", "ext_tmps", "[", "MAX_MOVE_WORDS", "]", ",", "data_regs", "[", "MAX_MOVE_WORDS", "+", "1", "]", ";", "rtx", "sreg", ",", "areg", ",", "tmp", ",", "smema", ";", "HOST_WIDE_INT", "i", ";", "smema", "=", "XEXP", "(", "smem", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "smema", ")", "==", "LO_SUM", ")", "smema", "=", "force_reg", "(", "Pmode", ",", "smema", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "words", ";", "++", "i", ")", "{", "data_regs", "[", "i", "]", "=", "out_regs", "[", "i", "]", ";", "ext_tmps", "[", "i", "]", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "}", "data_regs", "[", "words", "]", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "if", "(", "ofs", "!=", "0", ")", "smem", "=", "adjust_address", "(", "smem", ",", "GET_MODE", "(", "smem", ")", ",", "ofs", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "words", ";", "++", "i", ")", "{", "tmp", "=", "change_address", "(", "smem", ",", "DImode", ",", "gen_rtx_AND", "(", "DImode", ",", "plus_constant", "(", "DImode", ",", "smema", ",", "8", "*", "i", ")", ",", "im8", ")", ")", ";", "set_mem_alias_set", "(", "tmp", ",", "0", ")", ";", "emit_move_insn", "(", "data_regs", "[", "i", "]", ",", "tmp", ")", ";", "}", "tmp", "=", "change_address", "(", "smem", ",", "DImode", ",", "gen_rtx_AND", "(", "DImode", ",", "plus_constant", "(", "DImode", ",", "smema", ",", "8", "*", "words", "-", "1", ")", ",", "im8", ")", ")", ";", "set_mem_alias_set", "(", "tmp", ",", "0", ")", ";", "emit_move_insn", "(", "data_regs", "[", "words", "]", ",", "tmp", ")", ";", "sreg", "=", "copy_addr_to_reg", "(", "smema", ")", ";", "areg", "=", "expand_binop", "(", "DImode", ",", "and_optab", ",", "sreg", ",", "GEN_INT", "(", "7", ")", ",", "NULL", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "words", ";", "++", "i", ")", "{", "emit_insn", "(", "gen_extql", "(", "data_regs", "[", "i", "]", ",", "data_regs", "[", "i", "]", ",", "sreg", ")", ")", ";", "emit_insn", "(", "gen_extqh", "(", "ext_tmps", "[", "i", "]", ",", "data_regs", "[", "i", "+", "1", "]", ",", "sreg", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "ext_tmps", "[", "i", "]", ",", "gen_rtx_IF_THEN_ELSE", "(", "DImode", ",", "gen_rtx_EQ", "(", "DImode", ",", "areg", ",", "const0_rtx", ")", ",", "const0_rtx", ",", "ext_tmps", "[", "i", "]", ")", ")", ")", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "words", ";", "++", "i", ")", "{", "out_regs", "[", "i", "]", "=", "expand_binop", "(", "DImode", ",", "ior_optab", ",", "data_regs", "[", "i", "]", ",", "ext_tmps", "[", "i", "]", ",", "data_regs", "[", "i", "]", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "}", "}", "</s>"], "natrual_language": ["Load", "an", "integral", "number", "of", "consecutive", "unaligned", "quadwords", "."], "TS_V_token": ["alpha", "8", "1", "0", "0", "0", "0", "8", "0", "8", "1", "0", "7", "1", "0", "1", "0", "1"], "File": "alpha", "Func": "alpha_expand_unaligned_load_words", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40751, "Length": 411}
{"ground_truth": ["<s>", "static", "void", "alpha_expand_unaligned_store_words", "(", "rtx", "*", "data_regs", ",", "rtx", "dmem", ",", "HOST_WIDE_INT", "words", ",", "HOST_WIDE_INT", "ofs", ")", "{", "rtx", "const", "im8", "=", "GEN_INT", "(", "-", "8", ")", ";", "rtx", "ins_tmps", "[", "MAX_MOVE_WORDS", "]", ";", "rtx", "st_tmp_1", ",", "st_tmp_2", ",", "dreg", ";", "rtx", "st_addr_1", ",", "st_addr_2", ",", "dmema", ";", "HOST_WIDE_INT", "i", ";", "dmema", "=", "XEXP", "(", "dmem", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "dmema", ")", "==", "LO_SUM", ")", "dmema", "=", "force_reg", "(", "Pmode", ",", "dmema", ")", ";", "if", "(", "data_regs", "!=", "NULL", ")", "for", "(", "i", "=", "0", ";", "i", "<", "words", ";", "++", "i", ")", "ins_tmps", "[", "i", "]", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "st_tmp_1", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "st_tmp_2", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "if", "(", "ofs", "!=", "0", ")", "dmem", "=", "adjust_address", "(", "dmem", ",", "GET_MODE", "(", "dmem", ")", ",", "ofs", ")", ";", "st_addr_2", "=", "change_address", "(", "dmem", ",", "DImode", ",", "gen_rtx_AND", "(", "DImode", ",", "plus_constant", "(", "DImode", ",", "dmema", ",", "words", "*", "8", "-", "1", ")", ",", "im8", ")", ")", ";", "set_mem_alias_set", "(", "st_addr_2", ",", "0", ")", ";", "st_addr_1", "=", "change_address", "(", "dmem", ",", "DImode", ",", "gen_rtx_AND", "(", "DImode", ",", "dmema", ",", "im8", ")", ")", ";", "set_mem_alias_set", "(", "st_addr_1", ",", "0", ")", ";", "emit_move_insn", "(", "st_tmp_2", ",", "st_addr_2", ")", ";", "emit_move_insn", "(", "st_tmp_1", ",", "st_addr_1", ")", ";", "dreg", "=", "copy_addr_to_reg", "(", "dmema", ")", ";", "if", "(", "data_regs", "!=", "NULL", ")", "{", "for", "(", "i", "=", "words", "-", "1", ";", "i", ">=", "0", ";", "--", "i", ")", "{", "emit_insn", "(", "gen_insqh", "(", "ins_tmps", "[", "i", "]", ",", "data_regs", "[", "i", "]", ",", "dreg", ")", ")", ";", "emit_insn", "(", "gen_insql", "(", "data_regs", "[", "i", "]", ",", "data_regs", "[", "i", "]", ",", "dreg", ")", ")", ";", "}", "for", "(", "i", "=", "words", "-", "1", ";", "i", ">", "0", ";", "--", "i", ")", "{", "ins_tmps", "[", "i", "-", "1", "]", "=", "expand_binop", "(", "DImode", ",", "ior_optab", ",", "data_regs", "[", "i", "]", ",", "ins_tmps", "[", "i", "-", "1", "]", ",", "ins_tmps", "[", "i", "-", "1", "]", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "}", "}", "emit_insn", "(", "gen_mskqh", "(", "st_tmp_2", ",", "st_tmp_2", ",", "dreg", ")", ")", ";", "emit_insn", "(", "gen_mskql", "(", "st_tmp_1", ",", "st_tmp_1", ",", "dreg", ")", ")", ";", "if", "(", "data_regs", "!=", "NULL", ")", "{", "st_tmp_2", "=", "expand_binop", "(", "DImode", ",", "ior_optab", ",", "st_tmp_2", ",", "ins_tmps", "[", "words", "-", "1", "]", ",", "st_tmp_2", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "st_tmp_1", "=", "expand_binop", "(", "DImode", ",", "ior_optab", ",", "st_tmp_1", ",", "data_regs", "[", "0", "]", ",", "st_tmp_1", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "}", "emit_move_insn", "(", "st_addr_2", ",", "st_tmp_2", ")", ";", "for", "(", "i", "=", "words", "-", "1", ";", "i", ">", "0", ";", "--", "i", ")", "{", "rtx", "tmp", "=", "change_address", "(", "dmem", ",", "DImode", ",", "gen_rtx_AND", "(", "DImode", ",", "plus_constant", "(", "DImode", ",", "dmema", ",", "i", "*", "8", ")", ",", "im8", ")", ")", ";", "set_mem_alias_set", "(", "tmp", ",", "0", ")", ";", "emit_move_insn", "(", "tmp", ",", "data_regs", "?", "ins_tmps", "[", "i", "-", "1", "]", ":", "const0_rtx", ")", ";", "}", "emit_move_insn", "(", "st_addr_1", ",", "st_tmp_1", ")", ";", "}", "</s>"], "natrual_language": ["Store", "an", "integral", "number", "of", "consecutive", "unaligned", "quadwords", ".", "DATA_REGS", "may", "be", "NULL", "to", "store", "zeros", "."], "TS_V_token": ["alpha", "8", "0", "0", "0", "8", "1", "0", "0", "1", "0", "1", "0", "1", "1", "1", "1", "1", "1", "0", "1", "1", "0", "8", "0", "1"], "File": "alpha", "Func": "alpha_expand_unaligned_store_words", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40752, "Length": 499}
{"ground_truth": ["<s>", "rtx", "alpha_expand_zap_mask", "(", "HOST_WIDE_INT", "value", ")", "{", "rtx", "result", ";", "int", "i", ";", "HOST_WIDE_INT", "mask", "=", "0", ";", "for", "(", "i", "=", "7", ";", "i", ">=", "0", ";", "--", "i", ")", "{", "mask", "<<=", "8", ";", "if", "(", "!", "(", "(", "value", ">>", "i", ")", "&", "1", ")", ")", "mask", "|=", "0xff", ";", "}", "result", "=", "gen_int_mode", "(", "mask", ",", "DImode", ")", ";", "return", "result", ";", "}", "</s>"], "natrual_language": ["Returns", "a", "mask", "so", "that", "zap", "(", "x", ",", "value", ")", "==", "x", "&", "mask", "."], "TS_V_token": ["alpha", "0", "7", "0", "8", "1", "0xff"], "File": "alpha", "Func": "alpha_expand_zap_mask", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40753, "Length": 67}
{"ground_truth": ["<s>", "static", "HOST_WIDE_INT", "alpha_extract_integer", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_VECTOR", ")", "x", "=", "simplify_subreg", "(", "DImode", ",", "x", ",", "GET_MODE", "(", "x", ")", ",", "0", ")", ";", "gcc_assert", "(", "CONST_INT_P", "(", "x", ")", ")", ";", "return", "INTVAL", "(", "x", ")", ";", "}", "</s>"], "natrual_language": ["Given", "an", "integral", "CONST_INT", ",", "CONST_DOUBLE", ",", "or", "CONST_VECTOR", ",", "return", "the", "low", "64", "bits", "."], "TS_V_token": ["alpha", "0"], "File": "alpha", "Func": "alpha_extract_integer", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40754, "Length": 48}
{"ground_truth": ["<s>", "static", "tree", "alpha_fold_builtin_cmpbge", "(", "unsigned", "HOST_WIDE_INT", "opint", "[", "]", ",", "long", "op_const", ")", "{", "if", "(", "op_const", "==", "3", ")", "{", "int", "i", ",", "val", ";", "for", "(", "i", "=", "0", ",", "val", "=", "0", ";", "i", "<", "8", ";", "++", "i", ")", "{", "unsigned", "HOST_WIDE_INT", "c0", "=", "(", "opint", "[", "0", "]", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ";", "unsigned", "HOST_WIDE_INT", "c1", "=", "(", "opint", "[", "1", "]", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ";", "if", "(", "c0", ">=", "c1", ")", "val", "|=", "1", "<<", "i", ";", "}", "return", "build_int_cst", "(", "alpha_dimode_u", ",", "val", ")", ";", "}", "else", "if", "(", "op_const", "==", "2", "&&", "opint", "[", "1", "]", "==", "0", ")", "return", "build_int_cst", "(", "alpha_dimode_u", ",", "0xff", ")", ";", "return", "NULL", ";", "}", "</s>"], "natrual_language": ["Fold", "the", "builtin", "for", "the", "CMPBGE", "instruction", ".", "This", "is", "a", "vector", "comparison", "with", "an", "8", "bit", "output", "vector", ".", "OPINT", "contains", "the", "integer", "operands", ";", "bit", "N", "of", "OP_CONST", "is", "set", "if", "OPINT", "[", "N", "]", "is", "valid", "."], "TS_V_token": ["alpha", "3", "0", "0", "8", "0", "8", "0xff", "1", "8", "0xff", "1", "2", "1", "0", "0xff"], "File": "alpha", "Func": "alpha_fold_builtin_cmpbge", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40755, "Length": 130}
{"ground_truth": ["<s>", "static", "tree", "alpha_fold_builtin_extxx", "(", "tree", "op", "[", "]", ",", "unsigned", "HOST_WIDE_INT", "opint", "[", "]", ",", "long", "op_const", ",", "unsigned", "HOST_WIDE_INT", "bytemask", ",", "bool", "is_high", ")", "{", "long", "zap_const", "=", "2", ";", "tree", "*", "zap_op", "=", "NULL", ";", "if", "(", "op_const", "&", "2", ")", "{", "unsigned", "HOST_WIDE_INT", "loc", ";", "loc", "=", "opint", "[", "1", "]", "&", "7", ";", "loc", "*=", "BITS_PER_UNIT", ";", "if", "(", "loc", "!=", "0", ")", "{", "if", "(", "op_const", "&", "1", ")", "{", "unsigned", "HOST_WIDE_INT", "temp", "=", "opint", "[", "0", "]", ";", "if", "(", "is_high", ")", "temp", "<<=", "loc", ";", "else", "temp", ">>=", "loc", ";", "opint", "[", "0", "]", "=", "temp", ";", "zap_const", "=", "3", ";", "}", "}", "else", "zap_op", "=", "op", ";", "}", "opint", "[", "1", "]", "=", "bytemask", ";", "return", "alpha_fold_builtin_zapnot", "(", "zap_op", ",", "opint", ",", "zap_const", ")", ";", "}", "</s>"], "natrual_language": ["Fold", "the", "builtins", "for", "the", "EXT", "family", "of", "instructions", "."], "TS_V_token": ["alpha", "2", "2", "1", "7", "0", "1", "0", "0", "3", "1"], "File": "alpha", "Func": "alpha_fold_builtin_extxx", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40756, "Length": 134}
{"ground_truth": ["<s>", "static", "tree", "alpha_fold_builtin_insxx", "(", "tree", "op", "[", "]", ",", "unsigned", "HOST_WIDE_INT", "opint", "[", "]", ",", "long", "op_const", ",", "unsigned", "HOST_WIDE_INT", "bytemask", ",", "bool", "is_high", ")", "{", "if", "(", "(", "op_const", "&", "1", ")", "&&", "opint", "[", "0", "]", "==", "0", ")", "return", "build_int_cst", "(", "alpha_dimode_u", ",", "0", ")", ";", "if", "(", "op_const", "&", "2", ")", "{", "unsigned", "HOST_WIDE_INT", "temp", ",", "loc", ",", "byteloc", ";", "tree", "*", "zap_op", "=", "NULL", ";", "loc", "=", "opint", "[", "1", "]", "&", "7", ";", "bytemask", "<<=", "loc", ";", "temp", "=", "opint", "[", "0", "]", ";", "if", "(", "is_high", ")", "{", "byteloc", "=", "(", "64", "-", "(", "loc", "*", "8", ")", ")", "&", "0x3f", ";", "if", "(", "byteloc", "==", "0", ")", "zap_op", "=", "op", ";", "else", "temp", ">>=", "byteloc", ";", "bytemask", ">>=", "8", ";", "}", "else", "{", "byteloc", "=", "loc", "*", "8", ";", "if", "(", "byteloc", "==", "0", ")", "zap_op", "=", "op", ";", "else", "temp", "<<=", "byteloc", ";", "}", "opint", "[", "0", "]", "=", "temp", ";", "opint", "[", "1", "]", "=", "bytemask", ";", "return", "alpha_fold_builtin_zapnot", "(", "zap_op", ",", "opint", ",", "op_const", ")", ";", "}", "return", "NULL", ";", "}", "</s>"], "natrual_language": ["Fold", "the", "builtins", "for", "the", "INS", "family", "of", "instructions", "."], "TS_V_token": ["alpha", "1", "0", "0", "0", "2", "1", "7", "0", "64", "8", "0x3f", "0", "8", "8", "0", "0", "1"], "File": "alpha", "Func": "alpha_fold_builtin_insxx", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40757, "Length": 182}
{"ground_truth": ["<s>", "static", "tree", "alpha_fold_builtin_zapnot", "(", "tree", "*", "op", ",", "unsigned", "HOST_WIDE_INT", "opint", "[", "]", ",", "long", "op_const", ")", "{", "if", "(", "op_const", "&", "2", ")", "{", "unsigned", "HOST_WIDE_INT", "mask", "=", "0", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "++", "i", ")", "if", "(", "(", "opint", "[", "1", "]", ">>", "i", ")", "&", "1", ")", "mask", "|=", "(", "unsigned", "HOST_WIDE_INT", ")", "0xff", "<<", "(", "i", "*", "8", ")", ";", "if", "(", "op_const", "&", "1", ")", "return", "build_int_cst", "(", "alpha_dimode_u", ",", "opint", "[", "0", "]", "&", "mask", ")", ";", "if", "(", "op", ")", "return", "fold_build2", "(", "BIT_AND_EXPR", ",", "alpha_dimode_u", ",", "op", "[", "0", "]", ",", "build_int_cst", "(", "alpha_dimode_u", ",", "mask", ")", ")", ";", "}", "else", "if", "(", "(", "op_const", "&", "1", ")", "&&", "opint", "[", "0", "]", "==", "0", ")", "return", "build_int_cst", "(", "alpha_dimode_u", ",", "0", ")", ";", "return", "NULL", ";", "}", "</s>"], "natrual_language": ["Fold", "the", "builtin", "for", "the", "ZAPNOT", "instruction", ".", "This", "is", "essentially", "a", "specialized", "form", "of", "an", "AND", "operation", ".", "Other", "byte", "manipulation", "instructions", "are", "defined", "in", "terms", "of", "this", "instruction", ",", "so", "this", "is", "also", "used", "as", "a", "subroutine", "for", "other", "builtins", ".", "OP", "contains", "the", "tree", "operands", ";", "OPINT", "contains", "the", "extracted", "integer", "values", ".", "Bit", "N", "of", "OP_CONST", "it", "set", "if", "OPINT", "[", "N", "]", "is", "valid", ".", "OP", "may", "be", "null", "if", "only", "OPINT", "may", "be", "considered", "."], "TS_V_token": ["alpha", "2", "0", "0", "8", "1", "1", "0xff", "8", "1", "0", "0", "1", "0", "0", "0"], "File": "alpha", "Func": "alpha_fold_builtin_zapnot", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40758, "Length": 146}
{"ground_truth": ["<s>", "static", "rtx", "alpha_function_arg", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "basereg", ";", "int", "num_args", ";", "if", "(", "arg", ".", "aggregate_type_p", "(", ")", ")", "basereg", "=", "16", ";", "else", "{", "gcc_checking_assert", "(", "!", "COMPLEX_MODE_P", "(", "arg", ".", "mode", ")", ")", ";", "if", "(", "TARGET_FPREGS", "&&", "GET_MODE_CLASS", "(", "arg", ".", "mode", ")", "==", "MODE_FLOAT", ")", "basereg", "=", "32", "+", "16", ";", "else", "basereg", "=", "16", ";", "}", "{", "if", "(", "arg", ".", "end_marker_p", "(", ")", ")", "return", "alpha_arg_info_reg_val", "(", "*", "cum", ")", ";", "num_args", "=", "cum", "->", "num_args", ";", "if", "(", "num_args", ">=", "6", "||", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "arg", ")", ")", "return", "NULL_RTX", ";", "}", "{", "if", "(", "*", "cum", ">=", "6", ")", "return", "NULL_RTX", ";", "num_args", "=", "*", "cum", ";", "if", "(", "arg", ".", "end_marker_p", "(", ")", ")", "basereg", "=", "16", ";", "else", "if", "(", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "arg", ")", ")", "return", "NULL_RTX", ";", "}", "return", "gen_rtx_REG", "(", "arg", ".", "mode", ",", "num_args", "+", "basereg", ")", ";", "}", "</s>"], "natrual_language": ["Determine", "where", "to", "put", "an", "argument", "to", "a", "function", ".", "Value", "is", "zero", "to", "push", "the", "argument", "on", "the", "stack", ",", "or", "a", "hard", "register", "in", "which", "to", "store", "the", "argument", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "CUM", "is", "a", "variable", "of", "type", "CUMULATIVE_ARGS", "which", "gives", "info", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "NAMED", "is", "nonzero", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", ".", "On", "Alpha", "the", "first", "6", "words", "of", "args", "are", "normally", "in", "registers", "and", "the", "rest", "are", "pushed", "."], "TS_V_token": ["alpha", "16", "32", "16", "16", "6", "6", "16"], "File": "alpha", "Func": "alpha_function_arg", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40759, "Length": 176}
{"ground_truth": ["<s>", "static", "void", "alpha_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "bool", "onstack", "=", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "arg", ")", ";", "int", "increment", "=", "onstack", "?", "6", ":", "ALPHA_ARG_SIZE", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ";", "*", "cum", "+=", "increment", ";", "if", "(", "!", "onstack", "&&", "cum", "->", "num_args", "<", "6", ")", "cum", "->", "atypes", "[", "cum", "->", "num_args", "]", "=", "alpha_arg_type", "(", "arg", ".", "mode", ")", ";", "cum", "->", "num_args", "+=", "increment", ";", "}", "</s>"], "natrual_language": ["Update", "the", "data", "in", "CUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "(", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", ")"], "TS_V_token": ["alpha", "6", "6"], "File": "alpha", "Func": "alpha_function_arg_advance", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40760, "Length": 91}
{"ground_truth": ["<s>", "static", "bool", "alpha_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "!", "decl", ")", "return", "false", ";", "return", "decl_has_samegp", "(", "decl", ")", ";", "}", "</s>"], "natrual_language": ["We", "do", "not", "allow", "indirect", "calls", "to", "be", "optimized", "into", "sibling", "calls", ",", "nor", "can", "we", "allow", "a", "call", "to", "a", "function", "with", "a", "different", "GP", "to", "be", "optimized", "into", "a", "sibcall", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "alpha_function_ok_for_sibcall", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40761, "Length": 27}
{"ground_truth": ["<s>", "static", "rtx", "alpha_function_value", "(", "const_tree", "valtype", ",", "const_tree", "fn_decl_or_type", ",", "bool", ")", "{", "return", "alpha_function_value_1", "(", "valtype", ",", "fn_decl_or_type", ",", "VOIDmode", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_FUNCTION_VALUE", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "alpha_function_value", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40762, "Length": 24}
{"ground_truth": ["<s>", "static", "rtx", "alpha_function_value_1", "(", "const_tree", "valtype", ",", "const_tree", "func", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ")", "{", "unsigned", "int", "regnum", ",", "dummy", "ATTRIBUTE_UNUSED", ";", "enum", "mode_class", "mclass", ";", "gcc_assert", "(", "!", "valtype", "||", "!", "alpha_return_in_memory", "(", "valtype", ",", "func", ")", ")", ";", "if", "(", "valtype", ")", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "mclass", "=", "GET_MODE_CLASS", "(", "mode", ")", ";", "switch", "(", "mclass", ")", "{", "case", "MODE_INT", ":", "if", "(", "!", "(", "TARGET_ABI_OPEN_VMS", "&&", "valtype", "&&", "AGGREGATE_TYPE_P", "(", "valtype", ")", ")", ")", "PROMOTE_MODE", "(", "mode", ",", "dummy", ",", "valtype", ")", ";", "case", "MODE_COMPLEX_INT", ":", "case", "MODE_VECTOR_INT", ":", "regnum", "=", "0", ";", "break", ";", "case", "MODE_FLOAT", ":", "regnum", "=", "32", ";", "break", ";", "case", "MODE_COMPLEX_FLOAT", ":", "{", "machine_mode", "cmode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "return", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "cmode", ",", "32", ")", ",", "const0_rtx", ")", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "cmode", ",", "33", ")", ",", "GEN_INT", "(", "GET_MODE_SIZE", "(", "cmode", ")", ")", ")", ")", ")", ";", "}", "case", "MODE_RANDOM", ":", "gcc_assert", "(", "TARGET_ABI_OPEN_VMS", "&&", "mode", "==", "BLKmode", ")", ";", "regnum", "=", "0", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "gen_rtx_REG", "(", "mode", ",", "regnum", ")", ";", "}", "</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", ",", "FUNC", "is", "its", "FUNCTION_DECL", ";", "otherwise", ",", "FUNC", "is", "0", ".", "MODE", "is", "set", "instead", "of", "VALTYPE", "for", "libcalls", ".", "On", "Alpha", "the", "value", "is", "found", "in", "$", "0", "for", "integer", "functions", "and", "$", "f0", "for", "floating-point", "functions", "."], "TS_V_token": ["alpha", "0", "32", "2", "32", "33", "0"], "File": "alpha", "Func": "alpha_function_value_1", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40763, "Length": 202}
{"ground_truth": ["<s>", "static", "bool", "alpha_function_value_regno_p", "(", "const", "unsigned", "int", "regno", ")", "{", "return", "(", "regno", "==", "0", "||", "regno", "==", "1", "||", "regno", "==", "32", "||", "regno", "==", "33", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_FUNCTION_VALUE_REGNO_P", ".", "On", "the", "Alpha", ",", "$", "0", "$", "1", "and", "$", "f0", "$", "f1", "are", "the", "only", "register", "thus", "used", "."], "TS_V_token": ["alpha", "0", "1", "32", "33"], "File": "alpha", "Func": "alpha_function_value_regno_p", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40764, "Length": 30}
{"ground_truth": ["<s>", "rtx", "alpha_gp_save_rtx", "(", "void", ")", "{", "rtx_insn", "*", "seq", ";", "rtx", "m", "=", "cfun", "->", "machine", "->", "gp_save_rtx", ";", "if", "(", "m", "==", "NULL", ")", "{", "start_sequence", "(", ")", ";", "m", "=", "assign_stack_local", "(", "DImode", ",", "UNITS_PER_WORD", ",", "BITS_PER_WORD", ")", ";", "m", "=", "validize_mem", "(", "m", ")", ";", "emit_move_insn", "(", "m", ",", "pic_offset_table_rtx", ")", ";", "seq", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "insert_insn_on_edge", "(", "seq", ",", "single_succ_edge", "(", "ENTRY_BLOCK_PTR_FOR_FN", "(", "cfun", ")", ")", ")", ";", "cfun", "->", "machine", "->", "gp_save_rtx", "=", "m", ";", "}", "return", "m", ";", "}", "</s>"], "natrual_language": ["Return", "or", "create", "a", "pseudo", "containing", "the", "gp", "value", "for", "the", "current", "function", ".", "Needed", "only", "if", "TARGET_LD_BUGGY_LDGP", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "alpha_gp_save_rtx", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40765, "Length": 91}
{"ground_truth": ["<s>", "static", "bool", "alpha_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "IN_RANGE", "(", "regno", ",", "32", ",", "62", ")", ")", "return", "(", "mode", "==", "SFmode", "||", "mode", "==", "DFmode", "||", "mode", "==", "DImode", "||", "mode", "==", "SCmode", "||", "mode", "==", "DCmode", ")", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_HARD_REGNO_MODE_OK", ".", "On", "Alpha", ",", "the", "integer", "registers", "can", "hold", "any", "mode", ".", "The", "floating-point", "registers", "can", "hold", "64-bit", "integers", "as", "well", ",", "but", "not", "smaller", "values", "."], "TS_V_token": ["alpha", "32", "62"], "File": "alpha", "Func": "alpha_hard_regno_mode_ok", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40766, "Length": 50}
{"ground_truth": ["<s>", "HOST_WIDE_INT", "alpha_initial_elimination_offset", "(", "unsigned", "int", "from", ",", "unsigned", "int", "to", "ATTRIBUTE_UNUSED", ")", "{", "HOST_WIDE_INT", "ret", ";", "ret", "=", "cfun", "->", "machine", "->", "sa_size", ";", "ret", "+=", "ALPHA_ROUND", "(", "crtl", "->", "outgoing_args_size", ")", ";", "switch", "(", "from", ")", "{", "case", "FRAME_POINTER_REGNUM", ":", "break", ";", "case", "ARG_POINTER_REGNUM", ":", "ret", "+=", "(", "ALPHA_ROUND", "(", "get_frame_size", "(", ")", "+", "crtl", "->", "args", ".", "pretend_args_size", ")", "-", "crtl", "->", "args", ".", "pretend_args_size", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "ret", ";", "}", "</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": ["alpha"], "File": "alpha", "Func": "alpha_initial_elimination_offset", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40767, "Length": 82}
{"ground_truth": ["<s>", "static", "bool", "alpha_in_small_data_p", "(", "const_tree", "exp", ")", "{", "if", "(", "TREE_CODE", "(", "exp", ")", "==", "STRING_CST", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "exp", ")", "==", "FUNCTION_DECL", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "exp", ")", "==", "VAR_DECL", "&&", "DECL_COMMON", "(", "exp", ")", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "exp", ")", "==", "VAR_DECL", "&&", "DECL_SECTION_NAME", "(", "exp", ")", ")", "{", "const", "char", "*", "section", "=", "DECL_SECTION_NAME", "(", "exp", ")", ";", "if", "(", "strcmp", "(", "section", ",", "\".sdata\"", ")", "==", "0", "||", "strcmp", "(", "section", ",", "\".sbss\"", ")", "==", "0", ")", "return", "true", ";", "}", "else", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "TREE_TYPE", "(", "exp", ")", ")", ";", "if", "(", "size", ">", "0", "&&", "size", "<=", "g_switch_value", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "EXP", "should", "be", "placed", "in", "the", "small", "data", "section", "."], "TS_V_token": ["alpha", "\".sdata\"", "0", "\".sbss\"", "0", "0"], "File": "alpha", "Func": "alpha_in_small_data_p", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40768, "Length": 129}
{"ground_truth": ["<s>", "static", "int", "alpha_issue_rate", "(", "void", ")", "{", "return", "(", "alpha_tune", "==", "PROCESSOR_EV4", "?", "2", ":", "4", ")", ";", "}", "</s>"], "natrual_language": ["Function", "to", "initialize", "the", "issue", "rate", "used", "by", "the", "scheduler", "."], "TS_V_token": ["alpha", "2", "4"], "File": "alpha", "Func": "alpha_issue_rate", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40769, "Length": 19}
{"ground_truth": ["<s>", "static", "bool", "alpha_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "strict", ")", "{", "if", "(", "mode", "==", "DImode", "&&", "GET_CODE", "(", "x", ")", "==", "AND", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "-", "8", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "SUBREG_P", "(", "x", ")", "&&", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", "<", "GET_MODE_SIZE", "(", "GET_MODE", "(", "SUBREG_REG", "(", "x", ")", ")", ")", ")", ")", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "if", "(", "REG_P", "(", "x", ")", "&&", "(", "strict", "?", "STRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ":", "NONSTRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ")", ")", "return", "true", ";", "if", "(", "CONSTANT_ADDRESS_P", "(", "x", ")", ")", "return", "true", ";", "if", "(", "LINKAGE_SYMBOL_REF_P", "(", "x", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "rtx", "ofs", "=", "XEXP", "(", "x", ",", "1", ")", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "SUBREG_P", "(", "x", ")", "&&", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", "<", "GET_MODE_SIZE", "(", "GET_MODE", "(", "SUBREG_REG", "(", "x", ")", ")", ")", ")", ")", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "if", "(", "REG_P", "(", "x", ")", ")", "{", "if", "(", "!", "strict", "&&", "NONSTRICT_REG_OK_FP_BASE_P", "(", "x", ")", "&&", "CONST_INT_P", "(", "ofs", ")", ")", "return", "true", ";", "if", "(", "(", "strict", "?", "STRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ":", "NONSTRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ")", "&&", "CONSTANT_ADDRESS_P", "(", "ofs", ")", ")", "return", "true", ";", "}", "}", "else", "if", "(", "TARGET_EXPLICIT_RELOCS", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_WORD", ")", "{", "if", "(", "small_symbolic_operand", "(", "x", ",", "Pmode", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "LO_SUM", ")", "{", "rtx", "ofs", "=", "XEXP", "(", "x", ",", "1", ")", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "SUBREG_P", "(", "x", ")", "&&", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", "<", "GET_MODE_SIZE", "(", "GET_MODE", "(", "SUBREG_REG", "(", "x", ")", ")", ")", ")", ")", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "if", "(", "!", "(", "REG_P", "(", "x", ")", "&&", "(", "strict", "?", "STRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ":", "NONSTRICT_REG_OK_FOR_BASE_P", "(", "x", ")", ")", ")", ")", "return", "false", ";", "if", "(", "local_symbolic_operand", "(", "ofs", ",", "Pmode", ")", "||", "dtp32_symbolic_operand", "(", "ofs", ",", "Pmode", ")", "||", "tp32_symbolic_operand", "(", "ofs", ",", "Pmode", ")", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["legitimate_address_p", "recognizes", "an", "RTL", "expression", "that", "is", "a", "valid", "memory", "address", "for", "an", "instruction", ".", "The", "MODE", "argument", "is", "the", "machine", "mode", "for", "the", "MEM", "expression", "that", "wants", "to", "use", "this", "address", ".", "For", "Alpha", ",", "we", "have", "either", "a", "constant", "address", "or", "the", "sum", "of", "a", "register", "and", "a", "constant", "address", ",", "or", "just", "a", "register", ".", "For", "DImode", ",", "any", "of", "those", "forms", "can", "be", "surrounded", "with", "an", "AND", "that", "clear", "the", "low-order", "three", "bits", ";", "this", "is", "an", "``", "unaligned", "''", "access", "."], "TS_V_token": ["alpha", "1", "1", "8", "0", "1", "0", "1", "0"], "File": "alpha", "Func": "alpha_legitimate_address_p", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40770, "Length": 402}
{"ground_truth": ["<s>", "bool", "alpha_legitimate_constant_p", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "HOST_WIDE_INT", "i0", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "LABEL_REF", ":", "case", "HIGH", ":", "return", "true", ";", "case", "CONST", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", ")", "x", "=", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ";", "else", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "SYMBOL_REF", ")", "return", "true", ";", "case", "SYMBOL_REF", ":", "return", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "==", "0", ";", "case", "CONST_WIDE_INT", ":", "if", "(", "TARGET_BUILD_CONSTANTS", ")", "return", "true", ";", "if", "(", "x", "==", "CONST0_RTX", "(", "mode", ")", ")", "return", "true", ";", "mode", "=", "DImode", ";", "gcc_assert", "(", "CONST_WIDE_INT_NUNITS", "(", "x", ")", "==", "2", ")", ";", "i0", "=", "CONST_WIDE_INT_ELT", "(", "x", ",", "1", ")", ";", "if", "(", "alpha_emit_set_const_1", "(", "NULL_RTX", ",", "mode", ",", "i0", ",", "3", ",", "true", ")", "==", "NULL", ")", "return", "false", ";", "i0", "=", "CONST_WIDE_INT_ELT", "(", "x", ",", "0", ")", ";", "goto", "do_integer", ";", "case", "CONST_DOUBLE", ":", "if", "(", "x", "==", "CONST0_RTX", "(", "mode", ")", ")", "return", "true", ";", "return", "false", ";", "case", "CONST_VECTOR", ":", "if", "(", "x", "==", "CONST0_RTX", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_VECTOR_INT", ")", "return", "false", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "!=", "8", ")", "return", "false", ";", "case", "CONST_INT", ":", "if", "(", "TARGET_BUILD_CONSTANTS", ")", "return", "true", ";", "i0", "=", "alpha_extract_integer", "(", "x", ")", ";", "do_integer", ":", "return", "alpha_emit_set_const_1", "(", "NULL_RTX", ",", "mode", ",", "i0", ",", "3", ",", "true", ")", "!=", "NULL", ";", "default", ":", "return", "false", ";", "}", "}", "</s>"], "natrual_language": ["Implement", "LEGITIMATE_CONSTANT_P", ".", "This", "is", "all", "constants", "for", "which", "we", "are", "willing", "to", "load", "the", "value", "into", "a", "register", "via", "a", "move", "pattern", ".", "Normally", "this", "is", "all", "symbolic", "constants", ",", "integral", "constants", "that", "take", "three", "or", "fewer", "instructions", ",", "and", "floating-point", "zero", "."], "TS_V_token": ["alpha", "0", "0", "1", "0", "0", "0", "2", "1", "3", "0", "8", "3"], "File": "alpha", "Func": "alpha_legitimate_constant_p", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40771, "Length": 279}
{"ground_truth": ["<s>", "static", "rtx", "alpha_legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ")", "{", "rtx", "new_x", "=", "alpha_legitimize_address_1", "(", "x", ",", "NULL_RTX", ",", "mode", ")", ";", "return", "new_x", "?", "new_x", ":", "x", ";", "}", "</s>"], "natrual_language": ["Try", "machine-dependent", "ways", "of", "modifying", "an", "illegitimate", "address", "to", "be", "legitimate", ".", "If", "we", "find", "one", ",", "return", "the", "new", ",", "valid", "address", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "alpha_legitimize_address", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40772, "Length": 35}
{"ground_truth": ["<s>", "rtx", "alpha_legitimize_reload_address", "(", "rtx", "x", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "opnum", ",", "int", "type", ",", "int", "ind_levels", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "push_reload", "(", "XEXP", "(", "x", ",", "0", ")", ",", "NULL_RTX", ",", "&", "XEXP", "(", "x", ",", "0", ")", ",", "NULL", ",", "BASE_REG_CLASS", ",", "GET_MODE", "(", "x", ")", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "(", "enum", "reload_type", ")", "type", ")", ";", "return", "x", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "<", "FIRST_PSEUDO_REGISTER", "&&", "REGNO_OK_FOR_BASE_P", "(", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "HOST_WIDE_INT", "val", "=", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ";", "HOST_WIDE_INT", "low", "=", "(", "(", "val", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "HOST_WIDE_INT", "high", "=", "(", "(", "(", "val", "-", "low", ")", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "if", "(", "high", "+", "low", "!=", "val", ")", "return", "NULL_RTX", ";", "x", "=", "gen_rtx_PLUS", "(", "GET_MODE", "(", "x", ")", ",", "gen_rtx_PLUS", "(", "GET_MODE", "(", "x", ")", ",", "XEXP", "(", "x", ",", "0", ")", ",", "GEN_INT", "(", "high", ")", ")", ",", "GEN_INT", "(", "low", ")", ")", ";", "push_reload", "(", "XEXP", "(", "x", ",", "0", ")", ",", "NULL_RTX", ",", "&", "XEXP", "(", "x", ",", "0", ")", ",", "NULL", ",", "BASE_REG_CLASS", ",", "GET_MODE", "(", "x", ")", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "(", "enum", "reload_type", ")", "type", ")", ";", "return", "x", ";", "}", "return", "NULL_RTX", ";", "}", "</s>"], "natrual_language": ["Try", "a", "machine-dependent", "way", "of", "reloading", "an", "illegitimate", "address", "operand", ".", "If", "we", "find", "one", ",", "push", "the", "reload", "and", "return", "the", "new", "rtx", "."], "TS_V_token": ["alpha", "0", "0", "0", "0", "1", "1", "0", "0", "0", "0", "0", "0", "0", "1", "1", "0xffff", "0x8000", "0x8000", "0xffffffff", "0x80000000", "0x80000000", "0", "0", "0", "0", "0"], "File": "alpha", "Func": "alpha_legitimize_reload_address", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40773, "Length": 329}
{"ground_truth": ["<s>", "static", "rtx", "alpha_libcall_value", "(", "machine_mode", "mode", ",", "const_rtx", ")", "{", "return", "alpha_function_value_1", "(", "NULL_TREE", ",", "NULL_TREE", ",", "mode", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_LIBCALL_VALUE", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "alpha_libcall_value", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40774, "Length": 21}
{"ground_truth": ["<s>", "static", "rtx", "alpha_lookup_xfloating_lib_func", "(", "enum", "rtx_code", "code", ")", "{", "struct", "xfloating_op", "*", "ops", "=", "xfloating_ops", ";", "long", "n", "=", "ARRAY_SIZE", "(", "xfloating_ops", ")", ";", "long", "i", ";", "gcc_assert", "(", "TARGET_HAS_XFLOATING_LIBS", ")", ";", "if", "(", "TARGET_FLOAT_VAX", "&&", "(", "code", "==", "FLOAT_EXTEND", "||", "code", "==", "FLOAT_TRUNCATE", ")", ")", "{", "ops", "=", "vax_cvt_ops", ";", "n", "=", "ARRAY_SIZE", "(", "vax_cvt_ops", ")", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "n", ";", "++", "i", ",", "++", "ops", ")", "if", "(", "ops", "->", "code", "==", "code", ")", "{", "rtx", "func", "=", "ops", "->", "libcall", ";", "if", "(", "!", "func", ")", "{", "func", "=", "init_one_libfunc", "(", "TARGET_ABI_OPEN_VMS", "?", "ops", "->", "vms_func", ":", "ops", "->", "osf_func", ")", ";", "ops", "->", "libcall", "=", "func", ";", "}", "return", "func", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>"], "natrual_language": ["Look", "up", "the", "function", "X_floating", "library", "function", "name", "for", "the", "given", "operation", "."], "TS_V_token": ["alpha", "0"], "File": "alpha", "Func": "alpha_lookup_xfloating_lib_func", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40775, "Length": 128}
{"ground_truth": ["<s>", "static", "const", "char", "*", "alpha_mangle_type", "(", "const_tree", "type", ")", "{", "if", "(", "TYPE_MAIN_VARIANT", "(", "type", ")", "==", "long_double_type_node", "&&", "TARGET_LONG_DOUBLE_128", ")", "return", "\"g\"", ";", "return", "NULL", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_MANGLE_TYPE", "."], "TS_V_token": ["alpha", "\"g\""], "File": "alpha", "Func": "alpha_mangle_type", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40776, "Length": 28}
{"ground_truth": ["<s>", "static", "int", "alpha_memory_move_cost", "(", "machine_mode", ",", "reg_class_t", ",", "bool", ")", "{", "return", "2", "*", "alpha_memory_latency", ";", "}", "</s>"], "natrual_language": ["Return", "the", "cost", "of", "moving", "data", "of", "MODE", "from", "a", "register", "to", "or", "from", "memory", ".", "On", "the", "Alpha", ",", "bump", "this", "up", "a", "bit", "."], "TS_V_token": ["alpha", "2"], "File": "alpha", "Func": "alpha_memory_move_cost", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40777, "Length": 17}
{"ground_truth": ["<s>", "static", "bool", "alpha_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "return", "(", "alpha_hard_regno_mode_ok", "(", "32", ",", "mode1", ")", "?", "alpha_hard_regno_mode_ok", "(", "32", ",", "mode2", ")", ":", "true", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_MODES_TIEABLE_P", ".", "This", "asymmetric", "test", "is", "true", "when", "MODE1", "could", "be", "put", "in", "an", "FP", "register", "but", "MODE2", "could", "not", "."], "TS_V_token": ["alpha", "32", "32"], "File": "alpha", "Func": "alpha_modes_tieable_p", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40778, "Length": 31}
{"ground_truth": ["<s>", "static", "bool", "alpha_mode_dependent_address_p", "(", "const_rtx", "addr", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ")", "{", "return", "GET_CODE", "(", "addr", ")", "==", "AND", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "ADDR", "has", "an", "effect", "that", "depends", "on", "the", "machine", "mode", "it", "is", "used", "for", ".", "On", "the", "Alpha", "this", "is", "true", "only", "for", "the", "unaligned", "modes", ".", "We", "can", "simplify", "the", "test", "since", "we", "know", "that", "the", "address", "must", "be", "valid", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "alpha_mode_dependent_address_p", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40779, "Length": 21}
{"ground_truth": ["<s>", "static", "int", "alpha_multipass_dfa_lookahead", "(", "void", ")", "{", "return", "(", "alpha_tune", "==", "PROCESSOR_EV6", "?", "4", ":", "2", ")", ";", "}", "</s>"], "natrual_language": ["How", "many", "alternative", "schedules", "to", "try", ".", "This", "should", "be", "as", "wide", "as", "the", "scheduling", "freedom", "in", "the", "DFA", ",", "but", "no", "wider", ".", "Making", "this", "value", "too", "large", "results", "extra", "work", "for", "the", "scheduler", ".", "For", "EV4", ",", "loads", "can", "be", "issued", "to", "either", "IB0", "or", "IB1", ",", "thus", "we", "have", "2", "alternative", "schedules", ".", "For", "EV5", ",", "we", "can", "choose", "between", "E0/E1", "and", "FA/FM", ".", "For", "EV6", ",", "an", "arithmetic", "insn", "can", "be", "issued", "to", "U0/U1/L0/L1", "."], "TS_V_token": ["alpha", "4", "2"], "File": "alpha", "Func": "alpha_multipass_dfa_lookahead", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40780, "Length": 19}
{"ground_truth": ["<s>", "void", "alpha_output_filename", "(", "FILE", "*", "stream", ",", "const", "char", "*", "name", ")", "{", "static", "int", "first_time", "=", "TRUE", ";", "if", "(", "first_time", ")", "{", "first_time", "=", "FALSE", ";", "++", "num_source_filenames", ";", "current_function_file", "=", "name", ";", "fprintf", "(", "stream", ",", "\"\\t.file\\t%d \"", ",", "num_source_filenames", ")", ";", "output_quoted_string", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\"\\n\"", ")", ";", "}", "else", "if", "(", "name", "!=", "current_function_file", "&&", "strcmp", "(", "name", ",", "current_function_file", ")", "!=", "0", ")", "{", "++", "num_source_filenames", ";", "current_function_file", "=", "name", ";", "fprintf", "(", "stream", ",", "\"\\t.file\\t%d \"", ",", "num_source_filenames", ")", ";", "output_quoted_string", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\"\\n\"", ")", ";", "}", "}", "</s>"], "natrual_language": ["Emit", "a", "new", "filename", "to", "a", "stream", "."], "TS_V_token": ["alpha", "\"\\t.file\\t%d \"", "\"\\n\"", "0", "\"\\t.file\\t%d \"", "\"\\n\""], "File": "alpha", "Func": "alpha_output_filename", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40781, "Length": 108}
{"ground_truth": ["<s>", "static", "void", "alpha_output_function_end_prologue", "(", "FILE", "*", "file", ")", "{", "if", "(", "TARGET_ABI_OPEN_VMS", ")", "fputs", "(", "\"\\t.prologue\\n\"", ",", "file", ")", ";", "else", "if", "(", "!", "flag_inhibit_size_directive", ")", "fprintf", "(", "file", ",", "\"\\t.prologue %d\\n\"", ",", "alpha_function_needs_gp", "||", "cfun", "->", "is_thunk", ")", ";", "}", "</s>"], "natrual_language": ["Emit", "the", ".prologue", "note", "at", "the", "scheduled", "end", "of", "the", "prologue", "."], "TS_V_token": ["alpha", "\"\\t.prologue\\n\"", "\"\\t.prologue %d\\n\""], "File": "alpha", "Func": "alpha_output_function_end_prologue", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40782, "Length": 40}
{"ground_truth": ["<s>", "static", "void", "alpha_output_mi_thunk_osf", "(", "FILE", "*", "file", ",", "tree", "thunk_fndecl", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "const", "char", "*", "fnname", "=", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "thunk_fndecl", ")", ")", ";", "HOST_WIDE_INT", "hi", ",", "lo", ";", "rtx", "this_rtx", ",", "funexp", ";", "rtx_insn", "*", "insn", ";", "emit_insn", "(", "gen_prologue_ldgp", "(", ")", ")", ";", "emit_note", "(", "NOTE_INSN_PROLOGUE_END", ")", ";", "if", "(", "aggregate_value_p", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "function", ")", ")", ",", "function", ")", ")", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "17", ")", ";", "else", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "16", ")", ";", "lo", "=", "(", "(", "delta", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "hi", "=", "(", "(", "(", "delta", "-", "lo", ")", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "if", "(", "hi", "+", "lo", "==", "delta", ")", "{", "if", "(", "hi", ")", "emit_insn", "(", "gen_adddi3", "(", "this_rtx", ",", "this_rtx", ",", "GEN_INT", "(", "hi", ")", ")", ")", ";", "if", "(", "lo", ")", "emit_insn", "(", "gen_adddi3", "(", "this_rtx", ",", "this_rtx", ",", "GEN_INT", "(", "lo", ")", ")", ")", ";", "}", "else", "{", "rtx", "tmp", "=", "alpha_emit_set_long_const", "(", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ",", "delta", ")", ";", "emit_insn", "(", "gen_adddi3", "(", "this_rtx", ",", "this_rtx", ",", "tmp", ")", ")", ";", "}", "if", "(", "vcall_offset", ")", "{", "rtx", "tmp", ",", "tmp2", ";", "tmp", "=", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ";", "emit_move_insn", "(", "tmp", ",", "gen_rtx_MEM", "(", "Pmode", ",", "this_rtx", ")", ")", ";", "lo", "=", "(", "(", "vcall_offset", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "hi", "=", "(", "(", "(", "vcall_offset", "-", "lo", ")", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "if", "(", "hi", "+", "lo", "==", "vcall_offset", ")", "{", "if", "(", "hi", ")", "emit_insn", "(", "gen_adddi3", "(", "tmp", ",", "tmp", ",", "GEN_INT", "(", "hi", ")", ")", ")", ";", "}", "else", "{", "tmp2", "=", "alpha_emit_set_long_const", "(", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ",", "vcall_offset", ")", ";", "emit_insn", "(", "gen_adddi3", "(", "tmp", ",", "tmp", ",", "tmp2", ")", ")", ";", "lo", "=", "0", ";", "}", "if", "(", "lo", ")", "tmp2", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "tmp", ",", "GEN_INT", "(", "lo", ")", ")", ";", "else", "tmp2", "=", "tmp", ";", "emit_move_insn", "(", "tmp", ",", "gen_rtx_MEM", "(", "Pmode", ",", "tmp2", ")", ")", ";", "emit_insn", "(", "gen_adddi3", "(", "this_rtx", ",", "this_rtx", ",", "tmp", ")", ")", ";", "}", "if", "(", "!", "TREE_USED", "(", "function", ")", ")", "{", "assemble_external", "(", "function", ")", ";", "TREE_USED", "(", "function", ")", "=", "1", ";", "}", "funexp", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ";", "funexp", "=", "gen_rtx_MEM", "(", "FUNCTION_MODE", ",", "funexp", ")", ";", "insn", "=", "emit_call_insn", "(", "gen_sibcall", "(", "funexp", ",", "const0_rtx", ")", ")", ";", "SIBLING_CALL_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "get_insns", "(", ")", ";", "shorten_branches", "(", "insn", ")", ";", "assemble_start_function", "(", "thunk_fndecl", ",", "fnname", ")", ";", "final_start_function", "(", "insn", ",", "file", ",", "1", ")", ";", "final", "(", "insn", ",", "file", ",", "1", ")", ";", "final_end_function", "(", ")", ";", "assemble_end_function", "(", "thunk_fndecl", ",", "fnname", ")", ";", "}", "</s>"], "natrual_language": ["Emit", "a", "tail", "call", "to", "FUNCTION", "after", "adjusting", "THIS", "by", "DELTA", ".", "In", "order", "to", "avoid", "the", "hordes", "of", "differences", "between", "generated", "code", "with", "and", "without", "TARGET_EXPLICIT_RELOCS", ",", "and", "to", "avoid", "duplicating", "lots", "of", "code", "loading", "up", "large", "constants", ",", "generate", "rtl", "and", "emit", "it", "instead", "of", "going", "straight", "to", "text", ".", "Not", "sure", "why", "this", "idea", "has", "n't", "been", "explored", "before", "..."], "TS_V_token": ["alpha", "17", "16", "0xffff", "0x8000", "0x8000", "0xffffffff", "0x80000000", "0x80000000", "0", "0", "0xffff", "0x8000", "0x8000", "0xffffffff", "0x80000000", "0x80000000", "1", "0", "1", "0", "1", "1", "1"], "File": "alpha", "Func": "alpha_output_mi_thunk_osf", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40783, "Length": 488}
{"ground_truth": ["<s>", "static", "void", "alpha_override_options_after_change", "(", "void", ")", "{", "if", "(", "optimize", ">", "0", ")", "{", "if", "(", "flag_align_loops", "&&", "!", "str_align_loops", ")", "str_align_loops", "=", "\"16\"", ";", "if", "(", "flag_align_jumps", "&&", "!", "str_align_jumps", ")", "str_align_jumps", "=", "\"16\"", ";", "}", "if", "(", "flag_align_functions", "&&", "!", "str_align_functions", ")", "str_align_functions", "=", "\"16\"", ";", "}", "</s>"], "natrual_language": ["Implement", "targetm.override_options_after_change", "."], "TS_V_token": ["alpha", "0", "\"16\"", "\"16\"", "\"16\""], "File": "alpha", "Func": "alpha_override_options_after_change", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40784, "Length": 49}
{"ground_truth": ["<s>", "static", "void", "alpha_pad_function_end", "(", "void", ")", "{", "rtx_insn", "*", "insn", ",", "*", "next", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "!", "CALL_P", "(", "insn", ")", "||", "!", "(", "SIBLING_CALL_P", "(", "insn", ")", "||", "find_reg_note", "(", "insn", ",", "REG_NORETURN", ",", "NULL_RTX", ")", ")", ")", "continue", ";", "next", "=", "next_active_insn", "(", "insn", ")", ";", "if", "(", "next", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "next", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SET", "&&", "GET_CODE", "(", "SET_SRC", "(", "pat", ")", ")", "==", "UNSPEC_VOLATILE", "&&", "XINT", "(", "SET_SRC", "(", "pat", ")", ",", "1", ")", "==", "UNSPECV_LDGP1", ")", "emit_insn_after", "(", "gen_unop", "(", ")", ",", "insn", ")", ";", "}", "}", "}", "</s>"], "natrual_language": ["Insert", "an", "unop", "between", "sibcall", "or", "noreturn", "function", "call", "and", "GP", "load", "."], "TS_V_token": ["alpha", "1"], "File": "alpha", "Func": "alpha_pad_function_end", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40785, "Length": 122}
{"ground_truth": ["<s>", "static", "bool", "alpha_pass_by_reference", "(", "cumulative_args_t", ",", "const", "function_arg_info", "&", "arg", ")", "{", "if", "(", "arg", ".", "mode", "==", "SFmode", "||", "arg", ".", "mode", "==", "SCmode", ")", "return", "!", "arg", ".", "named", ";", "return", "arg", ".", "mode", "==", "TFmode", "||", "arg", ".", "mode", "==", "TCmode", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "TYPE", "should", "be", "passed", "by", "invisible", "reference", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "alpha_pass_by_reference", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40786, "Length": 46}
{"ground_truth": ["<s>", "enum", "reg_class", "alpha_preferred_reload_class", "(", "rtx", "x", ",", "enum", "reg_class", "rclass", ")", "{", "if", "(", "x", "==", "CONST0_RTX", "(", "GET_MODE", "(", "x", ")", ")", ")", "return", "rclass", ";", "if", "(", "CONST_SCALAR_INT_P", "(", "x", ")", "||", "CONST_DOUBLE_P", "(", "x", ")", "||", "GET_CODE", "(", "x", ")", "==", "CONST_VECTOR", ")", "{", "if", "(", "rclass", "==", "FLOAT_REGS", ")", "return", "NO_REGS", ";", "if", "(", "rclass", "==", "ALL_REGS", ")", "return", "GENERAL_REGS", ";", "return", "rclass", ";", "}", "if", "(", "CONSTANT_P", "(", "x", ")", ")", "return", "(", "rclass", "==", "ALL_REGS", "?", "GENERAL_REGS", ":", "rclass", ")", ";", "return", "rclass", ";", "}", "</s>"], "natrual_language": ["On", "the", "Alpha", ",", "all", "(", "non-symbolic", ")", "constants", "except", "zero", "go", "into", "a", "floating-point", "register", "via", "memory", ".", "Note", "that", "we", "can", "not", "return", "anything", "that", "is", "not", "a", "subset", "of", "CLASS", ",", "and", "that", "some", "symbolic", "constants", "can", "not", "be", "dropped", "to", "memory", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "alpha_preferred_reload_class", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40787, "Length": 91}
{"ground_truth": ["<s>", "static", "void", "alpha_pre_atomic_barrier", "(", "enum", "memmodel", "model", ")", "{", "if", "(", "need_atomic_barrier_p", "(", "model", ",", "true", ")", ")", "emit_insn", "(", "gen_memory_barrier", "(", ")", ")", ";", "}", "</s>"], "natrual_language": ["Subroutines", "of", "the", "atomic", "operation", "splitters", ".", "Emit", "barriers", "as", "needed", "for", "the", "memory", "MODEL", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "alpha_pre_atomic_barrier", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40788, "Length": 26}
{"ground_truth": ["<s>", "static", "void", "alpha_print_operand_address", "(", "FILE", "*", "file", ",", "machine_mode", ",", "rtx", "addr", ")", "{", "int", "basereg", "=", "31", ";", "HOST_WIDE_INT", "offset", "=", "0", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "AND", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ")", "{", "offset", "=", "INTVAL", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "addr", ")", "==", "LO_SUM", ")", "{", "const", "char", "*", "reloc16", ",", "*", "reloclo", ";", "rtx", "op1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "op1", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "op1", ",", "0", ")", ")", "==", "UNSPEC", ")", "{", "op1", "=", "XEXP", "(", "op1", ",", "0", ")", ";", "switch", "(", "XINT", "(", "op1", ",", "1", ")", ")", "{", "case", "UNSPEC_DTPREL", ":", "reloc16", "=", "NULL", ";", "reloclo", "=", "(", "alpha_tls_size", "==", "16", "?", "\"dtprel\"", ":", "\"dtprello\"", ")", ";", "break", ";", "case", "UNSPEC_TPREL", ":", "reloc16", "=", "NULL", ";", "reloclo", "=", "(", "alpha_tls_size", "==", "16", "?", "\"tprel\"", ":", "\"tprello\"", ")", ";", "break", ";", "default", ":", "output_operand_lossage", "(", "\"unknown relocation unspec\"", ")", ";", "return", ";", "}", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "op1", ",", "0", ",", "0", ")", ")", ";", "}", "else", "{", "reloc16", "=", "\"gprel\"", ";", "reloclo", "=", "\"gprellow\"", ";", "output_addr_const", "(", "file", ",", "op1", ")", ";", "}", "if", "(", "offset", ")", "fprintf", "(", "file", ",", "\"+\"", "HOST_WIDE_INT_PRINT_DEC", ",", "offset", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "basereg", "=", "REGNO", "(", "addr", ")", ";", "break", ";", "case", "SUBREG", ":", "basereg", "=", "subreg_regno", "(", "addr", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "fprintf", "(", "file", ",", "\"($%d)\\t\\t!%s\"", ",", "basereg", ",", "(", "basereg", "==", "29", "?", "reloc16", ":", "reloclo", ")", ")", ";", "return", ";", "}", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "basereg", "=", "REGNO", "(", "addr", ")", ";", "break", ";", "case", "SUBREG", ":", "basereg", "=", "subreg_regno", "(", "addr", ")", ";", "break", ";", "case", "CONST_INT", ":", "offset", "=", "INTVAL", "(", "addr", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "gcc_assert", "(", "TARGET_ABI_OPEN_VMS", "||", "this_is_asm_operands", ")", ";", "fprintf", "(", "file", ",", "\"%s\"", ",", "XSTR", "(", "addr", ",", "0", ")", ")", ";", "return", ";", "case", "CONST", ":", "gcc_assert", "(", "TARGET_ABI_OPEN_VMS", "||", "this_is_asm_operands", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", ";", "fprintf", "(", "file", ",", "\"%s+\"", "HOST_WIDE_INT_PRINT_DEC", ",", "XSTR", "(", "XEXP", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ",", "0", ")", ",", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "1", ")", ")", ")", ";", "return", ";", "default", ":", "output_operand_lossage", "(", "\"invalid operand address\"", ")", ";", "return", ";", "}", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", "\"($%d)\"", ",", "offset", ",", "basereg", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_PRINT_OPERAND_ADDRESS", "."], "TS_V_token": ["alpha", "31", "0", "0", "1", "1", "0", "1", "0", "0", "1", "16", "\"dtprel\"", "\"dtprello\"", "16", "\"tprel\"", "\"tprello\"", "\"unknown relocation unspec\"", "0", "0", "\"gprel\"", "\"gprellow\"", "\"+\"", "0", "\"($%d)\\t\\t!%s\"", "29", "\"%s\"", "0", "0", "0", "0", "\"%s+\"", "0", "0", "0", "0", "1", "\"invalid operand address\"", "\"($%d)\""], "File": "alpha", "Func": "alpha_print_operand_address", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40789, "Length": 499}
{"ground_truth": ["<s>", "static", "bool", "alpha_print_operand_punct_valid_p", "(", "unsigned", "char", "code", ")", "{", "return", "(", "code", "==", "'/'", "||", "code", "==", "','", "||", "code", "==", "'-'", "||", "code", "==", "'~'", "||", "code", "==", "'#'", "||", "code", "==", "'*'", "||", "code", "==", "'&'", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_PRINT_OPERAND_PUNCT_VALID_P", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "alpha_print_operand_punct_valid_p", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40790, "Length": 41}
{"ground_truth": ["<s>", "static", "int", "alpha_register_move_cost", "(", "machine_mode", ",", "reg_class_t", "from", ",", "reg_class_t", "to", ")", "{", "if", "(", "(", "from", "==", "FLOAT_REGS", ")", "==", "(", "to", "==", "FLOAT_REGS", ")", ")", "return", "2", ";", "if", "(", "TARGET_FIX", ")", "return", "(", "from", "==", "FLOAT_REGS", ")", "?", "6", ":", "8", ";", "return", "4", "+", "2", "*", "alpha_memory_latency", ";", "}", "</s>"], "natrual_language": ["Return", "the", "cost", "of", "moving", "between", "registers", "of", "various", "classes", ".", "Moving", "between", "FLOAT_REGS", "and", "anything", "else", "except", "float", "regs", "is", "expensive", ".", "In", "fact", ",", "we", "make", "it", "quite", "expensive", "because", "we", "really", "do", "n't", "want", "to", "do", "these", "moves", "unless", "it", "is", "clearly", "worth", "it", ".", "Optimizations", "may", "reduce", "the", "impact", "of", "not", "being", "able", "to", "allocate", "a", "pseudo", "to", "a", "hard", "register", "."], "TS_V_token": ["alpha", "2", "6", "8", "4", "2"], "File": "alpha", "Func": "alpha_register_move_cost", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40791, "Length": 53}
{"ground_truth": ["<s>", "static", "void", "alpha_reorg", "(", "void", ")", "{", "if", "(", "current_function_has_exception_handlers", "(", ")", ")", "alpha_pad_function_end", "(", ")", ";", "rtx_insn", "*", "insn", "=", "prev_active_insn", "(", "get_last_insn", "(", ")", ")", ";", "if", "(", "insn", "&&", "NONJUMP_INSN_P", "(", "insn", ")", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "{", "rtx", "vec", "=", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "vec", ")", "==", "TRAP_IF", "&&", "XEXP", "(", "vec", ",", "0", ")", "==", "const1_rtx", ")", "emit_insn_after", "(", "gen_unop", "(", ")", ",", "insn", ")", ";", "}", "}", "}", "</s>"], "natrual_language": ["Machine", "dependent", "reorg", "pass", "."], "TS_V_token": ["alpha", "0", "0", "0"], "File": "alpha", "Func": "alpha_reorg", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40792, "Length": 98}
{"ground_truth": ["<s>", "rtx", "alpha_return_addr", "(", "int", "count", ",", "rtx", "frame", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "count", "!=", "0", ")", "return", "const0_rtx", ";", "return", "get_hard_reg_initial_val", "(", "Pmode", ",", "REG_RA", ")", ";", "}", "</s>"], "natrual_language": ["Start", "the", "ball", "rolling", "with", "RETURN_ADDR_RTX", "."], "TS_V_token": ["alpha", "0"], "File": "alpha", "Func": "alpha_return_addr", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40793, "Length": 29}
{"ground_truth": ["<s>", "static", "bool", "alpha_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fndecl", "ATTRIBUTE_UNUSED", ")", "{", "machine_mode", "mode", "=", "VOIDmode", ";", "int", "size", ";", "if", "(", "type", ")", "{", "mode", "=", "TYPE_MODE", "(", "type", ")", ";", "if", "(", "TARGET_ABI_OPEN_VMS", "&&", "TREE_CODE", "(", "type", ")", "!=", "ARRAY_TYPE", "&&", "(", "unsigned", "HOST_WIDE_INT", ")", "int_size_in_bytes", "(", "type", ")", "<=", "8", ")", "return", "false", ";", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "return", "true", ";", "}", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "switch", "(", "GET_MODE_CLASS", "(", "mode", ")", ")", "{", "case", "MODE_VECTOR_FLOAT", ":", "return", "true", ";", "case", "MODE_COMPLEX_FLOAT", ":", "size", "=", "GET_MODE_UNIT_SIZE", "(", "mode", ")", ";", "break", ";", "case", "MODE_INT", ":", "case", "MODE_FLOAT", ":", "case", "MODE_COMPLEX_INT", ":", "case", "MODE_VECTOR_INT", ":", "break", ";", "default", ":", "return", "true", ";", "}", "return", "size", ">", "UNITS_PER_WORD", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "TYPE", "must", "be", "returned", "in", "memory", ",", "instead", "of", "in", "registers", "."], "TS_V_token": ["alpha", "8"], "File": "alpha", "Func": "alpha_return_in_memory", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40794, "Length": 127}
{"ground_truth": ["<s>", "static", "bool", "alpha_scalar_mode_supported_p", "(", "scalar_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "case", "E_HImode", ":", "case", "E_SImode", ":", "case", "E_DImode", ":", "case", "E_TImode", ":", "return", "true", ";", "case", "E_SFmode", ":", "case", "E_DFmode", ":", "return", "true", ";", "case", "E_TFmode", ":", "return", "TARGET_HAS_XFLOATING_LIBS", ";", "default", ":", "return", "false", ";", "}", "}", "</s>"], "natrual_language": ["The", "scalar", "modes", "supported", "differs", "from", "the", "default", "check-what-c-supports", "version", "in", "that", "sometimes", "TFmode", "is", "available", "even", "when", "long", "double", "indicates", "only", "DFmode", ".", "On", "unicosmk", ",", "we", "have", "the", "situation", "that", "HImode", "does", "n't", "map", "to", "any", "C", "type", ",", "but", "of", "course", "we", "still", "support", "that", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "alpha_scalar_mode_supported_p", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40795, "Length": 53}
{"ground_truth": ["<s>", "static", "bool", "alpha_secondary_memory_needed", "(", "machine_mode", ",", "reg_class_t", "class1", ",", "reg_class_t", "class2", ")", "{", "return", "(", "!", "TARGET_FIX", "&&", "(", "(", "class1", "==", "FLOAT_REGS", "&&", "class2", "!=", "FLOAT_REGS", ")", "||", "(", "class2", "==", "FLOAT_REGS", "&&", "class1", "!=", "FLOAT_REGS", ")", ")", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_SECONDARY_MEMORY_NEEDED", ".", "If", "we", "are", "copying", "between", "general", "and", "FP", "registers", ",", "we", "need", "a", "memory", "location", "unless", "the", "FIX", "extension", "is", "available", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "alpha_secondary_memory_needed", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40796, "Length": 42}
{"ground_truth": ["<s>", "static", "machine_mode", "alpha_secondary_memory_needed_mode", "(", "machine_mode", "mode", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", "return", "mode", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">=", "4", ")", "return", "mode", ";", "return", "mode_for_size", "(", "BITS_PER_WORD", ",", "GET_MODE_CLASS", "(", "mode", ")", ",", "0", ")", ".", "require", "(", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_SECONDARY_MEMORY_NEEDED_MODE", ".", "If", "MODE", "is", "floating-point", ",", "use", "it", ".", "Otherwise", ",", "widen", "to", "a", "word", "like", "the", "default", ".", "This", "is", "needed", "because", "we", "always", "store", "integers", "in", "FP", "registers", "in", "quadword", "format", ".", "This", "whole", "area", "is", "very", "tricky", "!"], "TS_V_token": ["alpha", "4", "0"], "File": "alpha", "Func": "alpha_secondary_memory_needed_mode", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40797, "Length": 50}
{"ground_truth": ["<s>", "static", "reg_class_t", "alpha_secondary_reload", "(", "bool", "in_p", ",", "rtx", "x", ",", "reg_class_t", "rclass_i", ",", "machine_mode", "mode", ",", "secondary_reload_info", "*", "sri", ")", "{", "enum", "reg_class", "rclass", "=", "(", "enum", "reg_class", ")", "rclass_i", ";", "if", "(", "!", "TARGET_BWX", "&&", "(", "mode", "==", "QImode", "||", "mode", "==", "HImode", "||", "mode", "==", "CQImode", ")", ")", "{", "if", "(", "any_memory_operand", "(", "x", ",", "mode", ")", ")", "{", "if", "(", "in_p", ")", "{", "if", "(", "!", "aligned_memory_operand", "(", "x", ",", "mode", ")", ")", "sri", "->", "icode", "=", "direct_optab_handler", "(", "reload_in_optab", ",", "mode", ")", ";", "}", "else", "sri", "->", "icode", "=", "direct_optab_handler", "(", "reload_out_optab", ",", "mode", ")", ";", "return", "NO_REGS", ";", "}", "}", "if", "(", "rclass", "==", "FLOAT_REGS", ")", "{", "if", "(", "MEM_P", "(", "x", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "AND", ")", "return", "GENERAL_REGS", ";", "if", "(", "in_p", "&&", "INTEGRAL_MODE_P", "(", "mode", ")", "&&", "!", "MEM_P", "(", "x", ")", "&&", "!", "REG_P", "(", "x", ")", "&&", "!", "CONST_INT_P", "(", "x", ")", ")", "return", "GENERAL_REGS", ";", "}", "return", "NO_REGS", ";", "}", "</s>"], "natrual_language": ["Inform", "reload", "about", "cases", "where", "moving", "X", "with", "a", "mode", "MODE", "to", "a", "register", "in", "RCLASS", "requires", "an", "extra", "scratch", "or", "immediate", "register", ".", "Return", "the", "class", "needed", "for", "the", "immediate", "register", "."], "TS_V_token": ["alpha", "0"], "File": "alpha", "Func": "alpha_secondary_reload", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40798, "Length": 169}
{"ground_truth": ["<s>", "static", "void", "alpha_setup_incoming_varargs", "(", "cumulative_args_t", "pcum", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_size", ",", "int", "no_rtl", ")", "{", "CUMULATIVE_ARGS", "cum", "=", "*", "get_cumulative_args", "(", "pcum", ")", ";", "targetm", ".", "calls", ".", "function_arg_advance", "(", "pack_cumulative_args", "(", "&", "cum", ")", ",", "arg", ")", ";", "if", "(", "cum", ".", "num_args", "<", "6", ")", "{", "if", "(", "!", "no_rtl", ")", "{", "emit_move_insn", "(", "gen_rtx_REG", "(", "DImode", ",", "1", ")", ",", "virtual_incoming_args_rtx", ")", ";", "emit_insn", "(", "gen_arg_home", "(", ")", ")", ";", "}", "*", "pretend_size", "=", "7", "*", "UNITS_PER_WORD", ";", "}", "if", "(", "cum", ">=", "6", ")", "return", ";", "if", "(", "!", "no_rtl", ")", "{", "int", "count", ";", "alias_set_type", "set", "=", "get_varargs_alias_set", "(", ")", ";", "rtx", "tmp", ";", "count", "=", "cfun", "->", "va_list_gpr_size", "/", "UNITS_PER_WORD", ";", "if", "(", "count", ">", "6", "-", "cum", ")", "count", "=", "6", "-", "cum", ";", "gcc_assert", "(", "(", "VA_LIST_MAX_FPR_SIZE", "&", "3", ")", "==", "3", ")", ";", "if", "(", "cfun", "->", "va_list_fpr_size", "&", "1", ")", "{", "tmp", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "(", "cum", "+", "6", ")", "*", "UNITS_PER_WORD", ")", ")", ";", "MEM_NOTRAP_P", "(", "tmp", ")", "=", "1", ";", "set_mem_alias_set", "(", "tmp", ",", "set", ")", ";", "move_block_from_reg", "(", "16", "+", "cum", ",", "tmp", ",", "count", ")", ";", "}", "if", "(", "cfun", "->", "va_list_fpr_size", "&", "2", ")", "{", "tmp", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "cum", "*", "UNITS_PER_WORD", ")", ")", ";", "MEM_NOTRAP_P", "(", "tmp", ")", "=", "1", ";", "set_mem_alias_set", "(", "tmp", ",", "set", ")", ";", "move_block_from_reg", "(", "16", "+", "cum", "+", "TARGET_FPREGS", "*", "32", ",", "tmp", ",", "count", ")", ";", "}", "}", "*", "pretend_size", "=", "12", "*", "UNITS_PER_WORD", ";", "}", "</s>"], "natrual_language": ["Perform", "any", "needed", "actions", "needed", "for", "a", "function", "that", "is", "receiving", "a", "variable", "number", "of", "arguments", "."], "TS_V_token": ["alpha", "6", "1", "7", "6", "6", "6", "3", "3", "1", "6", "1", "16", "2", "1", "16", "32", "12"], "File": "alpha", "Func": "alpha_setup_incoming_varargs", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40799, "Length": 270}
{"ground_truth": ["<s>", "void", "alpha_set_memflags", "(", "rtx", "seq", ",", "rtx", "ref", ")", "{", "rtx_insn", "*", "insn", ";", "if", "(", "!", "MEM_P", "(", "ref", ")", ")", "return", ";", "if", "(", "!", "MEM_VOLATILE_P", "(", "ref", ")", "&&", "!", "MEM_NOTRAP_P", "(", "ref", ")", "&&", "!", "MEM_READONLY_P", "(", "ref", ")", ")", "return", ";", "subrtx_var_iterator", "::", "array_type", "array", ";", "for", "(", "insn", "=", "as_a", "<", "rtx_insn", "*", ">", "(", "seq", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "INSN_P", "(", "insn", ")", ")", "FOR_EACH_SUBRTX_VAR", "(", "iter", ",", "array", ",", "PATTERN", "(", "insn", ")", ",", "NONCONST", ")", "{", "rtx", "x", "=", "*", "iter", ";", "if", "(", "MEM_P", "(", "x", ")", ")", "{", "MEM_VOLATILE_P", "(", "x", ")", "=", "MEM_VOLATILE_P", "(", "ref", ")", ";", "MEM_NOTRAP_P", "(", "x", ")", "=", "MEM_NOTRAP_P", "(", "ref", ")", ";", "MEM_READONLY_P", "(", "x", ")", "=", "MEM_READONLY_P", "(", "ref", ")", ";", "iter", ".", "skip_subrtxes", "(", ")", ";", "}", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>"], "natrual_language": ["Given", "INSN", ",", "which", "is", "an", "INSN", "list", "or", "the", "PATTERN", "of", "a", "single", "insn", "generated", "to", "perform", "a", "memory", "operation", ",", "look", "for", "any", "MEMs", "in", "either", "a", "SET_DEST", "or", "a", "SET_SRC", "and", "copy", "the", "in-struct", ",", "unchanging", ",", "and", "volatile", "flags", "from", "REF", "into", "each", "of", "the", "MEMs", "found", ".", "If", "REF", "is", "not", "a", "MEM", ",", "do", "n't", "do", "anything", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "alpha_set_memflags", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40800, "Length": 152}
{"ground_truth": ["<s>", "void", "alpha_split_atomic_exchange", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "retval", ",", "mem", ",", "val", ",", "scratch", ";", "enum", "memmodel", "model", ";", "machine_mode", "mode", ";", "rtx", "label", ",", "x", ",", "cond", ";", "retval", "=", "operands", "[", "0", "]", ";", "mem", "=", "operands", "[", "1", "]", ";", "val", "=", "operands", "[", "2", "]", ";", "model", "=", "(", "enum", "memmodel", ")", "INTVAL", "(", "operands", "[", "3", "]", ")", ";", "scratch", "=", "operands", "[", "4", "]", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "cond", "=", "gen_lowpart", "(", "DImode", ",", "scratch", ")", ";", "alpha_pre_atomic_barrier", "(", "model", ")", ";", "label", "=", "gen_rtx_LABEL_REF", "(", "DImode", ",", "gen_label_rtx", "(", ")", ")", ";", "emit_label", "(", "XEXP", "(", "label", ",", "0", ")", ")", ";", "emit_insn", "(", "gen_load_locked", "(", "mode", ",", "retval", ",", "mem", ")", ")", ";", "emit_move_insn", "(", "scratch", ",", "val", ")", ";", "emit_insn", "(", "gen_store_conditional", "(", "mode", ",", "cond", ",", "mem", ",", "scratch", ")", ")", ";", "x", "=", "gen_rtx_EQ", "(", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_unlikely_jump", "(", "x", ",", "label", ")", ";", "alpha_post_atomic_barrier", "(", "model", ")", ";", "}", "</s>"], "natrual_language": ["Expand", "an", "atomic", "exchange", "operation", "."], "TS_V_token": ["alpha", "0", "1", "2", "3", "4", "0"], "File": "alpha", "Func": "alpha_split_atomic_exchange", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40801, "Length": 173}
{"ground_truth": ["<s>", "void", "alpha_split_atomic_op", "(", "enum", "rtx_code", "code", ",", "rtx", "mem", ",", "rtx", "val", ",", "rtx", "before", ",", "rtx", "after", ",", "rtx", "scratch", ",", "enum", "memmodel", "model", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "rtx", "label", ",", "x", ",", "cond", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "scratch", ")", ")", ";", "alpha_pre_atomic_barrier", "(", "model", ")", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label", ")", ";", "label", "=", "gen_rtx_LABEL_REF", "(", "DImode", ",", "label", ")", ";", "if", "(", "before", "==", "NULL", ")", "before", "=", "scratch", ";", "emit_insn", "(", "gen_load_locked", "(", "mode", ",", "before", ",", "mem", ")", ")", ";", "if", "(", "code", "==", "NOT", ")", "{", "x", "=", "gen_rtx_AND", "(", "mode", ",", "before", ",", "val", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "val", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_NOT", "(", "mode", ",", "val", ")", ";", "}", "else", "x", "=", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "before", ",", "val", ")", ";", "if", "(", "after", ")", "emit_insn", "(", "gen_rtx_SET", "(", "after", ",", "copy_rtx", "(", "x", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "scratch", ",", "x", ")", ")", ";", "emit_insn", "(", "gen_store_conditional", "(", "mode", ",", "cond", ",", "mem", ",", "scratch", ")", ")", ";", "x", "=", "gen_rtx_EQ", "(", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_unlikely_jump", "(", "x", ",", "label", ")", ";", "alpha_post_atomic_barrier", "(", "model", ")", ";", "}", "</s>"], "natrual_language": ["Expand", "an", "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", ".", "SCRATCH", "is", "a", "scratch", "register", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "alpha_split_atomic_op", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40802, "Length": 216}
{"ground_truth": ["<s>", "void", "alpha_split_compare_and_swap", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "cond", ",", "retval", ",", "mem", ",", "oldval", ",", "newval", ";", "bool", "is_weak", ";", "enum", "memmodel", "mod_s", ",", "mod_f", ";", "machine_mode", "mode", ";", "rtx", "label1", ",", "label2", ",", "x", ";", "cond", "=", "operands", "[", "0", "]", ";", "retval", "=", "operands", "[", "1", "]", ";", "mem", "=", "operands", "[", "2", "]", ";", "oldval", "=", "operands", "[", "3", "]", ";", "newval", "=", "operands", "[", "4", "]", ";", "is_weak", "=", "(", "operands", "[", "5", "]", "!=", "const0_rtx", ")", ";", "mod_s", "=", "memmodel_from_int", "(", "INTVAL", "(", "operands", "[", "6", "]", ")", ")", ";", "mod_f", "=", "memmodel_from_int", "(", "INTVAL", "(", "operands", "[", "7", "]", ")", ")", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "alpha_pre_atomic_barrier", "(", "mod_s", ")", ";", "label1", "=", "NULL_RTX", ";", "if", "(", "!", "is_weak", ")", "{", "label1", "=", "gen_rtx_LABEL_REF", "(", "DImode", ",", "gen_label_rtx", "(", ")", ")", ";", "emit_label", "(", "XEXP", "(", "label1", ",", "0", ")", ")", ";", "}", "label2", "=", "gen_rtx_LABEL_REF", "(", "DImode", ",", "gen_label_rtx", "(", ")", ")", ";", "emit_insn", "(", "gen_load_locked", "(", "mode", ",", "retval", ",", "mem", ")", ")", ";", "x", "=", "gen_lowpart", "(", "DImode", ",", "retval", ")", ";", "if", "(", "oldval", "==", "const0_rtx", ")", "{", "emit_move_insn", "(", "cond", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_NE", "(", "DImode", ",", "x", ",", "const0_rtx", ")", ";", "}", "else", "{", "x", "=", "gen_rtx_EQ", "(", "DImode", ",", "x", ",", "oldval", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "cond", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_EQ", "(", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "}", "emit_unlikely_jump", "(", "x", ",", "label2", ")", ";", "emit_move_insn", "(", "cond", ",", "newval", ")", ";", "emit_insn", "(", "gen_store_conditional", "(", "mode", ",", "cond", ",", "mem", ",", "gen_lowpart", "(", "mode", ",", "cond", ")", ")", ")", ";", "if", "(", "!", "is_weak", ")", "{", "x", "=", "gen_rtx_EQ", "(", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_unlikely_jump", "(", "x", ",", "label1", ")", ";", "}", "if", "(", "!", "is_mm_relaxed", "(", "mod_f", ")", ")", "emit_label", "(", "XEXP", "(", "label2", ",", "0", ")", ")", ";", "alpha_post_atomic_barrier", "(", "mod_s", ")", ";", "if", "(", "is_mm_relaxed", "(", "mod_f", ")", ")", "emit_label", "(", "XEXP", "(", "label2", ",", "0", ")", ")", ";", "}", "</s>"], "natrual_language": ["Expand", "a", "compare", "and", "swap", "operation", "."], "TS_V_token": ["alpha", "0", "1", "2", "3", "4", "5", "6", "7", "0", "0", "0"], "File": "alpha", "Func": "alpha_split_compare_and_swap", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40803, "Length": 347}
{"ground_truth": ["<s>", "static", "bool", "alpha_split_complex_arg", "(", "const_tree", "type", ")", "{", "return", "TYPE_MODE", "(", "type", ")", "!=", "TCmode", ";", "}", "</s>"], "natrual_language": ["TCmode", "complex", "values", "are", "passed", "by", "invisible", "reference", ".", "We", "should", "not", "split", "these", "values", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "alpha_split_complex_arg", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40804, "Length": 17}
{"ground_truth": ["<s>", "int", "alpha_split_conditional_move", "(", "enum", "rtx_code", "code", ",", "rtx", "dest", ",", "rtx", "cond", ",", "rtx", "t_rtx", ",", "rtx", "f_rtx", ")", "{", "HOST_WIDE_INT", "t", ",", "f", ",", "diff", ";", "machine_mode", "mode", ";", "rtx", "target", ",", "subtarget", ",", "tmp", ";", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "t", "=", "INTVAL", "(", "t_rtx", ")", ";", "f", "=", "INTVAL", "(", "f_rtx", ")", ";", "diff", "=", "t", "-", "f", ";", "if", "(", "(", "(", "code", "==", "NE", "||", "code", "==", "EQ", ")", "&&", "diff", "<", "0", ")", "||", "(", "code", "==", "GE", "||", "code", "==", "GT", ")", ")", "{", "code", "=", "reverse_condition", "(", "code", ")", ";", "std", "::", "swap", "(", "t", ",", "f", ")", ";", "diff", "=", "-", "diff", ";", "}", "subtarget", "=", "target", "=", "dest", ";", "if", "(", "mode", "!=", "DImode", ")", "{", "target", "=", "gen_lowpart", "(", "DImode", ",", "dest", ")", ";", "if", "(", "can_create_pseudo_p", "(", ")", ")", "subtarget", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "else", "subtarget", "=", "target", ";", "}", "if", "(", "f", "==", "0", "&&", "exact_log2", "(", "diff", ")", ">", "0", "&&", "(", "diff", "<=", "8", "||", "alpha_tune", "==", "PROCESSOR_EV6", ")", ")", "{", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "copy_rtx", "(", "subtarget", ")", ",", "tmp", ")", ")", ";", "tmp", "=", "gen_rtx_ASHIFT", "(", "DImode", ",", "copy_rtx", "(", "subtarget", ")", ",", "GEN_INT", "(", "exact_log2", "(", "t", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "tmp", ")", ")", ";", "}", "else", "if", "(", "f", "==", "0", "&&", "t", "==", "-", "1", ")", "{", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "copy_rtx", "(", "subtarget", ")", ",", "tmp", ")", ")", ";", "emit_insn", "(", "gen_negdi2", "(", "target", ",", "copy_rtx", "(", "subtarget", ")", ")", ")", ";", "}", "else", "if", "(", "diff", "==", "1", "||", "diff", "==", "4", "||", "diff", "==", "8", ")", "{", "rtx", "add_op", ";", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "copy_rtx", "(", "subtarget", ")", ",", "tmp", ")", ")", ";", "if", "(", "diff", "==", "1", ")", "emit_insn", "(", "gen_adddi3", "(", "target", ",", "copy_rtx", "(", "subtarget", ")", ",", "GEN_INT", "(", "f", ")", ")", ")", ";", "else", "{", "add_op", "=", "GEN_INT", "(", "f", ")", ";", "if", "(", "sext_add_operand", "(", "add_op", ",", "mode", ")", ")", "{", "tmp", "=", "gen_rtx_ASHIFT", "(", "DImode", ",", "copy_rtx", "(", "subtarget", ")", ",", "GEN_INT", "(", "exact_log2", "(", "diff", ")", ")", ")", ";", "tmp", "=", "gen_rtx_PLUS", "(", "DImode", ",", "tmp", ",", "add_op", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "tmp", ")", ")", ";", "}", "else", "return", "0", ";", "}", "}", "else", "return", "0", ";", "return", "1", ";", "}", "</s>"], "natrual_language": ["Simplify", "a", "conditional", "move", "of", "two", "constants", "into", "a", "setcc", "with", "arithmetic", ".", "This", "is", "done", "with", "a", "splitter", "since", "combine", "would", "just", "undo", "the", "work", "if", "done", "during", "code", "generation", ".", "It", "also", "catches", "cases", "we", "would", "n't", "have", "before", "cse", "."], "TS_V_token": ["alpha", "0", "0", "0", "8", "0", "1", "1", "4", "8", "1", "0", "0", "1"], "File": "alpha", "Func": "alpha_split_conditional_move", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40805, "Length": 434}
{"ground_truth": ["<s>", "bool", "alpha_split_const_mov", "(", "machine_mode", "mode", ",", "rtx", "*", "operands", ")", "{", "HOST_WIDE_INT", "i0", ";", "rtx", "temp", "=", "NULL_RTX", ";", "i0", "=", "alpha_extract_integer", "(", "operands", "[", "1", "]", ")", ";", "temp", "=", "alpha_emit_set_const", "(", "operands", "[", "0", "]", ",", "mode", ",", "i0", ",", "3", ",", "false", ")", ";", "if", "(", "!", "temp", "&&", "TARGET_BUILD_CONSTANTS", ")", "temp", "=", "alpha_emit_set_long_const", "(", "operands", "[", "0", "]", ",", "i0", ")", ";", "if", "(", "temp", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "operands", "[", "0", "]", ",", "temp", ")", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "temp", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Operand", "1", "is", "known", "to", "be", "a", "constant", ",", "and", "should", "require", "more", "than", "one", "instruction", "to", "load", ".", "Emit", "that", "multi-part", "load", "."], "TS_V_token": ["alpha", "1", "0", "3", "0", "0", "0"], "File": "alpha", "Func": "alpha_split_const_mov", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40806, "Length": 102}
{"ground_truth": ["<s>", "void", "alpha_split_tfmode_frobsign", "(", "rtx", "operands", "[", "3", "]", ",", "rtx", "(", "*", "operation", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ")", "{", "rtx", "high_bit", "=", "operands", "[", "2", "]", ";", "rtx", "scratch", ";", "int", "move", ";", "alpha_split_tmode_pair", "(", "operands", ",", "TFmode", ",", "false", ")", ";", "move", "=", "1", ";", "if", "(", "rtx_equal_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ")", ")", "move", "=", "0", ";", "else", "if", "(", "rtx_equal_p", "(", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ")", "{", "if", "(", "rtx_equal_p", "(", "operands", "[", "0", "]", ",", "high_bit", ")", ")", "move", "=", "2", ";", "else", "move", "=", "-", "1", ";", "}", "if", "(", "move", "<", "0", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ")", ";", "scratch", "=", "operands", "[", "move", "<", "2", "?", "1", ":", "3", "]", ";", "emit_insn", "(", "(", "*", "operation", ")", "(", "scratch", ",", "high_bit", ",", "operands", "[", "3", "]", ")", ")", ";", "if", "(", "move", ">", "0", ")", "{", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ")", ";", "if", "(", "move", ">", "1", ")", "emit_move_insn", "(", "operands", "[", "1", "]", ",", "scratch", ")", ";", "}", "}", "</s>"], "natrual_language": ["Implement", "negtf2", "or", "abstf2", ".", "Op0", "is", "destination", ",", "op1", "is", "source", ",", "op2", "is", "a", "register", "containing", "the", "sign", "bit", ",", "operation", "is", "the", "logical", "operation", "to", "be", "performed", "."], "TS_V_token": ["alpha", "3", "2", "1", "0", "2", "0", "1", "2", "0", "2", "1", "0", "0", "2", "2", "1", "3", "3", "0", "0", "2", "1", "1"], "File": "alpha", "Func": "alpha_split_tfmode_frobsign", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40807, "Length": 197}
{"ground_truth": ["<s>", "void", "alpha_split_tmode_pair", "(", "rtx", "operands", "[", "4", "]", ",", "machine_mode", "mode", ",", "bool", "fixup_overlap", ")", "{", "switch", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", ")", "{", "case", "REG", ":", "operands", "[", "3", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "operands", "[", "1", "]", ")", "+", "1", ")", ";", "operands", "[", "2", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "operands", "[", "1", "]", ")", ")", ";", "break", ";", "case", "MEM", ":", "operands", "[", "3", "]", "=", "adjust_address", "(", "operands", "[", "1", "]", ",", "DImode", ",", "8", ")", ";", "operands", "[", "2", "]", "=", "adjust_address", "(", "operands", "[", "1", "]", ",", "DImode", ",", "0", ")", ";", "break", ";", "CASE_CONST_SCALAR_INT", ":", "case", "CONST_DOUBLE", ":", "gcc_assert", "(", "operands", "[", "1", "]", "==", "CONST0_RTX", "(", "mode", ")", ")", ";", "operands", "[", "2", "]", "=", "operands", "[", "3", "]", "=", "const0_rtx", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", ")", "{", "case", "REG", ":", "operands", "[", "1", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "operands", "[", "0", "]", ")", "+", "1", ")", ";", "operands", "[", "0", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "operands", "[", "0", "]", ")", ")", ";", "break", ";", "case", "MEM", ":", "operands", "[", "1", "]", "=", "adjust_address", "(", "operands", "[", "0", "]", ",", "DImode", ",", "8", ")", ";", "operands", "[", "0", "]", "=", "adjust_address", "(", "operands", "[", "0", "]", ",", "DImode", ",", "0", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "fixup_overlap", "&&", "reg_overlap_mentioned_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "3", "]", ")", ")", "{", "std", "::", "swap", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "std", "::", "swap", "(", "operands", "[", "2", "]", ",", "operands", "[", "3", "]", ")", ";", "}", "}", "</s>"], "natrual_language": ["Split", "a", "TImode", "or", "TFmode", "move", "from", "OP", "[", "1", "]", "to", "OP", "[", "0", "]", "into", "a", "pair", "of", "DImode", "moves", "from", "OP", "[", "2,3", "]", "to", "OP", "[", "0,1", "]", ".", "If", "FIXUP_OVERLAP", "is", "true", ",", "guarantee", "that", "the", "sequence", "set", "(", "OP", "[", "0", "]", "OP", "[", "2", "]", ")", "set", "(", "OP", "[", "1", "]", "OP", "[", "3", "]", ")", "is", "valid", ".", "Naturally", ",", "output", "operand", "ordering", "is", "little-endian", ".", "This", "is", "used", "by", "*", "movtf_internal", "and", "*", "movti_internal", "."], "TS_V_token": ["alpha", "4", "1", "3", "1", "1", "2", "1", "3", "1", "8", "2", "1", "0", "1", "2", "3", "0", "1", "0", "1", "0", "0", "1", "0", "8", "0", "0", "0", "0", "3", "0", "1", "2", "3"], "File": "alpha", "Func": "alpha_split_tmode_pair", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40808, "Length": 298}
{"ground_truth": ["<s>", "static", "void", "alpha_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "chain_value", ")", "{", "rtx", "fnaddr", ",", "mem", ",", "word1", ",", "word2", ";", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "fnaddr", "=", "convert_memory_address", "(", "Pmode", ",", "fnaddr", ")", ";", "chain_value", "=", "convert_memory_address", "(", "Pmode", ",", "chain_value", ")", ";", "if", "(", "TARGET_ABI_OPEN_VMS", ")", "{", "const", "char", "*", "fnname", ";", "char", "*", "trname", ";", "fnname", "=", "XSTR", "(", "fnaddr", ",", "0", ")", ";", "trname", "=", "(", "char", "*", ")", "alloca", "(", "strlen", "(", "fnname", ")", "+", "5", ")", ";", "strcpy", "(", "trname", ",", "fnname", ")", ";", "strcat", "(", "trname", ",", "\"..tr\"", ")", ";", "fnname", "=", "ggc_alloc_string", "(", "trname", ",", "strlen", "(", "trname", ")", "+", "1", ")", ";", "word2", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "fnname", ")", ";", "word1", "=", "force_reg", "(", "DImode", ",", "gen_const_mem", "(", "DImode", ",", "fnaddr", ")", ")", ";", "word1", "=", "expand_and", "(", "DImode", ",", "word1", ",", "GEN_INT", "(", "HOST_WIDE_INT_C", "(", "0xffff0fff0000fff0", ")", ")", ",", "NULL", ")", ";", "}", "else", "{", "word1", "=", "GEN_INT", "(", "HOST_WIDE_INT_C", "(", "0xa77b0010a43b0018", ")", ")", ";", "word2", "=", "GEN_INT", "(", "HOST_WIDE_INT_C", "(", "0x47ff041f6bfb0000", ")", ")", ";", "}", "mem", "=", "adjust_address", "(", "m_tramp", ",", "DImode", ",", "0", ")", ";", "emit_move_insn", "(", "mem", ",", "word1", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "DImode", ",", "8", ")", ";", "emit_move_insn", "(", "mem", ",", "word2", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "16", ")", ";", "emit_move_insn", "(", "mem", ",", "fnaddr", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "Pmode", ",", "24", ")", ";", "emit_move_insn", "(", "mem", ",", "chain_value", ")", ";", "if", "(", "TARGET_ABI_OSF", ")", "{", "emit_insn", "(", "gen_imb", "(", ")", ")", ";", "emit_library_call", "(", "init_one_libfunc", "(", "\"__enable_execute_stack\"", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "XEXP", "(", "m_tramp", ",", "0", ")", ",", "Pmode", ")", ";", "}", "}", "</s>"], "natrual_language": ["Emit", "RTL", "insns", "to", "initialize", "the", "variable", "parts", "of", "a", "trampoline", "at", "M_TRAMP", ".", "FNDECL", "is", "target", "function", "'s", "decl", ".", "CHAIN_VALUE", "is", "an", "rtx", "for", "the", "static", "chain", "value", "for", "the", "function", "."], "TS_V_token": ["alpha", "0", "0", "5", "\"..tr\"", "1", "0xffff0fff0000fff0", "0xa77b0010a43b0018", "0x47ff041f6bfb0000", "0", "8", "16", "24", "\"__enable_execute_stack\"", "0"], "File": "alpha", "Func": "alpha_trampoline_init", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40809, "Length": 293}
{"ground_truth": ["<s>", "rtx", "alpha_use_linkage", "(", "rtx", "func", "ATTRIBUTE_UNUSED", ",", "bool", "lflag", "ATTRIBUTE_UNUSED", ",", "bool", "rflag", "ATTRIBUTE_UNUSED", ")", "{", "return", "NULL_RTX", ";", "}", "</s>"], "natrual_language": ["Return", "a", "SYMBOL_REF", "representing", "the", "reference", "to", "the", ".linkage", "entry", "of", "function", "FUNC", "built", "for", "calls", "made", "from", "CFUNDECL", ".", "LFLAG", "is", "1", "if", "this", "is", "the", "reference", "to", "the", "linkage", "pointer", "value", ",", "0", "if", "this", "is", "the", "reference", "to", "the", "function", "entry", "value", ".", "RFLAG", "is", "1", "if", "this", "a", "reduced", "reference", "(", "code", "address", "only", ")", ",", "0", "if", "this", "is", "a", "full", "reference", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "alpha_use_linkage", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40810, "Length": 20}
{"ground_truth": ["<s>", "static", "bool", "alpha_vector_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "return", "mode", "==", "V8QImode", "||", "mode", "==", "V4HImode", "||", "mode", "==", "V2SImode", ";", "}", "</s>"], "natrual_language": ["Alpha", "implements", "a", "couple", "of", "integer", "vector", "mode", "operations", "when", "TARGET_MAX", "is", "enabled", ".", "We", "do", "not", "check", "TARGET_MAX", "here", ",", "however", ",", "which", "allows", "the", "vectorizer", "to", "operate", "on", "e.g", ".", "move", "instructions", ",", "or", "when", "expand_vector_operations", "can", "do", "something", "useful", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "alpha_vector_mode_supported_p", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40811, "Length": 22}
{"ground_truth": ["<s>", "static", "bool", "alpha_vms_can_eliminate", "(", "const", "int", "from", "ATTRIBUTE_UNUSED", ",", "const", "int", "to", ")", "{", "switch", "(", "alpha_procedure_type", ")", "{", "case", "PT_NULL", ":", "return", "to", "==", "STACK_POINTER_REGNUM", ";", "case", "PT_REGISTER", ":", "case", "PT_STACK", ":", "return", "(", "to", "!=", "STACK_POINTER_REGNUM", "||", "vms_unwind_regno", "!=", "HARD_FRAME_POINTER_REGNUM", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>"], "natrual_language": ["Worker", "function", "for", "TARGET_CAN_ELIMINATE", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "alpha_vms_can_eliminate", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40812, "Length": 50}
{"ground_truth": ["<s>", "HOST_WIDE_INT", "alpha_vms_initial_elimination_offset", "(", "unsigned", "int", "from", ",", "unsigned", "int", "to", ")", "{", "HOST_WIDE_INT", "sa_size", "=", "cfun", "->", "machine", "->", "sa_size", ";", "if", "(", "alpha_procedure_type", "==", "PT_NULL", ")", "return", "0", ";", "{", "HOST_WIDE_INT", "offset", ";", "HOST_WIDE_INT", "pv_save_size", "=", "alpha_procedure_type", "==", "PT_STACK", "?", "8", ":", "0", ";", "switch", "(", "from", ")", "{", "case", "FRAME_POINTER_REGNUM", ":", "offset", "=", "ALPHA_ROUND", "(", "sa_size", "+", "pv_save_size", ")", ";", "break", ";", "case", "ARG_POINTER_REGNUM", ":", "offset", "=", "(", "ALPHA_ROUND", "(", "sa_size", "+", "pv_save_size", "+", "get_frame_size", "(", ")", "+", "crtl", "->", "args", ".", "pretend_args_size", ")", "-", "crtl", "->", "args", ".", "pretend_args_size", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "to", "==", "STACK_POINTER_REGNUM", ")", "offset", "+=", "ALPHA_ROUND", "(", "crtl", "->", "outgoing_args_size", ")", ";", "return", "offset", ";", "}", "}", "</s>"], "natrual_language": ["FROM", "is", "to", "be", "eliminated", "for", "TO", ".", "Return", "the", "offset", "so", "that", "TO+offset", "designates", "the", "same", "location", "as", "FROM", "."], "TS_V_token": ["alpha", "0", "8", "0"], "File": "alpha", "Func": "alpha_vms_initial_elimination_offset", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40813, "Length": 123}
{"ground_truth": ["<s>", "static", "bool", "decl_has_samegp", "(", "const_tree", "decl", ")", "{", "if", "(", "!", "(", "*", "targetm", ".", "binds_local_p", ")", "(", "decl", ")", ")", "return", "false", ";", "if", "(", "TARGET_EXPLICIT_RELOCS", "&&", "TARGET_SMALL_DATA", ")", "return", "true", ";", "return", "!", "TREE_PUBLIC", "(", "decl", ")", "||", "!", "DECL_EXTERNAL", "(", "decl", ")", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "the", "function", "DECL", "will", "share", "the", "same", "GP", "as", "any", "function", "in", "the", "current", "unit", "of", "translation", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "decl_has_samegp", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40814, "Length": 47}
{"ground_truth": ["<s>", "bool", "direct_return", "(", "void", ")", "{", "return", "(", "TARGET_ABI_OSF", "&&", "reload_completed", "&&", "cfun", "->", "machine", "->", "frame_size", "==", "0", ")", ";", "}", "</s>"], "natrual_language": ["Return", "non-zero", "if", "this", "function", "is", "known", "to", "have", "a", "null", "epilogue", "."], "TS_V_token": ["alpha", "0"], "File": "alpha", "Func": "direct_return", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40815, "Length": 22}
{"ground_truth": ["<s>", "static", "void", "emit_frame_store_1", "(", "rtx", "value", ",", "rtx", "base_reg", ",", "HOST_WIDE_INT", "frame_bias", ",", "HOST_WIDE_INT", "base_ofs", ",", "rtx", "frame_reg", ")", "{", "rtx", "addr", ",", "mem", ";", "rtx_insn", "*", "insn", ";", "addr", "=", "plus_constant", "(", "Pmode", ",", "base_reg", ",", "base_ofs", ")", ";", "mem", "=", "gen_frame_mem", "(", "DImode", ",", "addr", ")", ";", "insn", "=", "emit_move_insn", "(", "mem", ",", "value", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "if", "(", "frame_bias", "||", "value", "!=", "frame_reg", ")", "{", "if", "(", "frame_bias", ")", "{", "addr", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "frame_bias", "+", "base_ofs", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "DImode", ",", "addr", ")", ";", "}", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "mem", ",", "frame_reg", ")", ")", ";", "}", "}", "</s>"], "natrual_language": ["Generates", "a", "store", "with", "the", "proper", "unwind", "info", "attached", ".", "VALUE", "is", "stored", "at", "BASE_REG+BASE_OFS", ".", "If", "FRAME_BIAS", "is", "nonzero", ",", "then", "BASE_REG", "contains", "SP+FRAME_BIAS", ",", "and", "that", "is", "the", "unwind", "info", "that", "should", "be", "generated", ".", "If", "FRAME_REG", "!", "=", "VALUE", ",", "then", "VALUE", "is", "being", "stored", "on", "behalf", "of", "FRAME_REG", ",", "and", "FRAME_REG", "should", "be", "present", "in", "the", "unwind", "."], "TS_V_token": ["alpha", "1"], "File": "alpha", "Func": "emit_frame_store_1", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40816, "Length": 118}
{"ground_truth": ["<s>", "static", "rtx", "emit_insxl", "(", "machine_mode", "mode", ",", "rtx", "op1", ",", "rtx", "op2", ")", "{", "rtx", "ret", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "rtx", "(", "*", "fn", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "fn", "=", "gen_insbl", ";", "break", ";", "case", "E_HImode", ":", "fn", "=", "gen_inswl", ";", "break", ";", "case", "E_SImode", ":", "fn", "=", "gen_insll", ";", "break", ";", "case", "E_DImode", ":", "fn", "=", "gen_insql", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "op1", "=", "force_reg", "(", "mode", ",", "op1", ")", ";", "emit_insn", "(", "fn", "(", "ret", ",", "op1", ",", "op2", ")", ")", ";", "return", "ret", ";", "}", "</s>"], "natrual_language": ["A", "subroutine", "of", "the", "atomic", "operation", "splitters", ".", "Emit", "an", "insxl", "instruction", "in", "MODE", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "emit_insxl", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40817, "Length": 108}
{"ground_truth": ["<s>", "static", "void", "emit_unlikely_jump", "(", "rtx", "cond", ",", "rtx", "label", ")", "{", "rtx", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "cond", ",", "label", ",", "pc_rtx", ")", ";", "rtx_insn", "*", "insn", "=", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "x", ")", ")", ";", "add_reg_br_prob_note", "(", "insn", ",", "profile_probability", "::", "very_unlikely", "(", ")", ")", ";", "}", "</s>"], "natrual_language": ["Mark", "the", "previous", "jump", "instruction", "as", "unlikely", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "emit_unlikely_jump", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40818, "Length": 51}
{"ground_truth": ["<s>", "virtual", "unsigned", "int", "execute", "(", "function", "*", ")", "{", "return", "rest_of_align_insns", "(", ")", ";", "}", "</s>"], "natrual_language": ["Main", "entry", "point", "for", "this", "pass", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "execute", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40819, "Length": 15}
{"ground_truth": ["<s>", "void", "get_aligned_mem", "(", "rtx", "ref", ",", "rtx", "*", "paligned_mem", ",", "rtx", "*", "pbitnum", ")", "{", "rtx", "base", ";", "HOST_WIDE_INT", "disp", ",", "offset", ";", "gcc_assert", "(", "MEM_P", "(", "ref", ")", ")", ";", "if", "(", "reload_in_progress", ")", "{", "base", "=", "find_replacement", "(", "&", "XEXP", "(", "ref", ",", "0", ")", ")", ";", "gcc_assert", "(", "memory_address_p", "(", "GET_MODE", "(", "ref", ")", ",", "base", ")", ")", ";", "}", "else", "base", "=", "XEXP", "(", "ref", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", ")", "disp", "=", "INTVAL", "(", "XEXP", "(", "base", ",", "1", ")", ")", ",", "base", "=", "XEXP", "(", "base", ",", "0", ")", ";", "else", "disp", "=", "0", ";", "if", "(", "MEM_ALIGN", "(", "ref", ")", ">=", "32", ")", "offset", "=", "0", ";", "else", "offset", "=", "disp", "&", "3", ";", "gcc_assert", "(", "offset", "+", "GET_MODE_SIZE", "(", "GET_MODE", "(", "ref", ")", ")", "<=", "GET_MODE_SIZE", "(", "SImode", ")", ")", ";", "*", "paligned_mem", "=", "widen_memory_access", "(", "ref", ",", "SImode", ",", "-", "offset", ")", ";", "offset", "*=", "BITS_PER_UNIT", ";", "*", "pbitnum", "=", "GEN_INT", "(", "offset", ")", ";", "}", "</s>"], "natrual_language": ["REF", "is", "an", "alignable", "memory", "location", ".", "Place", "an", "aligned", "SImode", "reference", "into", "*", "PALIGNED_MEM", "and", "the", "number", "of", "bits", "to", "shift", "into", "*", "PBITNUM", ".", "SCRATCH", "is", "a", "free", "register", "for", "use", "in", "reloading", "out", "of", "range", "stack", "slots", "."], "TS_V_token": ["alpha", "0", "0", "1", "0", "0", "32", "0", "3"], "File": "alpha", "Func": "get_aligned_mem", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40820, "Length": 172}
{"ground_truth": ["<s>", "static", "const", "char", "*", "get_round_mode_suffix", "(", "void", ")", "{", "enum", "attr_round_suffix", "s", "=", "get_attr_round_suffix", "(", "current_output_insn", ")", ";", "switch", "(", "s", ")", "{", "case", "ROUND_SUFFIX_NONE", ":", "return", "NULL", ";", "case", "ROUND_SUFFIX_NORMAL", ":", "switch", "(", "alpha_fprm", ")", "{", "case", "ALPHA_FPRM_NORM", ":", "return", "NULL", ";", "case", "ALPHA_FPRM_MINF", ":", "return", "\"m\"", ";", "case", "ALPHA_FPRM_CHOP", ":", "return", "\"c\"", ";", "case", "ALPHA_FPRM_DYN", ":", "return", "\"d\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "case", "ROUND_SUFFIX_C", ":", "return", "\"c\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>"], "natrual_language": ["Return", "the", "rounding", "mode", "suffix", "applicable", "to", "the", "current", "instruction", ",", "or", "NULL", "."], "TS_V_token": ["alpha", "\"m\"", "\"c\"", "\"d\"", "\"c\""], "File": "alpha", "Func": "get_round_mode_suffix", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40821, "Length": 88}
{"ground_truth": ["<s>", "static", "const", "char", "*", "get_trap_mode_suffix", "(", "void", ")", "{", "enum", "attr_trap_suffix", "s", "=", "get_attr_trap_suffix", "(", "current_output_insn", ")", ";", "switch", "(", "s", ")", "{", "case", "TRAP_SUFFIX_NONE", ":", "return", "NULL", ";", "case", "TRAP_SUFFIX_SU", ":", "if", "(", "alpha_fptm", ">=", "ALPHA_FPTM_SU", ")", "return", "\"su\"", ";", "return", "NULL", ";", "case", "TRAP_SUFFIX_SUI", ":", "if", "(", "alpha_fptm", ">=", "ALPHA_FPTM_SUI", ")", "return", "\"sui\"", ";", "return", "NULL", ";", "case", "TRAP_SUFFIX_V_SV", ":", "switch", "(", "alpha_fptm", ")", "{", "case", "ALPHA_FPTM_N", ":", "return", "NULL", ";", "case", "ALPHA_FPTM_U", ":", "return", "\"v\"", ";", "case", "ALPHA_FPTM_SU", ":", "case", "ALPHA_FPTM_SUI", ":", "return", "\"sv\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "TRAP_SUFFIX_V_SV_SVI", ":", "switch", "(", "alpha_fptm", ")", "{", "case", "ALPHA_FPTM_N", ":", "return", "NULL", ";", "case", "ALPHA_FPTM_U", ":", "return", "\"v\"", ";", "case", "ALPHA_FPTM_SU", ":", "return", "\"sv\"", ";", "case", "ALPHA_FPTM_SUI", ":", "return", "\"svi\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "case", "TRAP_SUFFIX_U_SU_SUI", ":", "switch", "(", "alpha_fptm", ")", "{", "case", "ALPHA_FPTM_N", ":", "return", "NULL", ";", "case", "ALPHA_FPTM_U", ":", "return", "\"u\"", ";", "case", "ALPHA_FPTM_SU", ":", "return", "\"su\"", ";", "case", "ALPHA_FPTM_SUI", ":", "return", "\"sui\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>"], "natrual_language": ["Return", "the", "trap", "mode", "suffix", "applicable", "to", "the", "current", "instruction", ",", "or", "NULL", "."], "TS_V_token": ["alpha", "\"su\"", "\"sui\"", "\"v\"", "\"sv\"", "\"v\"", "\"sv\"", "\"svi\"", "\"u\"", "\"su\"", "\"sui\""], "File": "alpha", "Func": "get_trap_mode_suffix", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40822, "Length": 189}
{"ground_truth": ["<s>", "rtx", "get_unaligned_address", "(", "rtx", "ref", ")", "{", "rtx", "base", ";", "HOST_WIDE_INT", "offset", "=", "0", ";", "gcc_assert", "(", "MEM_P", "(", "ref", ")", ")", ";", "if", "(", "reload_in_progress", ")", "{", "base", "=", "find_replacement", "(", "&", "XEXP", "(", "ref", ",", "0", ")", ")", ";", "gcc_assert", "(", "memory_address_p", "(", "GET_MODE", "(", "ref", ")", ",", "base", ")", ")", ";", "}", "else", "base", "=", "XEXP", "(", "ref", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", ")", "offset", "+=", "INTVAL", "(", "XEXP", "(", "base", ",", "1", ")", ")", ",", "base", "=", "XEXP", "(", "base", ",", "0", ")", ";", "return", "plus_constant", "(", "Pmode", ",", "base", ",", "offset", ")", ";", "}", "</s>"], "natrual_language": ["Similar", ",", "but", "just", "get", "the", "address", ".", "Handle", "the", "two", "reload", "cases", ".", "Add", "EXTRA_OFFSET", "to", "the", "address", "we", "return", "."], "TS_V_token": ["alpha", "0", "0", "0", "1", "0"], "File": "alpha", "Func": "get_unaligned_address", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40823, "Length": 106}
{"ground_truth": ["<s>", "rtx", "get_unaligned_offset", "(", "rtx", "addr", ",", "HOST_WIDE_INT", "ofs", ")", "{", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", ")", "{", "ofs", "+=", "INTVAL", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "}", "return", "expand_simple_binop", "(", "Pmode", ",", "PLUS", ",", "addr", ",", "GEN_INT", "(", "ofs", "&", "7", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_LIB_WIDEN", ")", ";", "}", "</s>"], "natrual_language": ["Compute", "a", "value", "X", ",", "such", "that", "X", "&", "7", "==", "(", "ADDR", "+", "OFS", ")", "&", "7", ".", "X", "is", "always", "returned", "in", "a", "register", "."], "TS_V_token": ["alpha", "1", "0", "7", "1"], "File": "alpha", "Func": "get_unaligned_offset", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40824, "Length": 66}
{"ground_truth": ["<s>", "rtx", "resolve_reload_operand", "(", "rtx", "op", ")", "{", "if", "(", "reload_in_progress", ")", "{", "rtx", "tmp", "=", "op", ";", "if", "(", "SUBREG_P", "(", "tmp", ")", ")", "tmp", "=", "SUBREG_REG", "(", "tmp", ")", ";", "if", "(", "REG_P", "(", "tmp", ")", "&&", "REGNO", "(", "tmp", ")", ">=", "FIRST_PSEUDO_REGISTER", ")", "{", "op", "=", "reg_equiv_memory_loc", "(", "REGNO", "(", "tmp", ")", ")", ";", "if", "(", "op", "==", "0", ")", "return", "0", ";", "}", "}", "return", "op", ";", "}", "</s>"], "natrual_language": ["Used", "by", "aligned_memory_operand", "and", "unaligned_memory_operand", "to", "resolve", "what", "reload", "is", "going", "to", "do", "with", "OP", "if", "it", "'s", "a", "register", "."], "TS_V_token": ["alpha", "0", "0"], "File": "alpha", "Func": "resolve_reload_operand", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40825, "Length": 71}
{"ground_truth": ["<s>", "static", "rtx_insn", "*", "set_frame_related_p", "(", "void", ")", "{", "rtx_insn", "*", "seq", "=", "get_insns", "(", ")", ";", "rtx_insn", "*", "insn", ";", "end_sequence", "(", ")", ";", "if", "(", "!", "seq", ")", "return", "NULL", ";", "if", "(", "INSN_P", "(", "seq", ")", ")", "{", "insn", "=", "seq", ";", "while", "(", "insn", "!=", "NULL_RTX", ")", "{", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "}", "seq", "=", "emit_insn", "(", "seq", ")", ";", "}", "else", "{", "seq", "=", "emit_insn", "(", "seq", ")", ";", "RTX_FRAME_RELATED_P", "(", "seq", ")", "=", "1", ";", "}", "return", "seq", ";", "}", "</s>"], "natrual_language": ["Helper", "function", "to", "set", "RTX_FRAME_RELATED_P", "on", "instructions", ",", "including", "sequences", "."], "TS_V_token": ["alpha", "1", "1"], "File": "alpha", "Func": "set_frame_related_p", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40826, "Length": 95}
{"ground_truth": ["<s>", "int", "tls_symbolic_operand_1", "(", "rtx", "op", ",", "int", "size", ",", "int", "unspec", ")", "{", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "UNSPEC", "||", "XINT", "(", "op", ",", "1", ")", "!=", "unspec", ")", "return", "0", ";", "op", "=", "XVECEXP", "(", "op", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "SYMBOL_REF", ")", "return", "0", ";", "switch", "(", "SYMBOL_REF_TLS_MODEL", "(", "op", ")", ")", "{", "case", "TLS_MODEL_LOCAL_DYNAMIC", ":", "return", "unspec", "==", "UNSPEC_DTPREL", "&&", "size", "==", "alpha_tls_size", ";", "case", "TLS_MODEL_INITIAL_EXEC", ":", "return", "unspec", "==", "UNSPEC_TPREL", "&&", "size", "==", "64", ";", "case", "TLS_MODEL_LOCAL_EXEC", ":", "return", "unspec", "==", "UNSPEC_TPREL", "&&", "size", "==", "alpha_tls_size", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Return", "true", "if", "OP", "is", "valid", "for", "a", "particular", "TLS", "relocation", ".", "We", "are", "already", "guaranteed", "that", "OP", "is", "a", "CONST", "."], "TS_V_token": ["alpha", "0", "1", "0", "0", "0", "0", "64"], "File": "alpha", "Func": "tls_symbolic_operand_1", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40827, "Length": 118}
{"ground_truth": ["<s>", "static", "enum", "tls_model", "tls_symbolic_operand_type", "(", "rtx", "symbol", ")", "{", "enum", "tls_model", "model", ";", "if", "(", "GET_CODE", "(", "symbol", ")", "!=", "SYMBOL_REF", ")", "return", "TLS_MODEL_NONE", ";", "model", "=", "SYMBOL_REF_TLS_MODEL", "(", "symbol", ")", ";", "if", "(", "model", "==", "TLS_MODEL_LOCAL_EXEC", "&&", "alpha_tls_size", "==", "64", ")", "model", "=", "TLS_MODEL_INITIAL_EXEC", ";", "return", "model", ";", "}", "</s>"], "natrual_language": ["Return", "the", "TLS", "model", "to", "use", "for", "SYMBOL", "."], "TS_V_token": ["alpha", "64"], "File": "alpha", "Func": "tls_symbolic_operand_type", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40828, "Length": 50}
{"ground_truth": ["<s>", "static", "gimple", "*", "va_list_skip_additions", "(", "tree", "lhs", ")", "{", "gimple", "*", "stmt", ";", "for", "(", ";", ";", ")", "{", "enum", "tree_code", "code", ";", "stmt", "=", "SSA_NAME_DEF_STMT", "(", "lhs", ")", ";", "if", "(", "gimple_code", "(", "stmt", ")", "==", "GIMPLE_PHI", ")", "return", "stmt", ";", "if", "(", "!", "is_gimple_assign", "(", "stmt", ")", "||", "gimple_assign_lhs", "(", "stmt", ")", "!=", "lhs", ")", "return", "NULL", ";", "if", "(", "TREE_CODE", "(", "gimple_assign_rhs1", "(", "stmt", ")", ")", "!=", "SSA_NAME", ")", "return", "stmt", ";", "code", "=", "gimple_assign_rhs_code", "(", "stmt", ")", ";", "if", "(", "!", "CONVERT_EXPR_CODE_P", "(", "code", ")", "&&", "(", "(", "code", "!=", "PLUS_EXPR", "&&", "code", "!=", "POINTER_PLUS_EXPR", ")", "||", "TREE_CODE", "(", "gimple_assign_rhs2", "(", "stmt", ")", ")", "!=", "INTEGER_CST", "||", "!", "tree_fits_uhwi_p", "(", "gimple_assign_rhs2", "(", "stmt", ")", ")", ")", ")", "return", "stmt", ";", "lhs", "=", "gimple_assign_rhs1", "(", "stmt", ")", ";", "}", "}", "</s>"], "natrual_language": ["Helper", "function", "for", "alpha_stdarg_optimize_hook", ".", "Skip", "over", "casts", "and", "constant", "additions", "."], "TS_V_token": ["alpha"], "File": "alpha", "Func": "va_list_skip_additions", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40829, "Length": 133}
{"ground_truth": ["<s>", "static", "void", "vms_asm_named_section", "(", "const", "char", "*", "name", ",", "unsigned", "int", "flags", ",", "tree", "decl", "ATTRIBUTE_UNUSED", ")", "{", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "fprintf", "(", "asm_out_file", ",", "\".section\\t%s\"", ",", "name", ")", ";", "if", "(", "flags", "&", "SECTION_DEBUG", ")", "fprintf", "(", "asm_out_file", ",", "\",NOWRT\"", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "}", "</s>"], "natrual_language": ["Switch", "to", "an", "arbitrary", "section", "NAME", "with", "attributes", "as", "specified", "by", "FLAGS", ".", "ALIGN", "specifies", "any", "known", "alignment", "requirements", "for", "the", "section", ";", "0", "if", "the", "default", "should", "be", "used", "."], "TS_V_token": ["alpha", "\".section\\t%s\"", "\",NOWRT\""], "File": "alpha", "Func": "vms_asm_named_section", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40830, "Length": 55}
{"ground_truth": ["<s>", "static", "void", "vms_asm_out_constructor", "(", "rtx", "symbol", ",", "int", "priority", "ATTRIBUTE_UNUSED", ")", "{", "switch_to_section", "(", "ctors_section", ")", ";", "assemble_align", "(", "BITS_PER_WORD", ")", ";", "assemble_integer", "(", "symbol", ",", "UNITS_PER_WORD", ",", "BITS_PER_WORD", ",", "1", ")", ";", "}", "</s>"], "natrual_language": ["Record", "an", "element", "in", "the", "table", "of", "global", "constructors", ".", "SYMBOL", "is", "a", "SYMBOL_REF", "of", "the", "function", "to", "be", "called", ";", "PRIORITY", "is", "a", "number", "between", "0", "and", "MAX_INIT_PRIORITY", ".", "Differs", "from", "default_ctors_section_asm_out_constructor", "in", "that", "the", "width", "of", "the", ".ctors", "entry", "is", "always", "64", "bits", ",", "rather", "than", "the", "32", "bits", "used", "by", "a", "normal", "pointer", "."], "TS_V_token": ["alpha", "1"], "File": "alpha", "Func": "vms_asm_out_constructor", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40831, "Length": 34}
{"ground_truth": ["<s>", "int", "zap_mask", "(", "HOST_WIDE_INT", "value", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "HOST_BITS_PER_WIDE_INT", "/", "HOST_BITS_PER_CHAR", ";", "i", "++", ",", "value", ">>=", "8", ")", "if", "(", "(", "value", "&", "0xff", ")", "!=", "0", "&&", "(", "value", "&", "0xff", ")", "!=", "0xff", ")", "return", "0", ";", "return", "1", ";", "}", "</s>"], "natrual_language": ["Returns", "1", "if", "VALUE", "is", "a", "mask", "that", "contains", "full", "bytes", "of", "zero", "or", "ones", "."], "TS_V_token": ["alpha", "0", "8", "0xff", "0", "0xff", "0xff", "0", "1"], "File": "alpha", "Func": "zap_mask", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40832, "Length": 54}
{"ground_truth": ["<s>", "const", "char", "*", "host_detect_local_cpu", "(", "int", "argc", ",", "const", "char", "*", "*", "argv", ")", "{", "static", "const", "struct", "cpu_types", "{", "long", "implver", ";", "long", "amask", ";", "const", "char", "*", "const", "cpu", ";", "}", "cpu_types", "[", "]", "=", "{", "{", "IMPLVER_EV7_FAMILY", ",", "AMASK_BWX", "|", "AMASK_MVI", "|", "AMASK_FIX", "|", "AMASK_CIX", ",", "\"ev67\"", "}", ",", "{", "IMPLVER_EV6_FAMILY", ",", "AMASK_BWX", "|", "AMASK_MVI", "|", "AMASK_FIX", "|", "AMASK_CIX", ",", "\"ev67\"", "}", ",", "{", "IMPLVER_EV6_FAMILY", ",", "AMASK_BWX", "|", "AMASK_MVI", "|", "AMASK_FIX", ",", "\"ev6\"", "}", ",", "{", "IMPLVER_EV5_FAMILY", ",", "AMASK_BWX", "|", "AMASK_MVI", ",", "\"pca56\"", "}", ",", "{", "IMPLVER_EV5_FAMILY", ",", "AMASK_BWX", ",", "\"ev56\"", "}", ",", "{", "IMPLVER_EV5_FAMILY", ",", "0", ",", "\"ev5\"", "}", ",", "{", "IMPLVER_EV4_FAMILY", ",", "0", ",", "\"ev4\"", "}", ",", "{", "0", ",", "0", ",", "NULL", "}", "}", ";", "long", "implver", ";", "long", "amask", ";", "const", "char", "*", "cpu", ";", "int", "i", ";", "if", "(", "argc", "<", "1", ")", "return", "NULL", ";", "if", "(", "strcmp", "(", "argv", "[", "0", "]", ",", "\"cpu\"", ")", "&&", "strcmp", "(", "argv", "[", "0", "]", ",", "\"tune\"", ")", ")", "return", "NULL", ";", "implver", "=", "__builtin_alpha_implver", "(", ")", ";", "amask", "=", "__builtin_alpha_amask", "(", "~", "0L", ")", ";", "cpu", "=", "NULL", ";", "for", "(", "i", "=", "0", ";", "cpu_types", "[", "i", "]", ".", "cpu", "!=", "NULL", ";", "i", "++", ")", "if", "(", "implver", "==", "cpu_types", "[", "i", "]", ".", "implver", "&&", "(", "~", "amask", "&", "cpu_types", "[", "i", "]", ".", "amask", ")", "==", "cpu_types", "[", "i", "]", ".", "amask", ")", "{", "cpu", "=", "cpu_types", "[", "i", "]", ".", "cpu", ";", "break", ";", "}", "if", "(", "cpu", "==", "NULL", ")", "return", "NULL", ";", "return", "concat", "(", "\"-m\"", ",", "argv", "[", "0", "]", ",", "\"=\"", ",", "cpu", ",", "NULL", ")", ";", "}", "</s>"], "natrual_language": ["This", "will", "be", "called", "by", "the", "spec", "parser", "in", "gcc.cc", "when", "it", "sees", "a", "%", ":", "local_cpu_detect", "(", "args", ")", "construct", ".", "Currently", "it", "will", "be", "called", "with", "either", "``", "cpu", "''", "or", "``", "tune", "''", "as", "argument", "depending", "on", "if", "-mcpu=native", "or", "-mtune=native", "is", "to", "be", "substituted", ".", "It", "returns", "a", "string", "containing", "new", "command", "line", "parameters", "to", "be", "put", "at", "the", "place", "of", "the", "above", "two", "options", ",", "depending", "on", "what", "CPU", "this", "is", "executed", ".", "E.g", ".", "``", "-mcpu=ultrasparc3", "''", "on", "an", "UltraSPARC", "III", "for", "-mcpu=native", ".", "If", "the", "routine", "ca", "n't", "detect", "a", "known", "processor", ",", "the", "-mcpu", "or", "-mtune", "option", "is", "discarded", ".", "ARGC", "and", "ARGV", "are", "set", "depending", "on", "the", "actual", "arguments", "given", "in", "the", "spec", "."], "TS_V_token": ["alpha", "\"ev67\"", "\"ev67\"", "\"ev6\"", "\"pca56\"", "\"ev56\"", "0", "\"ev5\"", "0", "\"ev4\"", "0", "0", "1", "0", "\"cpu\"", "0", "\"tune\"", "0L", "0", "\"-m\"", "0", "\"=\""], "File": "driver-alpha", "Func": "host_detect_local_cpu", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40833, "Length": 275}
{"ground_truth": ["<s>", "static", "void", "addarg", "(", "const", "char", "*", "str", ")", "{", "int", "i", ";", "if", "(", "++", "comp_arg_index", ">=", "comp_arg_max", ")", "{", "const", "char", "*", "*", "new_comp_args", "=", "(", "const", "char", "*", "*", ")", "xcalloc", "(", "comp_arg_max", "+", "1000", ",", "sizeof", "(", "char", "*", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<=", "comp_arg_max", ";", "i", "++", ")", "new_comp_args", "[", "i", "]", "=", "comp_args", "[", "i", "]", ";", "if", "(", "comp_args", ")", "free", "(", "comp_args", ")", ";", "comp_arg_max", "+=", "1000", ";", "comp_args", "=", "new_comp_args", ";", "}", "comp_args", "[", "comp_arg_index", "]", "=", "str", ";", "}", "</s>"], "natrual_language": ["Append", "STR", "to", "the", "command", "line", "to", "invoke", "the", "linker", ".", "Expand", "the", "line", "as", "necessary", "to", "accommodate", "."], "TS_V_token": ["alpha", "1000", "0", "1000"], "File": "vms-cc1", "Func": "addarg", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40834, "Length": 95}
{"ground_truth": ["<s>", "static", "void", "preprocess_args", "(", "int", "*", "p_argc", ",", "char", "*", "argv", "[", "]", ")", "{", "int", "i", ";", "for", "(", "i", "=", "1", ";", "i", "<", "*", "p_argc", ";", "i", "++", ")", "{", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-o\"", ")", "==", "0", ")", "{", "char", "*", "buff", ",", "*", "ptr", ";", "i", "++", ";", "ptr", "=", "to_host_file_spec", "(", "argv", "[", "i", "]", ")", ";", "objfilename", "=", "xstrdup", "(", "ptr", ")", ";", "buff", "=", "concat", "(", "\"/obj=\"", ",", "ptr", ",", "NULL", ")", ";", "addarg", "(", "buff", ")", ";", "}", "}", "}", "</s>"], "natrual_language": ["Preprocess", "the", "number", "of", "args", "P_ARGC", "in", "ARGV", ".", "Look", "for", "special", "flags", ",", "etc", ".", "that", "must", "be", "handled", "first", "."], "TS_V_token": ["alpha", "1", "\"-o\"", "0", "\"/obj=\""], "File": "vms-cc1", "Func": "preprocess_args", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40835, "Length": 94}
{"ground_truth": ["<s>", "static", "void", "process_args", "(", "int", "*", "p_argc", ",", "char", "*", "argv", "[", "]", ")", "{", "int", "i", ";", "for", "(", "i", "=", "1", ";", "i", "<", "*", "p_argc", ";", "i", "++", ")", "{", "if", "(", "strlen", "(", "argv", "[", "i", "]", ")", "<", "2", ")", "continue", ";", "if", "(", "strncmp", "(", "argv", "[", "i", "]", ",", "\"-I\"", ",", "2", ")", "==", "0", ")", "{", "char", "*", "ptr", ";", "int", "new_len", ",", "search_dirs_len", ";", "ptr", "=", "to_host_dir_spec", "(", "&", "argv", "[", "i", "]", "[", "2", "]", ")", ";", "new_len", "=", "strlen", "(", "ptr", ")", ";", "search_dirs_len", "=", "strlen", "(", "search_dirs", ")", ";", "search_dirs", "=", "xrealloc", "(", "search_dirs", ",", "search_dirs_len", "+", "new_len", "+", "2", ")", ";", "if", "(", "search_dirs_len", ">", "0", ")", "strcat", "(", "search_dirs", ",", "PATH_SEPARATOR_STR", ")", ";", "strcat", "(", "search_dirs", ",", "ptr", ")", ";", "}", "else", "if", "(", "strncmp", "(", "argv", "[", "i", "]", ",", "\"-D\"", ",", "2", ")", "==", "0", ")", "{", "char", "*", "ptr", ";", "int", "new_len", ",", "defines_len", ";", "ptr", "=", "&", "argv", "[", "i", "]", "[", "2", "]", ";", "new_len", "=", "strlen", "(", "ptr", ")", ";", "defines_len", "=", "strlen", "(", "defines", ")", ";", "defines", "=", "xrealloc", "(", "defines", ",", "defines_len", "+", "new_len", "+", "4", ")", ";", "if", "(", "defines_len", ">", "0", ")", "strcat", "(", "defines", ",", "\",\"", ")", ";", "strcat", "(", "defines", ",", "\"\\\"\"", ")", ";", "strcat", "(", "defines", ",", "ptr", ")", ";", "strcat", "(", "defines", ",", "\"\\\"\"", ")", ";", "}", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-v\"", ")", "==", "0", ")", "verbose", "=", "1", ";", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-g0\"", ")", "==", "0", ")", "addarg", "(", "\"/nodebug\"", ")", ";", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-O0\"", ")", "==", "0", ")", "addarg", "(", "\"/noopt\"", ")", ";", "else", "if", "(", "strncmp", "(", "argv", "[", "i", "]", ",", "\"-g\"", ",", "2", ")", "==", "0", ")", "addarg", "(", "\"/debug\"", ")", ";", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-E\"", ")", "==", "0", ")", "addarg", "(", "\"/preprocess\"", ")", ";", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-save-temps\"", ")", "==", "0", ")", "save_temps", "=", "1", ";", "}", "}", "</s>"], "natrual_language": ["Preprocess", "the", "number", "of", "args", "ARGC", "in", "ARGV", ".", "Look", "for", "special", "flags", ",", "etc", ".", "that", "must", "be", "handled", "for", "the", "VMS", "linker", "."], "TS_V_token": ["alpha", "1", "2", "\"-I\"", "2", "0", "2", "2", "0", "\"-D\"", "2", "0", "2", "4", "0", "\",\"", "\"\\\"\"", "\"\\\"\"", "\"-v\"", "0", "1", "\"-g0\"", "0", "\"/nodebug\"", "\"-O0\"", "0", "\"/noopt\"", "\"-g\"", "2", "0", "\"/debug\"", "\"-E\"", "0", "\"/preprocess\"", "\"-save-temps\"", "0", "1"], "File": "vms-cc1", "Func": "process_args", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40836, "Length": 357}
{"ground_truth": ["<s>", "static", "char", "*", "to_host_file_spec", "(", "char", "*", "filespec", ")", "{", "strcpy", "(", "new_host_filespec", ",", "\"\"", ")", ";", "if", "(", "strchr", "(", "filespec", ",", "']'", ")", "||", "strchr", "(", "filespec", ",", "':'", ")", ")", "strcpy", "(", "new_host_filespec", ",", "filespec", ")", ";", "else", "{", "decc$to_vms", "(", "filespec", ",", "translate_unix", ",", "1", ",", "1", ")", ";", "strcpy", "(", "new_host_filespec", ",", "filename_buff", ")", ";", "}", "return", "new_host_filespec", ";", "}", "</s>"], "natrual_language": ["Translate", "a", "Unix", "syntax", "file", "specification", "FILESPEC", "into", "VMS", "syntax", ".", "If", "indicators", "of", "VMS", "syntax", "found", ",", "return", "input", "string", ".", "Return", "a", "pointer", "to", "a", "static", "buffer", "."], "TS_V_token": ["alpha", "\"\"", "1", "1"], "File": "vms-cc1", "Func": "to_host_file_spec", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40837, "Length": 65}
{"ground_truth": ["<s>", "static", "int", "translate_unix", "(", "char", "*", "name", ",", "int", "type", "ATTRIBUTE_UNUSED", ")", "{", "strcpy", "(", "filename_buff", ",", "name", ")", ";", "return", "0", ";", "}", "</s>"], "natrual_language": ["Action", "routine", "called", "by", "decc", "$", "to_vms", ".", "NAME", "is", "a", "file", "name", "or", "directory", "name", ".", "TYPE", "is", "unused", "."], "TS_V_token": ["alpha", "0"], "File": "vms-cc1", "Func": "translate_unix", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40838, "Length": 24}
{"ground_truth": ["<s>", "static", "void", "addarg", "(", "const", "char", "*", "str", ")", "{", "int", "i", ";", "if", "(", "++", "link_arg_index", ">=", "link_arg_max", ")", "{", "const", "char", "*", "*", "new_link_args", "=", "(", "const", "char", "*", "*", ")", "xcalloc", "(", "link_arg_max", "+", "1000", ",", "sizeof", "(", "char", "*", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<=", "link_arg_max", ";", "i", "++", ")", "new_link_args", "[", "i", "]", "=", "link_args", "[", "i", "]", ";", "if", "(", "link_args", ")", "free", "(", "link_args", ")", ";", "link_arg_max", "+=", "1000", ";", "link_args", "=", "new_link_args", ";", "}", "link_args", "[", "link_arg_index", "]", "=", "str", ";", "}", "</s>"], "natrual_language": ["Append", "STR", "to", "the", "command", "line", "to", "invoke", "the", "linker", ".", "Expand", "the", "line", "as", "necessary", "to", "accommodate", "."], "TS_V_token": ["alpha", "1000", "0", "1000"], "File": "vms-ld1", "Func": "addarg", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40839, "Length": 95}
{"ground_truth": ["<s>", "static", "const", "char", "*", "expand_lib", "(", "char", "*", "name", ")", "{", "char", "*", "lib", ",", "*", "lib_path", ";", "if", "(", "strcmp", "(", "name", ",", "\"c\"", ")", "==", "0", ")", "return", "\"sys$library:vaxcrtltx.olb\"", ";", "else", "if", "(", "strcmp", "(", "name", ",", "\"m\"", ")", "==", "0", ")", "return", "\"\"", ";", "else", "{", "lib", "=", "xmalloc", "(", "strlen", "(", "name", ")", "+", "14", ")", ";", "strcpy", "(", "lib", ",", "\"lib\"", ")", ";", "strcat", "(", "lib", ",", "name", ")", ";", "lib_path", "=", "locate_lib", "(", "lib", ",", "search_dirs", ")", ";", "if", "(", "lib_path", ")", "return", "lib_path", ";", "}", "fprintf", "(", "stderr", ",", "\"Couldn't locate library: lib%s.exe, lib%s.a or lib%s.olb\\n\"", ",", "name", ",", "name", ",", "name", ")", ";", "exit", "(", "1", ")", ";", "}", "</s>"], "natrual_language": ["Given", "a", "library", "name", "NAME", ",", "i.e", ".", "foo", ",", "Look", "for", "libfoo.lib", "and", "then", "libfoo.a", "in", "the", "set", "of", "directories", "we", "are", "allowed", "to", "search", "in", ".", "May", "return", "NULL", "if", "the", "library", "can", "be", "discarded", "."], "TS_V_token": ["alpha", "\"c\"", "0", "\"sys$library:vaxcrtltx.olb\"", "\"m\"", "0", "\"\"", "14", "\"lib\"", "\"Couldn't locate library: lib%s.exe, lib%s.a or lib%s.olb\\n\"", "1"], "File": "vms-ld1", "Func": "expand_lib", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40840, "Length": 111}
{"ground_truth": ["<s>", "static", "int", "is_regular_file", "(", "char", "*", "name", ")", "{", "int", "ret", ";", "struct", "stat", "statbuf", ";", "ret", "=", "stat", "(", "name", ",", "&", "statbuf", ")", ";", "return", "!", "ret", "&&", "S_ISREG", "(", "statbuf", ".", "st_mode", ")", ";", "}", "</s>"], "natrual_language": ["Check", "to", "see", "if", "NAME", "is", "a", "regular", "file", ",", "i.e", ".", "not", "a", "directory", "."], "TS_V_token": ["alpha"], "File": "vms-ld1", "Func": "is_regular_file", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40841, "Length": 38}
{"ground_truth": ["<s>", "static", "char", "*", "locate_lib", "(", "char", "*", "lib_name", ",", "char", "*", "path_val", ")", "{", "int", "lib_len", "=", "strlen", "(", "lib_name", ")", ";", "char", "*", "eptr", ",", "*", "sptr", ";", "for", "(", "sptr", "=", "path_val", ";", "*", "sptr", ";", "sptr", "=", "eptr", ")", "{", "char", "*", "buf", ",", "*", "ptr", ";", "while", "(", "*", "sptr", "==", "PATH_SEPARATOR", ")", "sptr", "++", ";", "eptr", "=", "strchr", "(", "sptr", ",", "PATH_SEPARATOR", ")", ";", "if", "(", "eptr", "==", "0", ")", "eptr", "=", "strchr", "(", "sptr", ",", "0", ")", ";", "buf", "=", "alloca", "(", "(", "eptr", "-", "sptr", ")", "+", "lib_len", "+", "4", "+", "2", ")", ";", "strncpy", "(", "buf", ",", "sptr", ",", "eptr", "-", "sptr", ")", ";", "buf", "[", "eptr", "-", "sptr", "]", "=", "0", ";", "strcat", "(", "buf", ",", "\"/\"", ")", ";", "strcat", "(", "buf", ",", "lib_name", ")", ";", "ptr", "=", "strchr", "(", "buf", ",", "0", ")", ";", "if", "(", "debug", "||", "staticp", ")", "{", "strcpy", "(", "ptr", ",", "\".a\"", ")", ";", "if", "(", "is_regular_file", "(", "buf", ")", ")", "return", "xstrdup", "(", "to_host_file_spec", "(", "buf", ")", ")", ";", "strcpy", "(", "ptr", ",", "\".olb\"", ")", ";", "if", "(", "is_regular_file", "(", "buf", ")", ")", "return", "xstrdup", "(", "to_host_file_spec", "(", "buf", ")", ")", ";", "strcpy", "(", "ptr", ",", "\".exe\"", ")", ";", "if", "(", "is_regular_file", "(", "buf", ")", ")", "return", "xstrdup", "(", "to_host_file_spec", "(", "buf", ")", ")", ";", "}", "else", "{", "strcpy", "(", "ptr", ",", "\".exe\"", ")", ";", "if", "(", "is_regular_file", "(", "buf", ")", ")", "return", "xstrdup", "(", "to_host_file_spec", "(", "buf", ")", ")", ";", "strcpy", "(", "ptr", ",", "\".a\"", ")", ";", "if", "(", "is_regular_file", "(", "buf", ")", ")", "return", "xstrdup", "(", "to_host_file_spec", "(", "buf", ")", ")", ";", "strcpy", "(", "ptr", ",", "\".olb\"", ")", ";", "if", "(", "is_regular_file", "(", "buf", ")", ")", "return", "xstrdup", "(", "to_host_file_spec", "(", "buf", ")", ")", ";", "}", "}", "return", "0", ";", "}", "</s>"], "natrual_language": ["Locate", "library", "LIB_NAME", "on", "the", "library", "path", "."], "TS_V_token": ["alpha", "0", "0", "4", "2", "0", "\"/\"", "0", "\".a\"", "\".olb\"", "\".exe\"", "\".exe\"", "\".a\"", "\".olb\"", "0"], "File": "vms-ld1", "Func": "locate_lib", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40842, "Length": 298}
{"ground_truth": ["<s>", "static", "void", "preprocess_args", "(", "int", "*", "p_argc", ",", "char", "*", "*", "argv", ")", "{", "int", "i", ";", "for", "(", "i", "=", "1", ";", "i", "<", "*", "p_argc", ";", "i", "++", ")", "if", "(", "strlen", "(", "argv", "[", "i", "]", ")", ">=", "6", "&&", "strncmp", "(", "argv", "[", "i", "]", ",", "\"-shared\"", ",", "7", ")", "==", "0", ")", "share", "=", "1", ";", "for", "(", "i", "=", "1", ";", "i", "<", "*", "p_argc", ";", "i", "++", ")", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-o\"", ")", "==", "0", ")", "{", "char", "*", "buff", ",", "*", "ptr", ";", "int", "out_len", ";", "int", "len", ";", "i", "++", ";", "ptr", "=", "to_host_file_spec", "(", "argv", "[", "i", "]", ")", ";", "exefilename", "=", "xstrdup", "(", "ptr", ")", ";", "out_len", "=", "strlen", "(", "ptr", ")", ";", "buff", "=", "xmalloc", "(", "out_len", "+", "18", ")", ";", "if", "(", "share", ")", "strcpy", "(", "buff", ",", "\"/share=\"", ")", ";", "else", "strcpy", "(", "buff", ",", "\"/exe=\"", ")", ";", "strcat", "(", "buff", ",", "ptr", ")", ";", "addarg", "(", "buff", ")", ";", "if", "(", "share", ")", "{", "sharefilename", "=", "xmalloc", "(", "out_len", "+", "5", ")", ";", "if", "(", "ptr", "==", "strchr", "(", "argv", "[", "i", "]", ",", "']'", ")", ")", "strcpy", "(", "sharefilename", ",", "++", "ptr", ")", ";", "else", "if", "(", "ptr", "==", "strchr", "(", "argv", "[", "i", "]", ",", "':'", ")", ")", "strcpy", "(", "sharefilename", ",", "++", "ptr", ")", ";", "else", "if", "(", "ptr", "==", "strrchr", "(", "argv", "[", "i", "]", ",", "'/'", ")", ")", "strcpy", "(", "sharefilename", ",", "++", "ptr", ")", ";", "else", "strcpy", "(", "sharefilename", ",", "argv", "[", "i", "]", ")", ";", "len", "=", "strlen", "(", "sharefilename", ")", ";", "if", "(", "strncasecmp", "(", "&", "sharefilename", "[", "len", "-", "4", "]", ",", "\".exe\"", ",", "4", ")", "==", "0", ")", "sharefilename", "[", "len", "-", "4", "]", "=", "0", ";", "for", "(", "ptr", "=", "sharefilename", ";", "*", "ptr", ";", "ptr", "++", ")", "*", "ptr", "=", "TOUPPER", "(", "*", "ptr", ")", ";", "}", "}", "}", "</s>"], "natrual_language": ["Preprocess", "the", "number", "of", "args", "P_ARGC", "in", "ARGV", ".", "Look", "for", "special", "flags", ",", "etc", ".", "that", "must", "be", "handled", "first", "."], "TS_V_token": ["alpha", "1", "6", "\"-shared\"", "7", "0", "1", "1", "\"-o\"", "0", "18", "\"/share=\"", "\"/exe=\"", "5", "4", "\".exe\"", "4", "0", "4", "0"], "File": "vms-ld1", "Func": "preprocess_args", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40843, "Length": 322}
{"ground_truth": ["<s>", "static", "void", "process_args", "(", "int", "*", "p_argc", ",", "char", "*", "*", "argv", ")", "{", "int", "i", ";", "for", "(", "i", "=", "1", ";", "i", "<", "*", "p_argc", ";", "i", "++", ")", "{", "if", "(", "strlen", "(", "argv", "[", "i", "]", ")", "<", "2", ")", "continue", ";", "if", "(", "strncmp", "(", "argv", "[", "i", "]", ",", "\"-L\"", ",", "2", ")", "==", "0", ")", "{", "char", "*", "nbuff", ",", "*", "ptr", ";", "int", "new_len", ",", "search_dirs_len", ";", "ptr", "=", "&", "argv", "[", "i", "]", "[", "2", "]", ";", "new_len", "=", "strlen", "(", "ptr", ")", ";", "search_dirs_len", "=", "strlen", "(", "search_dirs", ")", ";", "nbuff", "=", "xmalloc", "(", "new_len", "+", "1", ")", ";", "strcpy", "(", "nbuff", ",", "ptr", ")", ";", "while", "(", "new_len", ">", "1", "&&", "nbuff", "[", "new_len", "-", "1", "]", "==", "'/'", ")", "{", "nbuff", "[", "new_len", "-", "1", "]", "=", "0", ";", "new_len", "--", ";", "}", "search_dirs", "=", "xrealloc", "(", "search_dirs", ",", "search_dirs_len", "+", "new_len", "+", "2", ")", ";", "if", "(", "search_dirs_len", ">", "0", ")", "strcat", "(", "search_dirs", ",", "PATH_SEPARATOR_STR", ")", ";", "strcat", "(", "search_dirs", ",", "nbuff", ")", ";", "free", "(", "nbuff", ")", ";", "}", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-v\"", ")", "==", "0", ")", "verbose", "=", "1", ";", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-g0\"", ")", "==", "0", ")", "addarg", "(", "\"/notraceback\"", ")", ";", "else", "if", "(", "strncmp", "(", "argv", "[", "i", "]", ",", "\"-g\"", ",", "2", ")", "==", "0", ")", "{", "addarg", "(", "\"/debug\"", ")", ";", "debug", "=", "1", ";", "}", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-static\"", ")", "==", "0", ")", "staticp", "=", "1", ";", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-map\"", ")", "==", "0", ")", "{", "char", "*", "buff", ",", "*", "ptr", ";", "buff", "=", "xmalloc", "(", "strlen", "(", "exefilename", ")", "+", "5", ")", ";", "strcpy", "(", "buff", ",", "exefilename", ")", ";", "ptr", "=", "strchr", "(", "buff", ",", "'.'", ")", ";", "if", "(", "ptr", ")", "*", "ptr", "=", "0", ";", "strcat", "(", "buff", ",", "\".map\"", ")", ";", "addarg", "(", "\"/map=\"", ")", ";", "addarg", "(", "buff", ")", ";", "addarg", "(", "\"/full\"", ")", ";", "}", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-save-temps\"", ")", "==", "0", ")", "save_temps", "=", "1", ";", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"--noinhibit-exec\"", ")", "==", "0", ")", "inhibit_exec", "=", "0", ";", "}", "}", "</s>"], "natrual_language": ["Preprocess", "the", "number", "of", "args", "ARGC", "in", "ARGV", ".", "Look", "for", "special", "flags", ",", "etc", ".", "that", "must", "be", "handled", "for", "the", "VMS", "linker", "."], "TS_V_token": ["alpha", "1", "2", "\"-L\"", "2", "0", "2", "1", "1", "1", "1", "0", "2", "0", "\"-v\"", "0", "1", "\"-g0\"", "0", "\"/notraceback\"", "\"-g\"", "2", "0", "\"/debug\"", "1", "\"-static\"", "0", "1", "\"-map\"", "0", "5", "0", "\".map\"", "\"/map=\"", "\"/full\"", "\"-save-temps\"", "0", "1", "\"--noinhibit-exec\"", "0", "0"], "File": "vms-ld1", "Func": "process_args", "Target": "alpha", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 40844, "Length": 393}