2006-01-31 Marcin Dalecki <martin@dalecki.de>

	* tree-vrp.c: Use XNEW/XCNEW allocation wrappers.
	* regrename.c: Ditto.
	* tree-ssa-loop-im.c: Ditto.
	* tree-dump.c: Ditto.
	* tree-complex.c: Ditto.
	* genrecog.c: Ditto.
	* tree-ssa-threadupdate.c: Ditto.
	* tracer.c: Ditto.
	* java/class.c: Ditto.
	* java/jcf-parse.c: Ditto.
	* java/resource.c: Ditto.
	* java/except.c: Ditto.
	* java/jvspec.c: Ditto.
	* java/jcf-write.c: Ditto.
	* java/jcf-path.c: Ditto.
	* java/gjavah.c: Ditto.
	* java/zextract.c: Ditto.
	* java/jcf-io.c: Ditto.
	* java/jcf.h: Ditto.
	* java/buffer.c: Ditto.
	* java/lang.c: Ditto.
	* java/parse-scan.y: Ditto.
	* java/lex.c: Ditto.
	* java/lex.h: Ditto.
	* cfgloopmanip.c: Ditto.
	* postreload-gcse.c: Ditto.
	* tree-ssa-loop-manip.c: Ditto.
	* postreload.c: Ditto.
	* tree-ssa-loop-ch.c: Ditto.
	* loop.c: Ditto.
	* ipa-cp.c: Ditto.
	* cppspec.c: Ditto.
	* diagnostic.c: Ditto.
	* final.c: Ditto.
	* genoutput.c: Ditto.
	* gcc.c: Ditto.
	* cfghooks.c: Ditto.
	* cfgloopanal.c: Ditto.
	* objc/objc-act.c: Ditto.
	* gcov.c: Ditto.
	* genextract.c: Ditto.
	* genautomata.c: Ditto.
	* pretty-print.c: Ditto.
	* genemit.c: Ditto.
	* cgraphunit.c: Ditto.
	* flow.c: Ditto.
	* df-scan.c: Ditto.
	* haifa-sched.c: Ditto.
	* dominance.c: Ditto.
	* dbxout.c: Ditto.
	* tree-ssa-loop-ivopts.c: Ditto.
	* df-core.c: Ditto.
	* mode-switching.c: Ditto.
	* modulo-sched.c: Ditto.
	* graph.c: Ditto.
	* ipa-pure-const.c: Ditto.
	* cse.c: Ditto.
	* fix-header.c: Ditto.
	* web.c: Ditto.
	* tree-stdarg.c: Ditto.
	* ipa-utils.c: Ditto.
	* loop-init.c: Ditto.
	* ipa-inline.c: Ditto.
	* cfganal.c: Ditto.
	* global.c: Ditto.
	* alloc-pool.c: Ditto.
	* dwarf2out.c: Ditto.
	* opts.c: Ditto.
	* genattrtab.c: Ditto.
	* tree-ssa-loop-ivcanon.c: Ditto.
	* predict.c: Ditto.
	* timevar.c: Ditto.
	* lcm.c: Ditto.
	* fortran/gfortranspec.c: Ditto.
	* regmove.c: Ditto.
	* local-alloc.c: Ditto.
	* langhooks.c: Ditto.
	* function.c: Ditto.
	* tree-vectorizer.c: Ditto.
	* gcse.c: Ditto.
	* ipa-type-escape.c: Ditto.
	* alias.c: Ditto.
	* tree-if-conv.c: Ditto.
	* profile.c: Ditto.
	* ipa.c: Ditto.
	* tree-data-ref.c: Ditto.
	* loop-unroll.c: Ditto.
	* treelang/treetree.c: Ditto.
	* calls.c: Ditto.
	* bt-load.c: Ditto.
	* ggc-common.c: Ditto.
	* except.c: Ditto.
	* coverage.c: Ditto.
	* cselib.c: Ditto.
	* tree-cfgcleanup.c: Ditto.
	* tree-ssa-pre.c: Ditto.
	* cfgcleanup.c: Ditto.
	* loop-invariant.c: Ditto.
	* loop-iv.c: Ditto.
	* ipa-prop.c: Ditto.
	* print-tree.c: Ditto.
	* conflict.c: Ditto.
	* ggc-page.c: Ditto.
	* sched-deps.c: Ditto.
	* regclass.c: Ditto.
	* tree-object-size.c: Ditto.
	* combine.c: Ditto.
	* bb-reorder.c: Ditto.
	* resource.c: Ditto.
	* var-tracking.c: Ditto.
	* cfgloop.c: Ditto.
	* df-problems.c: Ditto.
	* reg-stack.c: Ditto.
	* tlink.c: Ditto.
	* gccspec.c: Ditto.
	* sched-rgn.c: Ditto.
	* tree-ssa-structalias.c: Ditto.
	* tree-ssa-reassoc.c: Ditto.
	* config/darwin-c.c: Ditto.
	* config/darwin.c: Ditto.
	* config/arm/arm.c: Ditto.
	* cfgrtl.c: Ditto.
	* collect2.c: Ditto.
	* reload1.c: Ditto.



