+2001-05-01 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
+
+ * bitmap.c: Change NULL_PTR to NULL or "(rtx*)0".
+ * c-common.c: Likewise.
+ * c-decl.c: Likewise.
+ * combine.c: Likewise.
+ * rs6000.c: Likewise.
+ * except.c: Likewise.
+ * explow.c: Likewise.
+ * expr.c: Likewise.
+ * fold-const.c: Likewise.
+ * function.c: Likewise.
+ * gcc.c: Likewise.
+ * gcse.c: Likewise.
+ * integrate.c: Likewise.
+ * loop.c: Likewise.
+ * objc/objc-act.c: Likewise.
+ * recog.c: Likewise.
+ * reg-stack.c: Likewise.
+ * reload.c: Likewise.
+ * reload1.c: Likewise.
+ * simplify-rtx.c: Likewise.
+ * stmt.c: Likewise.
+ * varasm.c: Likewise.
+
2001-05-01 Gabriel Dos Reis <gdr@codesourcery.com>
* diagnostic.def: New file.
if (bitmap_obstack_init)
{
bitmap_obstack_init = FALSE;
- obstack_free (&bitmap_obstack, NULL_PTR);
+ obstack_free (&bitmap_obstack, NULL);
}
}
tree va_list_arg_type_node;
/* Define `int' and `char' first so that dbx will output them first. */
- record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
+ record_builtin_type (RID_INT, NULL, integer_type_node);
record_builtin_type (RID_CHAR, "char", char_type_node);
/* `signed' is the same as `int'. FIXME: the declarations of "signed",
"unsigned long", "long long unsigned" and "unsigned short" were in C++
but not C. Are the conditionals here needed? */
if (c_language == clk_cplusplus)
- record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
+ record_builtin_type (RID_SIGNED, NULL, integer_type_node);
record_builtin_type (RID_LONG, "long int", long_integer_type_node);
record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
record_builtin_type (RID_MAX, "long unsigned int",
build_common_tree_nodes_2 (flag_short_double);
- record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
- record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
+ record_builtin_type (RID_FLOAT, NULL, float_type_node);
+ record_builtin_type (RID_DOUBLE, NULL, double_type_node);
record_builtin_type (RID_MAX, "long double", long_double_type_node);
pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
complex_long_double_type_node));
- record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
+ record_builtin_type (RID_VOID, NULL, void_type_node);
void_list_node = build_void_list_node ();
NULL_TREE)));
builtin_function ("__builtin_constant_p", default_function_type,
- BUILT_IN_CONSTANT_P, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_CONSTANT_P, BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_return_address", ptr_ftype_unsigned,
- BUILT_IN_RETURN_ADDRESS, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_RETURN_ADDRESS, BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_frame_address", ptr_ftype_unsigned,
- BUILT_IN_FRAME_ADDRESS, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_FRAME_ADDRESS, BUILT_IN_NORMAL, NULL);
#ifdef EH_RETURN_DATA_REGNO
builtin_function ("__builtin_eh_return_data_regno", int_ftype_int,
- BUILT_IN_EH_RETURN_DATA_REGNO, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_EH_RETURN_DATA_REGNO, BUILT_IN_NORMAL, NULL);
#endif
builtin_function ("__builtin_alloca", ptr_ftype_sizetype,
BUILT_IN_FFS, BUILT_IN_NORMAL, 0, 1, 0);
/* Define alloca as builtin, unless SMALL_STACK. */
#ifndef SMALL_STACK
- builtin_function_2 (NULL_PTR, "alloca", NULL_TREE, ptr_ftype_sizetype,
+ builtin_function_2 (NULL, "alloca", NULL_TREE, ptr_ftype_sizetype,
BUILT_IN_ALLOCA, BUILT_IN_NORMAL, 0, 1, 0);
#endif
/* Declare _exit and _Exit just to mark them as non-returning. */
- builtin_function_2 (NULL_PTR, "_exit", NULL_TREE, void_ftype_int,
+ builtin_function_2 (NULL, "_exit", NULL_TREE, void_ftype_int,
0, NOT_BUILT_IN, 0, 1, 1);
- builtin_function_2 (NULL_PTR, "_Exit", NULL_TREE, void_ftype_int,
+ builtin_function_2 (NULL, "_Exit", NULL_TREE, void_ftype_int,
0, NOT_BUILT_IN, 0, !flag_isoc99, 1);
builtin_function_2 ("__builtin_index", "index",
BUILT_IN_ABS, BUILT_IN_NORMAL, 0, !flag_isoc99, 0);
builtin_function ("__builtin_saveregs", ptr_ftype, BUILT_IN_SAVEREGS,
- BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_classify_type", default_function_type,
- BUILT_IN_CLASSIFY_TYPE, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_CLASSIFY_TYPE, BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_next_arg", ptr_ftype, BUILT_IN_NEXT_ARG,
- BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_args_info", int_ftype_int, BUILT_IN_ARGS_INFO,
- BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_setjmp",
build_function_type (integer_type_node,
tree_cons (NULL_TREE, ptr_type_node,
endlink)),
- BUILT_IN_SETJMP, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_SETJMP, BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_longjmp",
build_function_type (void_type_node,
tree_cons (NULL_TREE, ptr_type_node,
int_endlink)),
- BUILT_IN_LONGJMP, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_LONGJMP, BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_trap", void_ftype, BUILT_IN_TRAP,
- BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_NORMAL, NULL);
/* ISO C99 IEEE Unordered compares. */
builtin_function ("__builtin_isgreater", default_function_type,
- BUILT_IN_ISGREATER, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_ISGREATER, BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_isgreaterequal", default_function_type,
- BUILT_IN_ISGREATEREQUAL, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_ISGREATEREQUAL, BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_isless", default_function_type,
- BUILT_IN_ISLESS, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_ISLESS, BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_islessequal", default_function_type,
- BUILT_IN_ISLESSEQUAL, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_ISLESSEQUAL, BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_islessgreater", default_function_type,
- BUILT_IN_ISLESSGREATER, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_ISLESSGREATER, BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_isunordered", default_function_type,
- BUILT_IN_ISUNORDERED, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_ISUNORDERED, BUILT_IN_NORMAL, NULL);
/* Untyped call and return. */
builtin_function ("__builtin_apply_args", ptr_ftype,
- BUILT_IN_APPLY_ARGS, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_APPLY_ARGS, BUILT_IN_NORMAL, NULL);
temp = tree_cons (NULL_TREE,
build_pointer_type (build_function_type (void_type_node,
tree_cons (NULL_TREE, ptr_type_node, sizetype_endlink));
builtin_function ("__builtin_apply",
build_function_type (ptr_type_node, temp),
- BUILT_IN_APPLY, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_APPLY, BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_return", void_ftype_ptr,
- BUILT_IN_RETURN, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_RETURN, BUILT_IN_NORMAL, NULL);
/* Support for varargs.h and stdarg.h. */
builtin_function ("__builtin_varargs_start",
tree_cons (NULL_TREE,
va_list_ref_type_node,
endlink)),
- BUILT_IN_VARARGS_START, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_VARARGS_START, BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_stdarg_start",
build_function_type (void_type_node,
tree_cons (NULL_TREE,
va_list_ref_type_node,
NULL_TREE)),
- BUILT_IN_STDARG_START, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_STDARG_START, BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_va_end",
build_function_type (void_type_node,
tree_cons (NULL_TREE,
va_list_ref_type_node,
endlink)),
- BUILT_IN_VA_END, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_VA_END, BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_va_copy",
build_function_type (void_type_node,
tree_cons (NULL_TREE,
va_list_arg_type_node,
endlink))),
- BUILT_IN_VA_COPY, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_VA_COPY, BUILT_IN_NORMAL, NULL);
/* ??? Ought to be `T __builtin_expect(T, T)' for any type T. */
builtin_function ("__builtin_expect",
tree_cons (NULL_TREE,
long_integer_type_node,
endlink))),
- BUILT_IN_EXPECT, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_EXPECT, BUILT_IN_NORMAL, NULL);
/* Currently under experimentation. */
builtin_function_2 ("__builtin_memcpy", "memcpy",
/* Declare these functions non-returning
to avoid spurious "control drops through" warnings. */
- builtin_function_2 (NULL_PTR, "abort",
+ builtin_function_2 (NULL, "abort",
NULL_TREE, ((c_language == clk_cplusplus)
? void_ftype : void_ftype_any),
0, NOT_BUILT_IN, 0, 0, 1);
- builtin_function_2 (NULL_PTR, "exit",
+ builtin_function_2 (NULL, "exit",
NULL_TREE, ((c_language == clk_cplusplus)
? void_ftype_int : void_ftype_any),
0, NOT_BUILT_IN, 0, 0, 1);
/* Support for these has not been written in either expand_builtin
or build_function_call. */
builtin_function ("__builtin_div", default_ftype, BUILT_IN_DIV,
- BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_ldiv", default_ftype, BUILT_IN_LDIV,
- BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_ffloor", double_ftype_double, BUILT_IN_FFLOOR,
- BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_fceil", double_ftype_double, BUILT_IN_FCEIL,
- BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_fmod", double_ftype_double_double,
- BUILT_IN_FMOD, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_FMOD, BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_frem", double_ftype_double_double,
- BUILT_IN_FREM, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_FREM, BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_getexp", double_ftype_double, BUILT_IN_GETEXP,
- BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_getman", double_ftype_double, BUILT_IN_GETMAN,
- BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_NORMAL, NULL);
#endif
main_identifier_node = get_identifier ("main");
if (builtin_name != 0)
{
bdecl = builtin_function (builtin_name, builtin_type, function_code,
- class, library_name_p ? name : NULL_PTR);
+ class, library_name_p ? name : NULL);
if (noreturn_p)
{
TREE_THIS_VOLATILE (bdecl) = 1;
}
if (name != 0 && !flag_no_builtin && !(nonansi_p && flag_no_nonansi_builtin))
{
- decl = builtin_function (name, type, function_code, class, NULL_PTR);
+ decl = builtin_function (name, type, function_code, class, NULL);
if (nonansi_p)
DECL_BUILT_IN_NONANSI (decl) = 1;
if (noreturn_p)
/* This is a no-op in c-lang.c or something real in objc-actions.c. */
maybe_objc_check_decl (decl);
- rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
+ rest_of_decl_compilation (decl, NULL, 0, 0);
if (implicit_warning)
implicit_decl_warning (functionid);
builtin_function ("__builtin_aggregate_incoming_address",
build_function_type (ptr_type_node, NULL_TREE),
BUILT_IN_AGGREGATE_INCOMING_ADDRESS,
- BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_NORMAL, NULL);
/* Hooks for the DWARF 2 __throw routine. */
builtin_function ("__builtin_unwind_init",
build_function_type (void_type_node, endlink),
- BUILT_IN_UNWIND_INIT, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_UNWIND_INIT, BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_dwarf_cfa", ptr_ftype_void,
- BUILT_IN_DWARF_CFA, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_DWARF_CFA, BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_dwarf_fp_regnum",
build_function_type (unsigned_type_node, endlink),
- BUILT_IN_DWARF_FP_REGNUM, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_DWARF_FP_REGNUM, BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_init_dwarf_reg_size_table", void_ftype_ptr,
- BUILT_IN_INIT_DWARF_REG_SIZES, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_INIT_DWARF_REG_SIZES, BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_frob_return_addr", ptr_ftype_ptr,
- BUILT_IN_FROB_RETURN_ADDR, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_FROB_RETURN_ADDR, BUILT_IN_NORMAL, NULL);
builtin_function ("__builtin_extract_return_addr", ptr_ftype_ptr,
- BUILT_IN_EXTRACT_RETURN_ADDR, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_EXTRACT_RETURN_ADDR, BUILT_IN_NORMAL, NULL);
builtin_function
("__builtin_eh_return",
build_function_type (void_type_node,
tree_cons (NULL_TREE,
ptr_type_node,
endlink))),
- BUILT_IN_EH_RETURN, BUILT_IN_NORMAL, NULL_PTR);
+ BUILT_IN_EH_RETURN, BUILT_IN_NORMAL, NULL);
pedantic_lvalues = pedantic;
DECL_BUILT_IN_NONANSI (decl) = 1;
if (library_name)
SET_DECL_ASSEMBLER_NAME (decl, get_identifier (library_name));
- make_decl_rtl (decl, NULL_PTR);
+ make_decl_rtl (decl, NULL);
pushdecl (decl);
DECL_BUILT_IN_CLASS (decl) = class;
DECL_FUNCTION_CODE (decl) = function_code;
{
/* This is a no-op in c-lang.c or something real in objc-actions.c. */
maybe_objc_check_decl (decl);
- rest_of_decl_compilation (decl, NULL_PTR, DECL_CONTEXT (decl) == 0, 0);
+ rest_of_decl_compilation (decl, NULL, DECL_CONTEXT (decl) == 0, 0);
}
/* At the end of a declaration, throw away any variable type sizes
layout_decl (decl, 0);
/* This is a no-op in c-lang.c or something real in objc-actions.c. */
maybe_objc_check_decl (decl);
- rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
+ rest_of_decl_compilation (decl, NULL, toplevel, 0);
if (! toplevel)
expand_decl (decl);
--current_binding_level->n_incomplete;
isn't mentioned in any SETs in NEWPAT that are field assignments. */
if (! combinable_i3pat (NULL_RTX, &newpat, i1dest, NULL_RTX,
- 0, NULL_PTR))
+ 0, (rtx*)0))
{
undo_all ();
return 0;
&& GET_CODE (XEXP (SET_SRC (x), 0)) == REG
&& (pos = exact_log2 (INTVAL (XEXP (SET_SRC (x), 1)))) >= 7
&& GET_CODE (SET_DEST (x)) == REG
- && (split = find_single_use (SET_DEST (x), insn, NULL_PTR)) != 0
+ && (split = find_single_use (SET_DEST (x), insn, (rtx*)0)) != 0
&& (GET_CODE (*split) == EQ || GET_CODE (*split) == NE)
&& XEXP (*split, 0) == SET_DEST (x)
&& XEXP (*split, 1) == const0_rtx)
abort();
emit_move_insn (opcode, insn_after_throw);
- emit_note (NULL_PTR, NOTE_INSN_LOOP_BEG);
+ emit_note (NULL, NOTE_INSN_LOOP_BEG);
emit_label (loop_start);
do_compare_rtx_and_jump (opcode, tocompare, NE, 1,
emit_move_insn (opcode_addr, mem);
emit_move_insn (opcode, gen_rtx_MEM (SImode, opcode_addr));
- emit_note (NULL_PTR, NOTE_INSN_LOOP_CONT);
+ emit_note (NULL, NOTE_INSN_LOOP_CONT);
emit_jump (loop_start);
- emit_note (NULL_PTR, NOTE_INSN_LOOP_END);
+ emit_note (NULL, NOTE_INSN_LOOP_END);
emit_label (loop_exit);
}
#endif /* TARGET_AIX */
/* Create a note marking the start of this region. */
new_region->region_number = ++cfun->eh->last_region_number;
- note = emit_note (NULL_PTR, NOTE_INSN_EH_REGION_BEG);
+ note = emit_note (NULL, NOTE_INSN_EH_REGION_BEG);
NOTE_EH_HANDLER (note) = new_region->region_number;
}
rtx note;
/* Create a nute marking the end of this region. */
- note = emit_note (NULL_PTR, NOTE_INSN_EH_REGION_END);
+ note = emit_note (NULL, NOTE_INSN_EH_REGION_END);
NOTE_EH_HANDLER (note) = cur_region->region_number;
/* Pop. */
|| REGNO (test_addr) < FIRST_PSEUDO_REGISTER)
test_addr = force_reg (Pmode, test_addr);
- emit_note (NULL_PTR, NOTE_INSN_LOOP_BEG);
+ emit_note (NULL, NOTE_INSN_LOOP_BEG);
emit_jump (test_lab);
emit_label (loop_lab);
emit_stack_probe (test_addr);
- emit_note (NULL_PTR, NOTE_INSN_LOOP_CONT);
+ emit_note (NULL, NOTE_INSN_LOOP_CONT);
#ifdef STACK_GROWS_DOWNWARD
#define CMP_OPCODE GTU
emit_cmp_and_jump_insns (test_addr, last_addr, CMP_OPCODE,
NULL_RTX, Pmode, 1, 0, loop_lab);
emit_jump (end_lab);
- emit_note (NULL_PTR, NOTE_INSN_LOOP_END);
+ emit_note (NULL, NOTE_INSN_LOOP_END);
emit_label (end_lab);
emit_stack_probe (last_addr);
DECL_EXTERNAL (fn) = 1;
TREE_PUBLIC (fn) = 1;
DECL_ARTIFICIAL (fn) = 1;
- make_decl_rtl (fn, NULL_PTR);
+ make_decl_rtl (fn, NULL);
assemble_external (fn);
}
DECL_EXTERNAL (fn) = 1;
TREE_PUBLIC (fn) = 1;
DECL_ARTIFICIAL (fn) = 1;
- make_decl_rtl (fn, NULL_PTR);
+ make_decl_rtl (fn, NULL);
assemble_external (fn);
}
{
/* Don't do the optimization if there was an arithmetic error. */
fail:
- set_float_handler (NULL_PTR);
+ set_float_handler (NULL);
return 0;
}
set_float_handler (float_error);
#endif
/* Output the reciprocal and return success flag. */
- set_float_handler (NULL_PTR);
+ set_float_handler (NULL);
*r = y.d;
return 1;
}
optimize_bit_field (x, insn, 0);
if (GET_CODE (SET_SRC (x)) == SIGN_EXTRACT
|| GET_CODE (SET_SRC (x)) == ZERO_EXTRACT)
- optimize_bit_field (x, insn, NULL_PTR);
+ optimize_bit_field (x, insn, 0);
/* For a paradoxical SUBREG inside a ZERO_EXTRACT, load the object
into a register and then store it back out. */
/* Make sure first insn is a note even if we don't want linenums.
This makes sure the first insn will never be deleted.
Also, final expects a note to appear there. */
- emit_note (NULL_PTR, NOTE_INSN_DELETED);
+ emit_note (NULL, NOTE_INSN_DELETED);
/* Set flags used by final.c. */
if (aggregate_value_p (DECL_RESULT (subr)))
The move is supposed to make sdb output more accurate. */
/* Indicate the beginning of the function body,
as opposed to parm setup. */
- emit_note (NULL_PTR, NOTE_INSN_FUNCTION_BEG);
+ emit_note (NULL, NOTE_INSN_FUNCTION_BEG);
if (GET_CODE (get_last_insn ()) != NOTE)
- emit_note (NULL_PTR, NOTE_INSN_DELETED);
+ emit_note (NULL, NOTE_INSN_DELETED);
parm_birth_insn = get_last_insn ();
context_display = 0;
/* After the display initializations is where the tail-recursion label
should go, if we end up needing one. Ensure we have a NOTE here
since some things (like trampolines) get placed before this. */
- tail_recursion_reentry = emit_note (NULL_PTR, NOTE_INSN_DELETED);
+ tail_recursion_reentry = emit_note (NULL, NOTE_INSN_DELETED);
/* Evaluate now the sizes of any types declared among the arguments. */
for (tem = nreverse (get_pending_sizes ()); tem; tem = TREE_CHAIN (tem))
/* Mark the end of the function body.
If control reaches this insn, the function can drop through
without returning a value. */
- emit_note (NULL_PTR, NOTE_INSN_FUNCTION_END);
+ emit_note (NULL, NOTE_INSN_FUNCTION_END);
/* Must mark the last line number note in the function, so that the test
coverage code can avoid counting the last line twice. This just tells
already exists a copy of this note somewhere above. This line number
note is still needed for debugging though, so we can't delete it. */
if (flag_test_coverage)
- emit_note (NULL_PTR, NOTE_INSN_REPEATED_LINE_NUMBER);
+ emit_note (NULL, NOTE_INSN_REPEATED_LINE_NUMBER);
/* Output a linenumber for the end of the function.
SDB depends on this. */
};
#define INIT_STATIC_SPEC(NAME,PTR) \
-{ NAME, NULL_PTR, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
+{ NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
/* List of statically defined specs. */
static struct spec_list static_specs[] =
if (p - 1 - q > 0)
dirs[num_dirs++] = save_string (q, p - 1 - q);
- dirs[num_dirs] = NULL_PTR;
+ dirs[num_dirs] = NULL;
if (ptr_num_dirs)
*ptr_num_dirs = num_dirs;
{
int i = 0;
- while (dirs[i] != NULL_PTR)
+ while (dirs[i] != NULL)
free (dirs[i++]);
free ((char *) dirs);
free_split_directories (prog_dirs);
free_split_directories (bin_dirs);
prog_dirs = bin_dirs = (char **) 0;
- return NULL_PTR;
+ return NULL;
}
}
free_split_directories (prog_dirs);
free_split_directories (bin_dirs);
free_split_directories (prefix_dirs);
- return NULL_PTR;
+ return NULL;
}
/* Build up the pathnames in argv[0]. */
}
else
nstore[endp - startp] = 0;
- add_prefix (&startfile_prefixes, nstore, NULL_PTR,
+ add_prefix (&startfile_prefixes, nstore, NULL,
PREFIX_PRIORITY_LAST, 0, NULL_PTR);
if (*endp == 0)
break;
}
else
nstore[endp - startp] = 0;
- add_prefix (&startfile_prefixes, nstore, NULL_PTR,
+ add_prefix (&startfile_prefixes, nstore, NULL,
PREFIX_PRIORITY_LAST, 0, NULL_PTR);
if (*endp == 0)
break;
&& (IS_DIR_SEPARATOR (value[len - 1])))
{
if (len == 7)
- add_prefix (&include_prefixes, "include", NULL_PTR,
+ add_prefix (&include_prefixes, "include", NULL,
PREFIX_PRIORITY_B_OPT, 0, NULL_PTR);
else
{
char *string = xmalloc (len + 1);
strncpy (string, value, len-7);
strcpy (string+len-7, "include");
- add_prefix (&include_prefixes, string, NULL_PTR,
+ add_prefix (&include_prefixes, string, NULL,
PREFIX_PRIORITY_B_OPT, 0, NULL_PTR);
}
}
}
- add_prefix (&exec_prefixes, value, NULL_PTR,
+ add_prefix (&exec_prefixes, value, NULL,
PREFIX_PRIORITY_B_OPT, 0, &warn_B);
- add_prefix (&startfile_prefixes, value, NULL_PTR,
+ add_prefix (&startfile_prefixes, value, NULL,
PREFIX_PRIORITY_B_OPT, 0, &warn_B);
add_prefix (&include_prefixes, concat (value, "include", NULL),
- NULL_PTR,
- PREFIX_PRIORITY_B_OPT, 0, NULL_PTR);
+ NULL, PREFIX_PRIORITY_B_OPT, 0, NULL_PTR);
n_switches++;
}
break;
add_prefix (&exec_prefixes,
concat (gcc_exec_tooldir_prefix, "bin",
dir_separator_str, NULL),
- NULL_PTR, PREFIX_PRIORITY_LAST, 0, NULL_PTR);
+ NULL, PREFIX_PRIORITY_LAST, 0, NULL_PTR);
add_prefix (&startfile_prefixes,
concat (gcc_exec_tooldir_prefix, "lib",
dir_separator_str, NULL),
- NULL_PTR, PREFIX_PRIORITY_LAST, 0, NULL_PTR);
+ NULL, PREFIX_PRIORITY_LAST, 0, NULL_PTR);
}
tooldir_prefix = concat (standard_exec_prefix, spec_machine,
input_from_pipe = 0;
suffix_subst = NULL;
- value = do_spec_1 (spec, 0, NULL_PTR);
+ value = do_spec_1 (spec, 0, NULL);
/* Force out any unfinished command.
If -pipe, this forces out the last command if it ended in `|'. */
strcat (buffer, machine_suffix);
if (is_directory (buffer, multilib_dir, 1))
{
- do_spec_1 ("-L", 0, NULL_PTR);
+ do_spec_1 ("-L", 0, NULL);
#ifdef SPACE_AFTER_L_OPTION
- do_spec_1 (" ", 0, NULL_PTR);
+ do_spec_1 (" ", 0, NULL);
#endif
- do_spec_1 (buffer, 1, NULL_PTR);
- do_spec_1 (multilib_dir, 1, NULL_PTR);
+ do_spec_1 (buffer, 1, NULL);
+ do_spec_1 (multilib_dir, 1, NULL);
/* Make this a separate argument. */
- do_spec_1 (" ", 0, NULL_PTR);
+ do_spec_1 (" ", 0, NULL);
}
}
if (!pl->require_machine_suffix)
{
if (is_directory (pl->prefix, multilib_dir, 1))
{
- do_spec_1 ("-L", 0, NULL_PTR);
+ do_spec_1 ("-L", 0, NULL);
#ifdef SPACE_AFTER_L_OPTION
- do_spec_1 (" ", 0, NULL_PTR);
+ do_spec_1 (" ", 0, NULL);
#endif
- do_spec_1 (pl->prefix, 1, NULL_PTR);
- do_spec_1 (multilib_dir, 1, NULL_PTR);
+ do_spec_1 (pl->prefix, 1, NULL);
+ do_spec_1 (multilib_dir, 1, NULL);
/* Make this a separate argument. */
- do_spec_1 (" ", 0, NULL_PTR);
+ do_spec_1 (" ", 0, NULL);
}
}
}
{
if (is_directory (pl->prefix, machine_suffix, 1))
{
- do_spec_1 ("-L", 0, NULL_PTR);
+ do_spec_1 ("-L", 0, NULL);
#ifdef SPACE_AFTER_L_OPTION
- do_spec_1 (" ", 0, NULL_PTR);
+ do_spec_1 (" ", 0, NULL);
#endif
- do_spec_1 (pl->prefix, 1, NULL_PTR);
+ do_spec_1 (pl->prefix, 1, NULL);
/* Remove slash from machine_suffix. */
if (strlen (machine_suffix) >= bufsize)
bufsize = strlen (machine_suffix) * 2 + 1;
idx = strlen (buffer);
if (IS_DIR_SEPARATOR (buffer[idx - 1]))
buffer[idx - 1] = 0;
- do_spec_1 (buffer, 1, NULL_PTR);
+ do_spec_1 (buffer, 1, NULL);
/* Make this a separate argument. */
- do_spec_1 (" ", 0, NULL_PTR);
+ do_spec_1 (" ", 0, NULL);
}
}
if (!pl->require_machine_suffix)
{
if (is_directory (pl->prefix, "", 1))
{
- do_spec_1 ("-L", 0, NULL_PTR);
+ do_spec_1 ("-L", 0, NULL);
#ifdef SPACE_AFTER_L_OPTION
- do_spec_1 (" ", 0, NULL_PTR);
+ do_spec_1 (" ", 0, NULL);
#endif
/* Remove slash from pl->prefix. */
if (strlen (pl->prefix) >= bufsize)
idx = strlen (buffer);
if (IS_DIR_SEPARATOR (buffer[idx - 1]))
buffer[idx - 1] = 0;
- do_spec_1 (buffer, 1, NULL_PTR);
+ do_spec_1 (buffer, 1, NULL);
/* Make this a separate argument. */
- do_spec_1 (" ", 0, NULL_PTR);
+ do_spec_1 (" ", 0, NULL);
}
}
}
if (gcc_exec_prefix)
{
- do_spec_1 ("-iprefix", 1, NULL_PTR);
+ do_spec_1 ("-iprefix", 1, NULL);
/* Make this a separate argument. */
- do_spec_1 (" ", 0, NULL_PTR);
- do_spec_1 (gcc_exec_prefix, 1, NULL_PTR);
- do_spec_1 (" ", 0, NULL_PTR);
+ do_spec_1 (" ", 0, NULL);
+ do_spec_1 (gcc_exec_prefix, 1, NULL);
+ do_spec_1 (" ", 0, NULL);
}
for (; pl; pl = pl->next)
{
- do_spec_1 ("-isystem", 1, NULL_PTR);
+ do_spec_1 ("-isystem", 1, NULL);
/* Make this a separate argument. */
- do_spec_1 (" ", 0, NULL_PTR);
- do_spec_1 (pl->prefix, 1, NULL_PTR);
- do_spec_1 (" ", 0, NULL_PTR);
+ do_spec_1 (" ", 0, NULL);
+ do_spec_1 (pl->prefix, 1, NULL);
+ do_spec_1 (" ", 0, NULL);
}
}
break;
case 'X':
for (i = 0; i < n_linker_options; i++)
{
- do_spec_1 (linker_options[i], 1, NULL_PTR);
+ do_spec_1 (linker_options[i], 1, NULL);
/* Make each accumulated option a separate argument. */
- do_spec_1 (" ", 0, NULL_PTR);
+ do_spec_1 (" ", 0, NULL);
}
break;
case 'Y':
for (i = 0; i < n_assembler_options; i++)
{
- do_spec_1 (assembler_options[i], 1, NULL_PTR);
+ do_spec_1 (assembler_options[i], 1, NULL);
/* Make each accumulated option a separate argument. */
- do_spec_1 (" ", 0, NULL_PTR);
+ do_spec_1 (" ", 0, NULL);
}
break;
case 'Z':
for (i = 0; i < n_preprocessor_options; i++)
{
- do_spec_1 (preprocessor_options[i], 1, NULL_PTR);
+ do_spec_1 (preprocessor_options[i], 1, NULL);
/* Make each accumulated option a separate argument. */
- do_spec_1 (" ", 0, NULL_PTR);
+ do_spec_1 (" ", 0, NULL);
}
break;
a certain constant string as a spec. */
case '1':
- value = do_spec_1 (cc1_spec, 0, NULL_PTR);
+ value = do_spec_1 (cc1_spec, 0, NULL);
if (value != 0)
return value;
break;
case '2':
- value = do_spec_1 (cc1plus_spec, 0, NULL_PTR);
+ value = do_spec_1 (cc1plus_spec, 0, NULL);
if (value != 0)
return value;
break;
case 'a':
- value = do_spec_1 (asm_spec, 0, NULL_PTR);
+ value = do_spec_1 (asm_spec, 0, NULL);
if (value != 0)
return value;
break;
case 'A':
- value = do_spec_1 (asm_final_spec, 0, NULL_PTR);
+ value = do_spec_1 (asm_final_spec, 0, NULL);
if (value != 0)
return value;
break;
case 'c':
- value = do_spec_1 (signed_char_spec, 0, NULL_PTR);
+ value = do_spec_1 (signed_char_spec, 0, NULL);
if (value != 0)
return value;
break;
= (input_file_compiler->cpp_spec
? input_file_compiler->cpp_spec
: cpp_spec);
- value = do_spec_1 (spec, 0, NULL_PTR);
+ value = do_spec_1 (spec, 0, NULL);
if (value != 0)
return value;
}
break;
case 'E':
- value = do_spec_1 (endfile_spec, 0, NULL_PTR);
+ value = do_spec_1 (endfile_spec, 0, NULL);
if (value != 0)
return value;
break;
case 'l':
- value = do_spec_1 (link_spec, 0, NULL_PTR);
+ value = do_spec_1 (link_spec, 0, NULL);
if (value != 0)
return value;
break;
case 'L':
- value = do_spec_1 (lib_spec, 0, NULL_PTR);
+ value = do_spec_1 (lib_spec, 0, NULL);
if (value != 0)
return value;
break;
case 'G':
- value = do_spec_1 (libgcc_spec, 0, NULL_PTR);
+ value = do_spec_1 (libgcc_spec, 0, NULL);
if (value != 0)
return value;
break;
*x = 0;
- value = do_spec_1 (buf, 0, NULL_PTR);
+ value = do_spec_1 (buf, 0, NULL);
if (value != 0)
return value;
}
*x = 0;
- value = do_spec_1 (buf, 0, NULL_PTR);
+ value = do_spec_1 (buf, 0, NULL);
if (value != 0)
return value;
}
break;
case 'S':
- value = do_spec_1 (startfile_spec, 0, NULL_PTR);
+ value = do_spec_1 (startfile_spec, 0, NULL);
if (value != 0)
return value;
break;
case '*':
if (soft_matched_part)
{
- do_spec_1 (soft_matched_part, 1, NULL_PTR);
- do_spec_1 (" ", 0, NULL_PTR);
+ do_spec_1 (soft_matched_part, 1, NULL);
+ do_spec_1 (" ", 0, NULL);
}
else
/* Catch the case where a spec string contains something like
{
if (c == '(')
{
- value = do_spec_1 (name, 0, NULL_PTR);
+ value = do_spec_1 (name, 0, NULL);
if (value != 0)
return value;
}
}
*x = 0;
- value = do_spec_1 (buf, 0, NULL_PTR);
+ value = do_spec_1 (buf, 0, NULL);
if (value != 0)
return value;
}
case '|':
if (input_from_pipe)
- do_spec_1 ("-", 0, NULL_PTR);
+ do_spec_1 ("-", 0, NULL);
break;
default:
abort ();
if (negate != found
- && do_spec_1 (save_string (body, endbody-body-1), 0, NULL_PTR) < 0)
+ && do_spec_1 (save_string (body, endbody-body-1), 0, NULL) < 0)
return 0;
}
else if (p[-1] == '*' && (p[0] == '}' || p[0] == '&'))
{
/* Here if a %{|...} conditional fails: output a minus sign,
which means "standard output" or "standard input". */
- do_spec_1 ("-", 0, NULL_PTR);
+ do_spec_1 ("-", 0, NULL);
return endbody;
}
}
else if (true_once)
{
if (do_spec_1 (save_string (body, endbody - body - 1),
- 0, NULL_PTR) < 0)
+ 0, NULL) < 0)
return 0;
}
if (!omit_first_word)
{
- do_spec_1 ("-", 0, NULL_PTR);
- do_spec_1 (switches[switchnum].part1, 1, NULL_PTR);
+ do_spec_1 ("-", 0, NULL);
+ do_spec_1 (switches[switchnum].part1, 1, NULL);
}
if (switches[switchnum].args != 0)
const char *arg = *p;
if (include_blanks)
- do_spec_1 (" ", 0, NULL_PTR);
+ do_spec_1 (" ", 0, NULL);
if (suffix_subst)
{
unsigned length = strlen (arg);
((char *)arg)[length] = 0;
break;
}
- do_spec_1 (arg, 1, NULL_PTR);
+ do_spec_1 (arg, 1, NULL);
if (!arg[length])
{
((char *)arg)[length] = '.';
- do_spec_1 (suffix_subst, 1, NULL_PTR);
+ do_spec_1 (suffix_subst, 1, NULL);
}
}
else
- do_spec_1 (arg, 1, NULL_PTR);
+ do_spec_1 (arg, 1, NULL);
}
}
- do_spec_1 (" ", 0, NULL_PTR);
+ do_spec_1 (" ", 0, NULL);
switches[switchnum].validated = 1;
}
\f
add_prefix (&startfile_prefixes,
concat (gcc_exec_prefix, machine_suffix,
standard_startfile_prefix, NULL),
- NULL_PTR, PREFIX_PRIORITY_LAST, 0, NULL_PTR);
+ NULL, PREFIX_PRIORITY_LAST, 0, NULL_PTR);
add_prefix (&startfile_prefixes,
concat (standard_exec_prefix,
machine_suffix,
standard_startfile_prefix, NULL),
- NULL_PTR, PREFIX_PRIORITY_LAST, 0, NULL_PTR);
+ NULL, PREFIX_PRIORITY_LAST, 0, NULL_PTR);
}
add_prefix (&startfile_prefixes, standard_startfile_prefix_1,
add_prefix (&startfile_prefixes, standard_startfile_prefix_2,
"BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL_PTR);
#if 0 /* Can cause surprises, and one can use -B./ instead. */
- add_prefix (&startfile_prefixes, "./", NULL_PTR,
+ add_prefix (&startfile_prefixes, "./", NULL,
PREFIX_PRIORITY_LAST, 1, NULL_PTR);
#endif
}
/* An alias entry maps a suffix to a language.
Search for the language; pass 0 for NAME and LENGTH
to avoid infinite recursion if language not found. */
- return lookup_compiler (NULL_PTR, 0, cp->spec + 1);
+ return lookup_compiler (NULL, 0, cp->spec + 1);
}
return 0;
}
pass, pass > 1 ? "es" : "", max_pass_bytes);
}
- obstack_free (&gcse_obstack, NULL_PTR);
+ obstack_free (&gcse_obstack, NULL);
free_reg_set_mem ();
/* We are finished with alias. */
end_alias_analysis ();
free_reg_set_mem ()
{
free (reg_set_table);
- obstack_free (®_set_obstack, NULL_PTR);
+ obstack_free (®_set_obstack, NULL);
}
/* Record REGNO in the reg_set table. */
insn that can be used as an insertion point. */
map->insns_at_start = get_last_insn ();
if (map->insns_at_start == 0)
- map->insns_at_start = emit_note (NULL_PTR, NOTE_INSN_DELETED);
+ map->insns_at_start = emit_note (NULL, NOTE_INSN_DELETED);
map->regno_pointer_align = inl_f->emit->regno_pointer_align;
map->x_regno_reg_rtx = inl_f->emit->x_regno_reg_rtx;
record_giv (loop, v, p, src_reg, dest_reg, mult_val, add_val,
ext_val, benefit, DEST_REG, not_every_iteration,
- maybe_multiple, NULL_PTR);
+ maybe_multiple, (rtx*)0);
}
}
const struct loop *loop;
rtx x;
{
- rtx comparison = get_condition (x, NULL_PTR);
+ rtx comparison = get_condition (x, (rtx*)0);
if (comparison == 0
|| ! loop_invariant_p (loop, XEXP (comparison, 0))
if (flag_traditional && TAG_MSGSEND[0] != '_')
DECL_BUILT_IN_NONANSI (umsg_decl) = 1;
- make_decl_rtl (umsg_decl, NULL_PTR);
+ make_decl_rtl (umsg_decl, NULL);
pushdecl (umsg_decl);
}
else
rtx insn;
{
if (INSN_CODE (insn) < 0)
- INSN_CODE (insn) = recog (PATTERN (insn), insn, NULL_PTR);
+ INSN_CODE (insn) = recog (PATTERN (insn), insn, 0);
return INSN_CODE (insn);
}
\f
int icode = recog (pat, insn,
(GET_CODE (pat) == SET
&& ! reload_completed && ! reload_in_progress)
- ? &num_clobbers : NULL_PTR);
+ ? &num_clobbers : 0);
int is_asm = icode < 0 && asm_noperands (PATTERN (insn)) >= 0;
case SET:
{
- rtx *src1 = (rtx *) NULL_PTR, *src2;
+ rtx *src1 = (rtx *) 0, *src2;
rtx src1_note, src2_note;
rtx pat_src;
: type == RELOAD_FOR_OUTPUT ? RELOAD_FOR_OUTPUT_ADDRESS
: RELOAD_OTHER);
- find_reloads_address (mode, NULL_PTR, XEXP (loc, 0), &XEXP (loc, 0),
+ find_reloads_address (mode, (rtx*)0, XEXP (loc, 0), &XEXP (loc, 0),
opnum, type, 0, 0);
}
order as the reloads. Thus if the outer reload is also of type
RELOAD_OTHER, we are guaranteed that this inner reload will be
output before the outer reload. */
- push_reload (SUBREG_REG (in), NULL_RTX, &SUBREG_REG (in), NULL_PTR,
+ push_reload (SUBREG_REG (in), NULL_RTX, &SUBREG_REG (in), (rtx*)0,
find_valid_class (inmode,
subreg_regno_offset (REGNO (SUBREG_REG (in)),
GET_MODE (SUBREG_REG (in)),
unsigned int regno = REGNO (in) + in_offset;
unsigned int nwords = HARD_REGNO_NREGS (regno, inmode);
- if (! refers_to_regno_for_reload_p (regno, regno + nwords, out, NULL_PTR)
+ if (! refers_to_regno_for_reload_p (regno, regno + nwords, out, (rtx*)0)
&& ! hard_reg_set_here_p (regno, regno + nwords,
PATTERN (this_insn))
&& (! earlyclobber
struct decomposition xdata;
if (ydata.reg_flag)
- return !refers_to_regno_for_reload_p (ydata.start, ydata.end, x, NULL_PTR);
+ return !refers_to_regno_for_reload_p (ydata.start, ydata.end, x, (rtx*)0);
if (ydata.safe)
return 1;
;
else if (constraints[i][0] == 'p')
{
- find_reloads_address (VOIDmode, NULL_PTR,
+ find_reloads_address (VOIDmode, (rtx*)0,
recog_data.operand[i],
recog_data.operand_loc[i],
i, operand_type[i], ind_levels, insn);
{
operand_reloadnum[i]
= push_reload (XEXP (recog_data.operand[i], 0), NULL_RTX,
- &XEXP (recog_data.operand[i], 0), NULL_PTR,
+ &XEXP (recog_data.operand[i], 0), (rtx*)0,
BASE_REG_CLASS,
GET_MODE (XEXP (recog_data.operand[i], 0)),
VOIDmode, 0, 0, i, RELOAD_FOR_INPUT);
calculate the register number as :
SUBREG_BYTE (x) / GET_MODE_SIZE (subreg_mode) */
if (is_set_dest)
- push_reload (NULL_RTX, SUBREG_REG (x), NULL_PTR, &SUBREG_REG (x),
+ push_reload (NULL_RTX, SUBREG_REG (x), (rtx*)0, &SUBREG_REG (x),
find_valid_class (subreg_mode,
SUBREG_BYTE (x) / GET_MODE_SIZE (subreg_mode)),
VOIDmode, subreg_mode, 0, 0, opnum, type);
else
- push_reload (SUBREG_REG (x), NULL_RTX, &SUBREG_REG (x), NULL_PTR,
+ push_reload (SUBREG_REG (x), NULL_RTX, &SUBREG_REG (x), (rtx*)0,
find_valid_class (subreg_mode,
SUBREG_BYTE (x) / GET_MODE_SIZE (subreg_mode)),
subreg_mode, VOIDmode, 0, 0, opnum, type);
tem = make_memloc (ad, regno);
if (! strict_memory_address_p (GET_MODE (tem), XEXP (tem, 0)))
{
- find_reloads_address (GET_MODE (tem), NULL_PTR, XEXP (tem, 0),
+ find_reloads_address (GET_MODE (tem), (rtx*)0, XEXP (tem, 0),
&XEXP (tem, 0), opnum, ADDR_TYPE (type),
ind_levels, insn);
}
return 0;
/* If we do not have one of the cases above, we must do the reload. */
- push_reload (ad, NULL_RTX, loc, NULL_PTR, BASE_REG_CLASS,
+ push_reload (ad, NULL_RTX, loc, (rtx*)0, BASE_REG_CLASS,
GET_MODE (ad), VOIDmode, 0, 0, opnum, type);
return 1;
}
{
/* Must use TEM here, not AD, since it is the one that will
have any subexpressions reloaded, if needed. */
- push_reload (tem, NULL_RTX, loc, NULL_PTR,
+ push_reload (tem, NULL_RTX, loc, (rtx*)0,
BASE_REG_CLASS, GET_MODE (tem),
VOIDmode, 0,
0, opnum, type);
else
{
reloadnum
- = push_reload (x, NULL_RTX, loc, NULL_PTR,
+ = push_reload (x, NULL_RTX, loc, (rtx*)0,
(context ? INDEX_REG_CLASS : BASE_REG_CLASS),
GET_MODE (x), GET_MODE (x), 0, 0,
opnum, type);
XEXP (XEXP (x, 0), 0), &XEXP (XEXP (x, 0), 0),
opnum, type, ind_levels, insn);
- reloadnum = push_reload (x, NULL_RTX, loc, NULL_PTR,
+ reloadnum = push_reload (x, NULL_RTX, loc, (rtx*)0,
(context ? INDEX_REG_CLASS : BASE_REG_CLASS),
GET_MODE (x), VOIDmode, 0, 0, opnum, type);
rld[reloadnum].inc
find_reloads_address (GET_MODE (x), loc, XEXP (x, 0), &XEXP (x, 0),
opnum, ADDR_TYPE (type), ind_levels, insn);
- push_reload (*loc, NULL_RTX, loc, NULL_PTR,
+ push_reload (*loc, NULL_RTX, loc, (rtx*)0,
(context ? INDEX_REG_CLASS : BASE_REG_CLASS),
GET_MODE (x), VOIDmode, 0, 0, opnum, type);
return 1;
that feeds this insn. */
if (reg_equiv_mem[regno] != 0)
{
- push_reload (reg_equiv_mem[regno], NULL_RTX, loc, NULL_PTR,
+ push_reload (reg_equiv_mem[regno], NULL_RTX, loc, (rtx*)0,
(context ? INDEX_REG_CLASS : BASE_REG_CLASS),
GET_MODE (x), VOIDmode, 0, 0, opnum, type);
return 1;
|| !(context ? REGNO_OK_FOR_INDEX_P (regno)
: REGNO_MODE_OK_FOR_BASE_P (regno, mode))))
{
- push_reload (x, NULL_RTX, loc, NULL_PTR,
+ push_reload (x, NULL_RTX, loc, (rtx*)0,
(context ? INDEX_REG_CLASS : BASE_REG_CLASS),
GET_MODE (x), VOIDmode, 0, 0, opnum, type);
return 1;
from before this insn to after it. */
if (regno_clobbered_p (regno, this_insn, GET_MODE (x), 0))
{
- push_reload (x, NULL_RTX, loc, NULL_PTR,
+ push_reload (x, NULL_RTX, loc, (rtx*)0,
(context ? INDEX_REG_CLASS : BASE_REG_CLASS),
GET_MODE (x), VOIDmode, 0, 0, opnum, type);
return 1;
if (! (context ? REGNO_OK_FOR_INDEX_P (regno)
: REGNO_MODE_OK_FOR_BASE_P (regno, mode)))
{
- push_reload (x, NULL_RTX, loc, NULL_PTR,
+ push_reload (x, NULL_RTX, loc, (rtx*)0,
(context ? INDEX_REG_CLASS : BASE_REG_CLASS),
GET_MODE (x), VOIDmode, 0, 0, opnum, type);
return 1;
{
x = find_reloads_subreg_address (x, 0, opnum, type,
ind_levels, insn);
- push_reload (x, NULL_RTX, loc, NULL_PTR, class,
+ push_reload (x, NULL_RTX, loc, (rtx*)0, class,
GET_MODE (x), VOIDmode, 0, 0, opnum, type);
return 1;
}
opnum, type, ind_levels, 0);
}
- push_reload (x, NULL_RTX, loc, NULL_PTR, class,
+ push_reload (x, NULL_RTX, loc, (rtx*)0, class,
mode, VOIDmode, 0, 0, opnum, type);
}
\f
if (reg_equiv_memory_loc[r])
return refers_to_regno_for_reload_p (regno, endregno,
reg_equiv_memory_loc[r],
- NULL_PTR);
+ (rtx*)0);
if (reg_equiv_constant[r])
return 0;
endregno = regno + (regno < FIRST_PSEUDO_REGISTER
? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
- return refers_to_regno_for_reload_p (regno, endregno, in, NULL_PTR);
+ return refers_to_regno_for_reload_p (regno, endregno, in, (rtx*)0);
}
/* Return nonzero if anything in X contains a MEM. Look also for pseudo
&& refers_to_regno_for_reload_p (valueno,
(valueno
+ HARD_REGNO_NREGS (valueno, mode)),
- goal, NULL_PTR))
+ goal, (rtx*)0))
return 0;
/* Reject registers that overlap GOAL. */
/* Make sure that the last insn in the chain
is not something that needs reloading. */
- emit_note (NULL_PTR, NOTE_INSN_DELETED);
+ emit_note (NULL, NOTE_INSN_DELETED);
/* Enable find_equiv_reg to distinguish insns made by reload. */
reload_first_uid = get_max_uid ();
}
x = CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
- set_float_handler (NULL_PTR);
+ set_float_handler (NULL);
return x;
}
abort ();
}
- set_float_handler (NULL_PTR);
+ set_float_handler (NULL);
val = trunc_int_for_mode (val, mode);
#endif
value = real_value_truncate (mode, value);
- set_float_handler (NULL_PTR);
+ set_float_handler (NULL);
return CONST_DOUBLE_FROM_REAL_VALUE (value, mode);
}
#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
REAL_VALUE_FROM_CONST_DOUBLE (d, op1);
op1is2 = REAL_VALUES_EQUAL (d, dconst2);
op1ism1 = REAL_VALUES_EQUAL (d, dconstm1);
- set_float_handler (NULL_PTR);
+ set_float_handler (NULL);
/* x*2 is x+x and x*(-1) is -x */
if (op1is2 && GET_MODE (op0) == mode)
}
start_sequence ();
- start = emit_note (NULL_PTR, NOTE_INSN_BLOCK_BEG);
+ start = emit_note (NULL, NOTE_INSN_BLOCK_BEG);
if (cfun->x_whole_function_mode_p)
NOTE_BLOCK (start) = block;
- fixup->before_jump = emit_note (NULL_PTR, NOTE_INSN_DELETED);
- end = emit_note (NULL_PTR, NOTE_INSN_BLOCK_END);
+ fixup->before_jump = emit_note (NULL, NOTE_INSN_DELETED);
+ end = emit_note (NULL, NOTE_INSN_BLOCK_END);
if (cfun->x_whole_function_mode_p)
NOTE_BLOCK (end) = block;
fixup->context = block;
do_pending_stack_adjust ();
emit_queue ();
- emit_note (NULL_PTR, NOTE_INSN_LOOP_BEG);
+ emit_note (NULL, NOTE_INSN_LOOP_BEG);
emit_label (thisloop->data.loop.start_label);
return thisloop;
expand_loop_continue_here ()
{
do_pending_stack_adjust ();
- emit_note (NULL_PTR, NOTE_INSN_LOOP_CONT);
+ emit_note (NULL, NOTE_INSN_LOOP_CONT);
emit_label (loop_stack->data.loop.continue_label);
}
if (needs_end_jump)
{
emit_jump (start_label);
- emit_note (NULL_PTR, NOTE_INSN_LOOP_END);
+ emit_note (NULL, NOTE_INSN_LOOP_END);
}
emit_label (loop_stack->data.loop.end_label);
/* Create a note to mark the beginning of the block. */
if (block_flag)
{
- note = emit_note (NULL_PTR, NOTE_INSN_BLOCK_BEG);
+ note = emit_note (NULL, NOTE_INSN_BLOCK_BEG);
NOTE_BLOCK (note) = block;
}
else
- note = emit_note (NULL_PTR, NOTE_INSN_DELETED);
+ note = emit_note (NULL, NOTE_INSN_DELETED);
/* Make an entry on block_stack for the block we are entering. */
fix this is to just insert another instruction here, so that the
instructions inserted after the last unconditional cleanup are
never the last instruction. */
- emit_note (NULL_PTR, NOTE_INSN_DELETED);
+ emit_note (NULL, NOTE_INSN_DELETED);
thisblock->data.block.cleanup_ptr = &thisblock->data.block.cleanups;
if (block_stack
if (mark_ends)
{
- rtx note = emit_note (NULL_PTR, NOTE_INSN_BLOCK_END);
+ rtx note = emit_note (NULL, NOTE_INSN_BLOCK_END);
NOTE_BLOCK (note) = NOTE_BLOCK (thisblock->data.block.first_insn);
}
else
fix this is to just insert another instruction here, so that the
instructions inserted after the last unconditional cleanup are
never the last instruction. */
- emit_note (NULL_PTR, NOTE_INSN_DELETED);
+ emit_note (NULL, NOTE_INSN_DELETED);
thisblock->data.block.cleanup_ptr = &thisblock->data.block.cleanups;
}
}
/* Make sure case_stmt.start points to something that won't
need any transformation before expand_end_case. */
if (GET_CODE (get_last_insn ()) != NOTE)
- emit_note (NULL_PTR, NOTE_INSN_DELETED);
+ emit_note (NULL, NOTE_INSN_DELETED);
thiscase->data.case_stmt.start = get_last_insn ();
abort ();
}
- set_float_handler (NULL_PTR);
+ set_float_handler (NULL);
}
\f
/* Here we combine duplicate floating constants to make
/* We must force creation of DECL_RTL for debug info generation, even though
we don't use it here. */
- make_decl_rtl (decl, NULL_PTR);
+ make_decl_rtl (decl, NULL);
name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
projects / platform / upstream / linaro-gcc.git / commitdiff