gcc/java/jcf-io.c

   1 /* Utility routines for finding and reading Java(TM) .class files.
   2    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005,
   3    2006, 2007, 2008 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 3, or (at your option)
  10 any later version.
  11
  12 GCC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.
  20
  21 Java and all Java-based marks are trademarks or registered trademarks
  22 of Sun Microsystems, Inc. in the United States and other countries.
  23 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
  24
  25 /* Written by Per Bothner <bothner@cygnus.com>, February 1996. */
  26
  27 #include "config.h"
  28 #include "system.h"
  29 #include "coretypes.h"
  30 #include "tm.h"
  31
  32 #include "jcf.h"
  33 #include "tree.h"
  34 #include "toplev.h"
  35 #include "java-tree.h"
  36 #include "hashtab.h"
  37 #include <dirent.h>
  38
  39 #include "zlib.h"
  40
  41 /* DOS brain-damage */
  42 #ifndef O_BINARY
  43 #define O_BINARY 0 /* MS-DOS brain-damage */
  44 #endif
  45
  46 int
  47 jcf_unexpected_eof (JCF *jcf, int count ATTRIBUTE_UNUSED)
  48 {
  49   if (jcf->filename)
  50     fprintf (stderr, "Premature end of .class file %s.\n", jcf->filename);
  51   else
  52     fprintf (stderr, "Premature end of .class file <stdin>.\n");
  53   exit (-1);
  54 }
  55
  56 void
  57 jcf_trim_old_input (JCF *jcf)
  58 {
  59   int count = jcf->read_ptr - jcf->buffer;
  60   if (count > 0)
  61     {
  62       memmove (jcf->buffer, jcf->read_ptr, jcf->read_end - jcf->read_ptr);
  63       jcf->read_ptr -= count;
  64       jcf->read_end -= count;
  65     }
  66 }
  67
  68 int
  69 jcf_filbuf_from_stdio (JCF *jcf, int count)
  70 {
  71   FILE *file = (FILE*) (jcf->read_state);
  72   if (count > jcf->buffer_end - jcf->read_ptr)
  73     {
  74       JCF_u4 old_read_ptr = jcf->read_ptr - jcf->buffer;
  75       JCF_u4 old_read_end = jcf->read_end - jcf->buffer;
  76       JCF_u4 old_size = jcf->buffer_end - jcf->buffer;
  77       JCF_u4 new_size = (old_size == 0 ? 2000 : 2 * old_size) + count;
  78       unsigned char *new_buffer
  79         = jcf->buffer == NULL ? XNEWVAR (unsigned char, new_size)
  80         : XRESIZEVAR (unsigned char, jcf->buffer, new_size);
  81       jcf->buffer = new_buffer;
  82       jcf->buffer_end = new_buffer + new_size;
  83       jcf->read_ptr = new_buffer + old_read_ptr;
  84       jcf->read_end = new_buffer + old_read_end;
  85     }
  86   count -= jcf->read_end - jcf->read_ptr;
  87   if (count <= 0)
  88     return 0;
  89   if ((int) fread (jcf->read_end, 1, count, file) != count)
  90     jcf_unexpected_eof (jcf, count);
  91   jcf->read_end += count;
  92   return 0;
  93 }
  94
  95 #include "zipfile.h"
  96
  97 struct ZipFile *SeenZipFiles = NULL;
  98
  99 /* Open a zip file with the given name, and cache directory and file
 100    descriptor.  If the file is missing, treat it as an empty archive.
 101    Return NULL if the .zip file is malformed.
 102 */
 103
 104 ZipFile *
 105 opendir_in_zip (const char *zipfile, int is_system)
 106 {
 107   struct ZipFile* zipf;
 108   char magic [4];
 109   int fd;
 110   for (zipf = SeenZipFiles;  zipf != NULL;  zipf = zipf->next)
 111     {
 112       if (strcmp (zipf->name, zipfile) == 0)
 113         return zipf;
 114     }
 115
 116   zipf = XNEWVAR (struct ZipFile, sizeof (struct ZipFile) + strlen (zipfile) + 1);
 117   zipf->next = SeenZipFiles;
 118   zipf->name = (char*)(zipf+1);
 119   strcpy (zipf->name, zipfile);
 120   fd = open (zipfile, O_RDONLY | O_BINARY);
 121   zipf->fd = fd;
 122   if (fd < 0)
 123     {
 124       /* A missing zip file is not considered an error.
 125        We may want to re-consider that.  FIXME. */
 126       zipf->count = 0;
 127       zipf->dir_size = 0;
 128       zipf->central_directory = NULL;
 129     }
 130   else
 131     {
 132       jcf_dependency_add_file (zipfile, is_system);
 133       if (read (fd, magic, 4) != 4 || GET_u4 (magic) != (JCF_u4)ZIPMAGIC)
 134         {
 135           free (zipf);
 136           close (fd);
 137           return NULL;
 138         }
 139       lseek (fd, 0L, SEEK_SET);
 140       if (read_zip_archive (zipf) != 0)
 141         {
 142           free (zipf);
 143           close (fd);
 144           return NULL;
 145         }
 146     }
 147
 148   SeenZipFiles = zipf;
 149   return zipf;
 150 }
 151
 152 /* Returns:
 153    0:  OK - zipmember found.
 154    -1: Not found.
 155    -2: Malformed archive.
 156 */
 157
 158 int
 159 open_in_zip (JCF *jcf, const char *zipfile, const char *zipmember,
 160              int is_system)
 161 {
 162   ZipDirectory *zipd;
 163   int i, len;
 164   ZipFile *zipf = opendir_in_zip (zipfile, is_system);
 165
 166   if (zipf == NULL)
 167     return -2;
 168
 169   if (!zipmember)
 170     return 0;
 171
 172   len = strlen (zipmember);
 173
 174   zipd = (struct ZipDirectory*) zipf->central_directory;
 175   for (i = 0; i < zipf->count; i++, zipd = ZIPDIR_NEXT (zipd))
 176     {
 177       if (len == zipd->filename_length &&
 178           strncmp (ZIPDIR_FILENAME (zipd), zipmember, len) == 0)
 179         {
 180           JCF_ZERO (jcf);
 181
 182           jcf->filename = xstrdup (zipfile);
 183           jcf->classname = xstrdup (zipmember);
 184           return read_zip_member(jcf, zipd, zipf);
 185         }
 186     }
 187   return -1;
 188 }
 189
 190 /* Read data from zip archive member. */
 191
 192 int
 193 read_zip_member (JCF *jcf,  ZipDirectory *zipd, ZipFile *zipf)
 194 {
 195   jcf->filbuf = jcf_unexpected_eof;
 196   jcf->zipd = zipd;
 197
 198   if (zipd->compression_method == Z_NO_COMPRESSION)
 199     {
 200       jcf->buffer = XNEWVEC (unsigned char, zipd->size);
 201       jcf->buffer_end = jcf->buffer + zipd->size;
 202       jcf->read_ptr = jcf->buffer;
 203       jcf->read_end = jcf->buffer_end;
 204       if (lseek (zipf->fd, zipd->filestart, 0) < 0
 205           || read (zipf->fd, jcf->buffer, zipd->size) != (long) zipd->size)
 206         return -2;
 207     }
 208   else
 209     {
 210       char *buffer;
 211       z_stream d_stream; /* decompression stream */
 212       d_stream.zalloc = (alloc_func) 0;
 213       d_stream.zfree = (free_func) 0;
 214       d_stream.opaque = (voidpf) 0;
 215
 216       jcf->buffer = XNEWVEC (unsigned char, zipd->uncompressed_size);
 217       d_stream.next_out = jcf->buffer;
 218       d_stream.avail_out = zipd->uncompressed_size;
 219       jcf->buffer_end = jcf->buffer + zipd->uncompressed_size;
 220       jcf->read_ptr = jcf->buffer;
 221       jcf->read_end = jcf->buffer_end;
 222       buffer = XNEWVEC (char, zipd->size);
 223       d_stream.next_in = (unsigned char *) buffer;
 224       d_stream.avail_in = zipd->size;
 225       if (lseek (zipf->fd, zipd->filestart, 0) < 0
 226           || read (zipf->fd, buffer, zipd->size) != (long) zipd->size)
 227         return -2;
 228       /* Handle NO_HEADER using undocumented zlib feature.
 229          This is a very common hack.  */
 230       inflateInit2 (&d_stream, -MAX_WBITS);
 231       inflate (&d_stream, Z_NO_FLUSH);
 232       inflateEnd (&d_stream);
 233       free (buffer);
 234     }
 235
 236   return 0;
 237 }
 238
 239 const char *
 240 open_class (const char *filename, JCF *jcf, int fd, const char *dep_name)
 241 {
 242   if (jcf)
 243     {
 244       struct stat stat_buf;
 245       if (fstat (fd, &stat_buf) != 0
 246           || ! S_ISREG (stat_buf.st_mode))
 247         {
 248           perror ("Could not figure length of .class file");
 249           return NULL;
 250         }
 251       if (dep_name != NULL)
 252         jcf_dependency_add_file (dep_name, 0);
 253       JCF_ZERO (jcf);
 254       jcf->buffer = XNEWVEC (unsigned char, stat_buf.st_size);
 255       jcf->buffer_end = jcf->buffer + stat_buf.st_size;
 256       jcf->read_ptr = jcf->buffer;
 257       jcf->read_end = jcf->buffer_end;
 258       jcf->read_state = NULL;
 259       jcf->filename = xstrdup (filename);
 260       if (read (fd, jcf->buffer, stat_buf.st_size) != stat_buf.st_size)
 261         {
 262           perror ("Failed to read .class file");
 263           return NULL;
 264         }
 265       close (fd);
 266       jcf->filbuf = jcf_unexpected_eof;
 267     }
 268   else
 269     close (fd);
 270   return filename;
 271 }
 272
 273
 274 const char *
 275 find_classfile (char *filename, JCF *jcf, const char *dep_name)
 276 {
 277   int fd = open (filename, O_RDONLY | O_BINARY);
 278   if (fd < 0)
 279     return NULL;
 280   return open_class (filename, jcf, fd, dep_name);
 281 }
 282
 283 /* Returns 1 if the CLASSNAME (really a char *) matches the name
 284    stored in TABLE_ENTRY (also a char *).  */
 285
 286 static int
 287 memoized_class_lookup_eq (const void *table_entry, const void *classname)
 288 {
 289   return strcmp ((const char *)classname, (const char *)table_entry) == 0;
 290 }
 291
 292 /* A hash table keeping track of class names that were not found
 293    during class lookup.  (There is no need to cache the values
 294    associated with names that were found; they are saved in
 295    IDENTIFIER_CLASS_VALUE.)  */
 296 static htab_t memoized_class_lookups;
 297
 298 /* Returns a freshly malloc'd string with the fully qualified pathname
 299    of the .class file for the class CLASSNAME.  CLASSNAME must be
 300    allocated in permanent storage; this function may retain a pointer
 301    to it.  Returns NULL on failure.  If JCF != NULL, it is suitably
 302    initialized.  SOURCE_OK is true if we should also look for .java
 303    file. */
 304
 305 const char *
 306 find_class (const char *classname, int classname_length, JCF *jcf)
 307 {
 308   int fd;
 309   int i, k, klass = -1;
 310   struct stat class_buf;
 311   char *dep_file;
 312   void *entry;
 313   int buflen;
 314   char *buffer;
 315   hashval_t hash;
 316
 317   /* Create the hash table, if it does not already exist.  */
 318   if (!memoized_class_lookups)
 319     memoized_class_lookups = htab_create (37,
 320                                           htab_hash_string,
 321                                           memoized_class_lookup_eq,
 322                                           NULL);
 323
 324   /* Loop for this class in the hashtable.  If it is present, we've
 325      already looked for this class and failed to find it.  */
 326   hash = htab_hash_string (classname);
 327   if (htab_find_with_hash (memoized_class_lookups, classname, hash))
 328     return NULL;
 329
 330   /* Allocate and zero out the buffer, since we don't explicitly put a
 331      null pointer when we're copying it below.  */
 332   buflen = jcf_path_max_len () + classname_length + 10;
 333   buffer = XNEWVAR (char, buflen);
 334   memset (buffer, 0, buflen);
 335
 336   for (entry = jcf_path_start (); entry != NULL; entry = jcf_path_next (entry))
 337     {
 338       const char *path_name = jcf_path_name (entry);
 339       if (klass != 0)
 340         {
 341           int dir_len;
 342
 343           strcpy (buffer, path_name);
 344           i = strlen (buffer);
 345
 346           /* This is right because we know that `.zip' entries will have a
 347              trailing slash.  See jcf-path.c.  */
 348           dir_len = i - 1;
 349
 350           for (k = 0; k < classname_length; k++, i++)
 351             {
 352               char ch = classname[k];
 353               buffer[i] = ch == '.' ? '/' : ch;
 354             }
 355           strcpy (buffer+i, ".class");
 356
 357           if (jcf_path_is_zipfile (entry))
 358             {
 359               int err_code;
 360               JCF _jcf;
 361               buffer[dir_len] = '\0';
 362               SOURCE_FRONTEND_DEBUG
 363                 (("Trying [...%s]:%s",
 364                   &buffer[dir_len-(dir_len > 15 ? 15 : dir_len)],
 365                   buffer+dir_len+1));
 366               if (jcf == NULL)
 367                 jcf = &_jcf;
 368               err_code = open_in_zip (jcf, buffer, buffer+dir_len+1,
 369                                       jcf_path_is_system (entry));
 370               if (err_code == 0)
 371                 {
 372                   /* Should we check if .zip is out-of-date wrt .java? */
 373                   buffer[dir_len] = '(';
 374                   strcpy (buffer+i, ".class)");
 375                   if (jcf == &_jcf)
 376                     JCF_FINISH (jcf);
 377                   return buffer;
 378                 }
 379               else
 380                 continue;
 381             }
 382           klass = stat (buffer, &class_buf);
 383         }
 384     }
 385
 386   dep_file = buffer;
 387   if (!klass)
 388     {
 389       SOURCE_FRONTEND_DEBUG ((stderr, "[Class selected: %s]\n",
 390                               classname+classname_length-
 391                               (classname_length <= 30 ?
 392                                classname_length : 30)));
 393       fd = JCF_OPEN_EXACT_CASE (buffer, O_RDONLY | O_BINARY);
 394       if (fd >= 0)
 395         goto found;
 396     }
 397
 398   free (buffer);
 399
 400   /* Remember that this class could not be found so that we do not
 401      have to look again.  */
 402   *(const void **)htab_find_slot_with_hash (memoized_class_lookups,
 403                                             classname, hash, INSERT)
 404     = classname;
 405
 406   return NULL;
 407  found:
 408   {
 409     const char *const tmp = open_class (buffer, jcf, fd, dep_file);
 410     jcf->classname = xstrdup (classname);
 411     return tmp;
 412   }
 413 }
 414
 415 void
 416 jcf_print_char (FILE *stream, int ch)
 417 {
 418   switch (ch)
 419     {
 420     case '\'':
 421     case '\\':
 422     case '\"':
 423       fprintf (stream, "\\%c", ch);
 424       break;
 425     case '\n':
 426       fprintf (stream, "\\n");
 427       break;
 428     case '\t':
 429       fprintf (stream, "\\t");
 430       break;
 431     case '\r':
 432       fprintf (stream, "\\r");
 433       break;
 434     default:
 435       if (ch >= ' ' && ch < 127)
 436         putc (ch, stream);
 437       else if (ch < 256)
 438         fprintf (stream, "\\%03x", ch);
 439       else
 440         fprintf (stream, "\\u%04x", ch);
 441     }
 442 }
 443
 444 /* Print UTF8 string at STR of length LENGTH bytes to STREAM. */
 445
 446 void
 447 jcf_print_utf8 (FILE *stream, const unsigned char *str, int length)
 448 {
 449   const unsigned char * limit = str + length;
 450   while (str < limit)
 451     {
 452       int ch = UTF8_GET (str, limit);
 453       if (ch < 0)
 454         {
 455           fprintf (stream, "\\<invalid>");
 456           return;
 457         }
 458       jcf_print_char (stream, ch);
 459     }
 460 }
 461
 462 /* Same as jcf_print_utf8, but print IN_CHAR as OUT_CHAR. */
 463
 464 void
 465 jcf_print_utf8_replace (FILE *stream, const unsigned char *str, int length,
 466                         int in_char, int out_char)
 467 {
 468   const unsigned char *limit = str + length;
 469   while (str < limit)
 470     {
 471       int ch = UTF8_GET (str, limit);
 472       if (ch < 0)
 473         {
 474           fprintf (stream, "\\<invalid>");
 475           return;
 476         }
 477       jcf_print_char (stream, ch == in_char ? out_char : ch);
 478     }
 479 }
 480
 481 /* Check that all the cross-references in the constant pool are
 482    valid.  Returns 0 on success.
 483    Otherwise, returns the index of the (first) invalid entry.
 484    Only checks internal consistency, but does not check that
 485    any classes, fields, or methods are valid.*/
 486
 487 int
 488 verify_constant_pool (JCF *jcf)
 489 {
 490   int i, n;
 491   for (i = 1; i < JPOOL_SIZE (jcf); i++)
 492     {
 493       switch (JPOOL_TAG (jcf, i))
 494         {
 495         case CONSTANT_NameAndType:
 496           n = JPOOL_USHORT2 (jcf, i);
 497           if (n <= 0 || n >= JPOOL_SIZE(jcf)
 498               || JPOOL_TAG (jcf, n) != CONSTANT_Utf8)
 499             return i;
 500           /* ... fall through ... */
 501         case CONSTANT_Class:
 502         case CONSTANT_String:
 503           n = JPOOL_USHORT1 (jcf, i);
 504           if (n <= 0 || n >= JPOOL_SIZE(jcf)
 505               || JPOOL_TAG (jcf, n) != CONSTANT_Utf8)
 506             return i;
 507           break;
 508         case CONSTANT_Fieldref:
 509         case CONSTANT_Methodref:
 510         case CONSTANT_InterfaceMethodref:
 511           n = JPOOL_USHORT1 (jcf, i);
 512           if (n <= 0 || n >= JPOOL_SIZE(jcf)
 513               || JPOOL_TAG (jcf, n) != CONSTANT_Class)
 514             return i;
 515           n = JPOOL_USHORT2 (jcf, i);
 516           if (n <= 0 || n >= JPOOL_SIZE(jcf)
 517               || JPOOL_TAG (jcf, n) != CONSTANT_NameAndType)
 518             return i;
 519           break;
 520         case CONSTANT_Long:
 521         case CONSTANT_Double:
 522           i++;
 523           break;
 524         case CONSTANT_Float:
 525         case CONSTANT_Integer:
 526         case CONSTANT_Utf8:
 527         case CONSTANT_Unicode:
 528           break;
 529         default:
 530           return i;
 531         }
 532     }
 533   return 0;
 534 }
 535
 536 void
 537 format_uint (char *buffer, uint64 value, int base)
 538 {
 539 #define WRITE_BUF_SIZE (4 + sizeof(uint64) * 8)
 540   char buf[WRITE_BUF_SIZE];
 541   char *buf_ptr = buf+WRITE_BUF_SIZE; /* End of buf. */
 542   int chars_written;
 543   int i;
 544
 545   /* Now do the actual conversion, placing the result at the *end* of buf. */
 546   /* Note this code does not pretend to be optimized. */
 547   do {
 548     int digit = value % base;
 549     static const char digit_chars[] = "0123456789abcdefghijklmnopqrstuvwxyz";
 550     *--buf_ptr = digit_chars[digit];
 551     value /= base;
 552   } while (value != 0);
 553
 554   chars_written = buf+WRITE_BUF_SIZE - buf_ptr;
 555   for (i = 0; i < chars_written; i++)
 556     buffer[i] = *buf_ptr++;
 557   buffer[i] = 0;
 558 }
 559
 560 void
 561 format_int (char *buffer, jlong value, int base)
 562 {
 563   uint64 abs_value;
 564   if (value < 0)
 565     {
 566       abs_value = -(uint64)value;
 567       *buffer++ = '-';
 568     }
 569   else
 570     abs_value = (uint64) value;
 571   format_uint (buffer, abs_value, base);
 572 }