git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@110446 138bc75d-0d04-0410-961f-82ee72b054a4

16 files changed, 61 insertions, 63 deletions

diff --git a/gcc/java/buffer.c b/gcc/java/buffer.c
index 1d5e282b229..996dac78585 100644
--- a/gcc/java/buffer.c
+++ b/gcc/java/buffer.c
@@ -37,7 +37,7 @@ buffer_grow (struct buffer *bufp, int size)
     {
       if (size < 120)
 	size = 120;
-      bufp->data = xmalloc (size);
+      bufp->data = XNEWVEC (unsigned char, size);
       bufp->ptr = bufp->data;
     }
   else
diff --git a/gcc/java/class.c b/gcc/java/class.c
index ff2c1eb5128..c09ed5c5314 100644
--- a/gcc/java/class.c
+++ b/gcc/java/class.c
@@ -156,7 +156,7 @@ add_class_flag (class_flag_node **rootp, const char *ident, int value)
 
   if (NULL == root)
     {
-      root = xmalloc (sizeof (class_flag_node));
+      root = XNEW (class_flag_node);
       root->ident = "";
       root->value = 0;
       root->sibling = NULL;
@@ -183,7 +183,7 @@ add_class_flag (class_flag_node **rootp, const char *ident, int value)
   else
     {
       /* Insert new node into the tree.  */
-      node = xmalloc (sizeof (class_flag_node));
+      node = XNEW (class_flag_node);
 
       node->ident = xstrdup (ident);
       node->value = value;
diff --git a/gcc/java/except.c b/gcc/java/except.c
index 048a92fc802..2354a6d0794 100644
--- a/gcc/java/except.c
+++ b/gcc/java/except.c
@@ -211,7 +211,7 @@ split_range (struct eh_range *range, int pc)
     }
 
   /* Create a new range.  */
-  h = xmalloc (sizeof (struct eh_range));
+  h = XNEW (struct eh_range);
 
   h->start_pc = pc;
   h->end_pc = range->end_pc;
@@ -289,7 +289,7 @@ add_handler (int start_pc, int end_pc, tree handler, tree type)
     }
 
   /* Create the new range.  */
-  h = xmalloc (sizeof (struct eh_range));
+  h = XNEW (struct eh_range);
   first_child = &h->first_child;
 
   h->start_pc = start_pc;
diff --git a/gcc/java/gjavah.c b/gcc/java/gjavah.c
index 35bcdea386c..8c9884b96fa 100644
--- a/gcc/java/gjavah.c
+++ b/gcc/java/gjavah.c
@@ -600,7 +600,7 @@ cxx_keyword_subst (const unsigned char *str, int length)
 	     are `$'.  */
 	  if (i == length)
 	    {
-	      char *dup = xmalloc (2 + length - min_length + kwl);
+	      char *dup = XNEWVEC (char, 2 + length - min_length + kwl);
 	      strcpy (dup, cxx_keywords[mid]);
 	      for (i = kwl; i < length + 1; ++i)
 		dup[i] = '$';
@@ -719,7 +719,7 @@ get_field_name (JCF *jcf, int name_index, JCF_u2 flags)
 	  return NULL;
 	}
 
-      override = xmalloc (length + 3);
+      override = XNEWVEC (char, length + 3);
       memcpy (override, name, length);
       strcpy (override + length, "__");
     }
@@ -929,13 +929,13 @@ print_method_info (FILE *stream, JCF* jcf, int name_index, int sig_index,
     {
       struct method_name *nn;
 
-      nn = xmalloc (sizeof (struct method_name));
-      nn->name = xmalloc (length);
+      nn = XNEW (struct method_name);
+      nn->name = XNEWVEC (unsigned char, length);
       memcpy (nn->name, str, length);
       nn->length = length;
       nn->next = method_name_list;
       nn->sig_length = JPOOL_UTF_LENGTH (jcf, sig_index);
-      nn->signature = xmalloc (nn->sig_length);
+      nn->signature = XNEWVEC (unsigned char, nn->sig_length);
       nn->is_native = METHOD_IS_NATIVE (flags);
       memcpy (nn->signature, JPOOL_UTF_DATA (jcf, sig_index),
 	      nn->sig_length);
@@ -1240,7 +1240,7 @@ throwable_p (const unsigned char *clname)
 
   for (length = 0; clname[length] != ';' && clname[length] != '\0'; ++length)
     ;
-  current = ALLOC (length + 1);
+  current = XNEWVEC (unsigned char, length + 1);
   for (i = 0; i < length; ++i)
     current[i] = clname[i] == '/' ? '.' : clname[i];
   current[length] = '\0';
@@ -1276,7 +1276,7 @@ throwable_p (const unsigned char *clname)
       jcf_parse_class (&jcf);
 
       tmp = (unsigned char *) super_class_name (&jcf, &super_length);
-      super = ALLOC (super_length + 1);
+      super = XNEWVEC (unsigned char, super_length + 1);
       memcpy (super, tmp, super_length);      
       super[super_length] = '\0';
 
@@ -1836,8 +1836,8 @@ print_include (FILE *out, const unsigned char *utf8, int len)
 	return;
     }
 
-  incl = xmalloc (sizeof (struct include));
-  incl->name = xmalloc (len + 1);
+  incl = XNEW (struct include);
+  incl->name = XNEWVEC (char, len + 1);
   strncpy (incl->name, (const char *) utf8, len);
   incl->name[len] = '\0';
   incl->next = all_includes;
@@ -1922,8 +1922,8 @@ add_namelet (const unsigned char *name, const unsigned char *name_limit,
 
   if (n == NULL)
     {
-      n = xmalloc (sizeof (struct namelet));
-      n->name = xmalloc (p - name + 1);
+      n = XNEW (struct namelet);
+      n->name = XNEWVEC (char, p - name + 1);
       strncpy (n->name, (const char *) name, p - name);
       n->name[p - name] = '\0';
       n->is_class = (p == name_limit);
@@ -2173,7 +2173,7 @@ process_file (JCF *jcf, FILE *out)
 	  if (len > 6 && ! strcmp (&jcf->classname[len - 6], ".class"))
 	    len -= 6;
 	  /* Turn the class name into a file name.  */
-	  name = xmalloc (len + 1);
+	  name = XNEWVEC (char, len + 1);
 	  for (i = 0; i < len; ++i)
 	    name[i] = jcf->classname[i] == '.' ? '/' : jcf->classname[i];
 	  name[i] = '\0';
@@ -2484,25 +2484,25 @@ main (int argc, char** argv)
 
 	case OPT_PREPEND:
 	  if (prepend_count == 0)
-	    prepend_specs = ALLOC (argc * sizeof (char*));
+	    prepend_specs = XNEWVEC (char *, argc);
 	  prepend_specs[prepend_count++] = optarg;
 	  break;
 
 	case OPT_FRIEND:
 	  if (friend_count == 0)
-	    friend_specs = ALLOC (argc * sizeof (char*));
+	    friend_specs = XNEWVEC (char *, argc);
 	  friend_specs[friend_count++] = optarg;
 	  break;
 
 	case OPT_ADD:
 	  if (add_count == 0)
-	    add_specs = ALLOC (argc * sizeof (char*));
+	    add_specs = XNEWVEC (char *, argc);
 	  add_specs[add_count++] = optarg;
 	  break;
 
 	case OPT_APPEND:
 	  if (append_count == 0)
-	    append_specs = ALLOC (argc * sizeof (char*));
+	    append_specs = XNEWVEC (char *, argc);
 	  append_specs[append_count++] = optarg;
 	  break;
 
@@ -2608,7 +2608,7 @@ main (int argc, char** argv)
 	{
 	  int dir_len = strlen (output_directory);
 	  int i, classname_length = strlen (classname);
-	  current_output_file = ALLOC (dir_len + classname_length + 5);
+	  current_output_file = XNEWVEC (char, dir_len + classname_length + 5);
 	  strcpy (current_output_file, output_directory);
 	  if (dir_len > 0 && output_directory[dir_len-1] != '/')
 	    current_output_file[dir_len++] = '/';
diff --git a/gcc/java/jcf-io.c b/gcc/java/jcf-io.c
index 9b9be0a4f5a..c8651b6715f 100644
--- a/gcc/java/jcf-io.c
+++ b/gcc/java/jcf-io.c
@@ -188,11 +188,11 @@ int
 read_zip_member (JCF *jcf,  ZipDirectory *zipd, ZipFile *zipf)
 {
   jcf->filbuf = jcf_unexpected_eof;
-  jcf->zipd = (void *)zipd;
+  jcf->zipd = zipd;
 
   if (zipd->compression_method == Z_NO_COMPRESSION)
     {
-      jcf->buffer = ALLOC (zipd->size);
+      jcf->buffer = XNEWVEC (unsigned char, zipd->size);
       jcf->buffer_end = jcf->buffer + zipd->size;
       jcf->read_ptr = jcf->buffer;
       jcf->read_end = jcf->buffer_end;
@@ -208,13 +208,13 @@ read_zip_member (JCF *jcf,  ZipDirectory *zipd, ZipFile *zipf)
       d_stream.zfree = (free_func) 0;
       d_stream.opaque = (voidpf) 0;
 
-      jcf->buffer = ALLOC (zipd->uncompressed_size);
+      jcf->buffer = XNEWVEC (unsigned char, zipd->uncompressed_size);
       d_stream.next_out = jcf->buffer;
       d_stream.avail_out = zipd->uncompressed_size;
       jcf->buffer_end = jcf->buffer + zipd->uncompressed_size;
       jcf->read_ptr = jcf->buffer;
       jcf->read_end = jcf->buffer_end;
-      buffer = ALLOC (zipd->size);
+      buffer = XNEWVEC (char, zipd->size);
       d_stream.next_in = (unsigned char *) buffer;
       d_stream.avail_in = zipd->size;
       if (lseek (zipf->fd, zipd->filestart, 0) < 0
@@ -225,7 +225,7 @@ read_zip_member (JCF *jcf,  ZipDirectory *zipd, ZipFile *zipf)
       inflateInit2 (&d_stream, -MAX_WBITS);
       inflate (&d_stream, Z_NO_FLUSH);
       inflateEnd (&d_stream);
-      FREE (buffer);
+      free (buffer);
     }
 
   return 0;
@@ -246,7 +246,7 @@ open_class (const char *filename, JCF *jcf, int fd, const char *dep_name)
       if (dep_name != NULL)
 	jcf_dependency_add_file (dep_name, 0);
       JCF_ZERO (jcf);
-      jcf->buffer = ALLOC (stat_buf.st_size);
+      jcf->buffer = XNEWVEC (unsigned char, stat_buf.st_size);
       jcf->buffer_end = jcf->buffer + stat_buf.st_size;
       jcf->read_ptr = jcf->buffer;
       jcf->read_end = jcf->buffer_end;
@@ -383,8 +383,7 @@ caching_stat (char *filename, struct stat *buf)
   if (!*slot)
     {
       /* We have not already scanned this directory; scan it now.  */
-      dent = ((memoized_dirlist_entry *) 
-	      ALLOC (sizeof (memoized_dirlist_entry)));
+      dent = XNEW (memoized_dirlist_entry);
       dent->dir = xstrdup (filename);
       /* Unfortunately, scandir is not fully standardized.  In
 	 particular, the type of the function pointer passed as the
diff --git a/gcc/java/jcf-parse.c b/gcc/java/jcf-parse.c
index 4bc12f4d98a..dc33ccf25f8 100644
--- a/gcc/java/jcf-parse.c
+++ b/gcc/java/jcf-parse.c
@@ -160,7 +160,7 @@ set_source_filename (JCF *jcf, int index)
 	  /* Length of prefix, not counting final dot. */
 	  int i = dot - class_name;
 	  /* Concatenate current package prefix with new sfname. */
-	  char *buf = xmalloc (i + new_len + 2); /* Space for '.' and '\0'. */
+	  char *buf = XNEWVEC (char, i + new_len + 2); /* Space for '.' and '\0'. */
 	  strcpy (buf + i + 1, sfname);
 	  /* Copy package from class_name, replacing '.' by DIR_SEPARATOR.
 	     Note we start at the end with the final package dot. */
@@ -1084,7 +1084,7 @@ java_parse_file (int set_yydebug ATTRIBUTE_UNUSED)
       finput = fopen (main_input_filename, "r");
       if (finput == NULL)
 	fatal_error ("can't open %s: %m", input_filename);
-      list = xmalloc(avail);
+      list = XNEWVEC (char, avail);
       next = list;
       for (;;)
 	{
@@ -1351,7 +1351,7 @@ compute_class_name (struct ZipDirectory *zdir)
     }
 
   filename_length -= strlen (".class");
-  class_name = ALLOC (filename_length + 1);
+  class_name = XNEWVEC (char, filename_length + 1);
   memcpy (class_name, class_name_in_zip_dir, filename_length);
   class_name [filename_length] = '\0';
 
@@ -1455,7 +1455,7 @@ parse_zip_file_entries (void)
 	    if (TYPE_SIZE (current_class) != error_mark_node)
 	      {
 		parse_class_file ();
-		FREE (current_jcf->buffer); /* No longer necessary */
+		free (current_jcf->buffer); /* No longer necessary */
 		/* Note: there is a way to free this buffer right after a
 		   class seen in a zip file has been parsed. The idea is the
 		   set its jcf in such a way that buffer will be reallocated
@@ -1468,11 +1468,11 @@ parse_zip_file_entries (void)
 	  {
 	    char *file_name, *class_name_in_zip_dir, *buffer;
 	    JCF *jcf;
-	    file_name = ALLOC (zdir->filename_length + 1);
+	    file_name = XNEWVEC (char, zdir->filename_length + 1);
 	    class_name_in_zip_dir = ZIPDIR_FILENAME (zdir);
 	    strncpy (file_name, class_name_in_zip_dir, zdir->filename_length);
 	    file_name[zdir->filename_length] = '\0';
-	    jcf = ALLOC (sizeof (JCF));
+	    jcf = XNEW (JCF);
 	    JCF_ZERO (jcf);
 	    jcf->read_state  = finput;
 	    jcf->filbuf      = jcf_filbuf_from_stdio;
@@ -1484,7 +1484,7 @@ parse_zip_file_entries (void)
 	    if (read_zip_member (jcf, zdir, localToFile) < 0)
 	      fatal_error ("error while reading %s from zip file", file_name);
 
-	    buffer = ALLOC (zdir->filename_length + 1 +
+	    buffer = XNEWVEC (char, zdir->filename_length + 1 +
 			    (jcf->buffer_end - jcf->buffer));
 	    strcpy (buffer, file_name);
 	    /* This is not a typo: we overwrite the trailing \0 of the
@@ -1495,8 +1495,8 @@ parse_zip_file_entries (void)
 	    compile_resource_data (file_name, buffer,
 				   jcf->buffer_end - jcf->buffer);
 	    JCF_FINISH (jcf);
-	    FREE (jcf);
-	    FREE (buffer);
+	    free (jcf);
+	    free (buffer);
 	  }
 	  break;
 
@@ -1529,7 +1529,7 @@ process_zip_dir (FILE *finput)
 	continue;
 
       class_name = compute_class_name (zdir);
-      file_name  = ALLOC (zdir->filename_length+1);
+      file_name  = XNEWVEC (char, zdir->filename_length+1);
       jcf = ggc_alloc (sizeof (JCF));
       JCF_ZERO (jcf);
 
diff --git a/gcc/java/jcf-path.c b/gcc/java/jcf-path.c
index 5f509b7fc86..65cd80ef30c 100644
--- a/gcc/java/jcf-path.c
+++ b/gcc/java/jcf-path.c
@@ -132,7 +132,7 @@ add_entry (struct entry **entp, const char *filename, int is_system)
   int len;
   struct entry *n;
 
-  n = ALLOC (sizeof (struct entry));
+  n = XNEW (struct entry);
   n->flags = is_system ? FLAG_SYSTEM : 0;
   n->next = NULL;
 
diff --git a/gcc/java/jcf-write.c b/gcc/java/jcf-write.c
index caf57d1e8bc..39d318e0e28 100644
--- a/gcc/java/jcf-write.c
+++ b/gcc/java/jcf-write.c
@@ -1729,7 +1729,7 @@ generate_bytecode_insns (tree exp, int target, struct jcf_partial *state)
 	    unsigned HOST_WIDE_INT delta;
 	    /* Copy the chain of relocs into a sorted array. */
 	    struct jcf_relocation **relocs
-	      = xmalloc (sw_state.num_cases * sizeof (struct jcf_relocation *));
+	      = XNEWVEC (struct jcf_relocation *, sw_state.num_cases);
 	    /* The relocs arrays is a buffer with a gap.
 	       The assumption is that cases will normally come in "runs". */
 	    int gap_start = 0;
@@ -3473,7 +3473,7 @@ make_class_file_name (tree clas)
       slash = dname + strlen (dname);
     }
 
-  r = xmalloc (slash - dname + strlen (cname) + 2);
+  r = XNEWVEC (char, slash - dname + strlen (cname) + 2);
   strncpy (r, dname, slash - dname);
   r[slash - dname] = sep;
   strcpy (&r[slash - dname + 1], cname);
diff --git a/gcc/java/jcf.h b/gcc/java/jcf.h
index c92c34bd6c4..87c7a6e5d45 100644
--- a/gcc/java/jcf.h
+++ b/gcc/java/jcf.h
@@ -165,9 +165,9 @@ typedef struct JCF GTY(()) {
 
 #define JCF_FINISH(JCF) { \
   CPOOL_FINISH(&(JCF)->cpool); \
-  if ((JCF)->buffer) FREE ((JCF)->buffer); \
-  if ((JCF)->filename) FREE ((char *) (JCF)->filename); \
-  if ((JCF)->classname) FREE ((char *) (JCF)->classname); \
+  if ((JCF)->buffer) free ((JCF)->buffer); \
+  if ((JCF)->filename) free ((char *) (JCF)->filename); \
+  if ((JCF)->classname) free ((char *) (JCF)->classname); \
   (JCF)->finished = 1; }
   
 #define CPOOL_INIT(CPOOL) \
diff --git a/gcc/java/jvspec.c b/gcc/java/jvspec.c
index d325feeffd8..63f49ff74b3 100644
--- a/gcc/java/jvspec.c
+++ b/gcc/java/jvspec.c
@@ -90,7 +90,7 @@ find_spec_file (const char *dir)
   int x;
   struct stat sb;
 
-  spec = xmalloc (strlen (dir) + sizeof (SPEC_FILE)
+  spec = XNEWVEC (char, strlen (dir) + sizeof (SPEC_FILE)
 		  + sizeof ("-specs=") + 4);
   strcpy (spec, "-specs=");
   x = strlen (spec);
@@ -247,7 +247,7 @@ lang_specific_driver (int *in_argc, const char *const **in_argv,
   argv = *in_argv;
   added_libraries = *in_added_libraries;
 
-  args = xcalloc (argc, sizeof (int));
+  args = XCNEWVEC (int, argc);
 
   for (i = 1; i < argc; i++)
     {
@@ -490,7 +490,7 @@ lang_specific_driver (int *in_argc, const char *const **in_argv,
   
   num_args += shared_libgcc;
 
-  arglist = xmalloc ((num_args + 1) * sizeof (char *));
+  arglist = XNEWVEC (const char *, num_args + 1);
   j = 0;
 
   arglist[j++] = argv[0];
diff --git a/gcc/java/lang.c b/gcc/java/lang.c
index 4b7902f2825..f435fdeeeab 100644
--- a/gcc/java/lang.c
+++ b/gcc/java/lang.c
@@ -401,7 +401,7 @@ put_decl_string (const char *str, int len)
       if (decl_buf == NULL)
 	{
 	  decl_buflen = len + 100;
-	  decl_buf = xmalloc (decl_buflen);
+	  decl_buf = XNEWVEC (char, decl_buflen);
 	}
       else
 	{
@@ -631,7 +631,7 @@ java_post_options (const char **pfilename)
 		error ("couldn't determine target name for dependency tracking");
 	      else
 		{
-		  char *buf = xmalloc (dot - filename +
+		  char *buf = XNEWVEC (char, dot - filename +
 				       3 + sizeof (TARGET_OBJECT_SUFFIX));
 		  strncpy (buf, filename, dot - filename);
 
diff --git a/gcc/java/lex.c b/gcc/java/lex.c
index 6941c4e19d4..661f1411bd0 100644
--- a/gcc/java/lex.c
+++ b/gcc/java/lex.c
@@ -162,7 +162,7 @@ java_sprint_unicode (int c)
 java_lexer *
 java_new_lexer (FILE *finput, const char *encoding)
 {
-  java_lexer *lex = xmalloc (sizeof (java_lexer));
+  java_lexer *lex = XNEW (java_lexer);
   int enc_error = 0;
 
   lex->finput = finput;
diff --git a/gcc/java/lex.h b/gcc/java/lex.h
index 3a5671db52f..20f7680b0fd 100644
--- a/gcc/java/lex.h
+++ b/gcc/java/lex.h
@@ -200,7 +200,7 @@ extern void java_destroy_lexer (java_lexer *);
 /* Special ways to report error on numeric literals  */
 #define JAVA_FLOAT_RANGE_ERROR(m)					\
   {									\
-    char *msg = xmalloc (100 + strlen (m));				\
+    char *msg = XNEWVEC (char, 100 + strlen (m));			\
     sprintf (msg, "Floating point literal exceeds range of `%s'", (m));	\
     JAVA_RANGE_ERROR(msg);						\
     free (msg);								\
diff --git a/gcc/java/parse-scan.y b/gcc/java/parse-scan.y
index 71c43a74af6..cedba9eb8e3 100644
--- a/gcc/java/parse-scan.y
+++ b/gcc/java/parse-scan.y
@@ -105,7 +105,7 @@ struct method_declarator {
 };
 #define NEW_METHOD_DECLARATOR(D,N,A)					     \
 {									     \
-  (D) = xmalloc (sizeof (struct method_declarator));			     \
+  (D) = XNEW (struct method_declarator);				     \
   (D)->method_name = (N);						     \
   (D)->args = (A);							     \
 }
@@ -498,7 +498,7 @@ formal_parameter:
 		  if (bracket_count)
 		    {
 		      int i;
-		      char *n = xmalloc (bracket_count + 1 + strlen ($$));
+		      char *n = XNEWVEC (char, bracket_count + 1 + strlen ($$));
 		      for (i = 0; i < bracket_count; ++i)
 			n[i] = '[';
 		      strcpy (n + bracket_count, $$);
@@ -512,7 +512,7 @@ formal_parameter:
 		  if (bracket_count)
 		    {
 		      int i;
-		      char *n = xmalloc (bracket_count + 1 + strlen ($2));
+		      char *n = XNEWVEC (char, bracket_count + 1 + strlen ($2));
 		      for (i = 0; i < bracket_count; ++i)
 			n[i] = '[';
 		      strcpy (n + bracket_count, $2);
@@ -1175,10 +1175,10 @@ constant_expression:
 void
 java_push_parser_context (void)
 {
-  struct parser_ctxt *new = xcalloc (1, sizeof (struct parser_ctxt));
+  struct parser_ctxt *tmp = XCNEW (struct parser_ctxt);
 
-  new->next = ctxp;
-  ctxp = new;
+  tmp->next = ctxp;
+  ctxp = tmp;
 }  
 
 static void
@@ -1186,7 +1186,7 @@ push_class_context (const char *name)
 {
   struct class_context *ctx;
 
-  ctx = xmalloc (sizeof (struct class_context));
+  ctx = XNEW (struct class_context);
   ctx->name = (char *) name;
   ctx->next = current_class_context;
   current_class_context = ctx;
diff --git a/gcc/java/resource.c b/gcc/java/resource.c
index 0f4cafa3457..fd3d4946c4e 100644
--- a/gcc/java/resource.c
+++ b/gcc/java/resource.c
@@ -145,7 +145,7 @@ compile_resource_file (const char *name, const char *filename)
       perror ("Could not figure length of resource file");
       return;
     }
-  buffer = xmalloc (strlen (name) + stat_buf.st_size);
+  buffer = XNEWVEC (char, strlen (name) + stat_buf.st_size);
   strcpy (buffer, name);
   read (fd, buffer + strlen (name), stat_buf.st_size);
   close (fd);
diff --git a/gcc/java/zextract.c b/gcc/java/zextract.c
index 461cfbd493c..c1aff1de785 100644
--- a/gcc/java/zextract.c
+++ b/gcc/java/zextract.c
@@ -308,9 +308,8 @@ read_zip_archive (ZipFile *zipf)
     }
   zipf->count = makeword((const uch *) &buffer[TOTAL_ENTRIES_CENTRAL_DIR]);
   zipf->dir_size = makelong((const uch *) &buffer[SIZE_CENTRAL_DIRECTORY]);
-#define ALLOC xmalloc
   /* Allocate 1 more to allow appending '\0' to last filename. */
-  zipf->central_directory = ALLOC (zipf->dir_size+1);
+  zipf->central_directory = XNEWVEC (char, zipf->dir_size + 1);
   if (lseek (zipf->fd, -(zipf->dir_size+ECREC_SIZE+4), SEEK_CUR) < 0)
     return -2;
   if (read (zipf->fd, zipf->central_directory, zipf->dir_size) < 0)