[BACK]Return to nm.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / nm

Diff for /src/usr.bin/nm/nm.c between version 1.21 and 1.22

version 1.21, 2004/01/13 17:32:32 version 1.22, 2004/01/14 02:52:04
Line 344 
Line 344 
         return (0);          return (0);
 }  }
   
   #define MMAP(ptr, len, prot, flags, fd, off)    do {            \
           didmmap = (ptr = mmap(NULL, len, prot, flags, fd, off)) != MAP_FAILED; \
           if (!didmmap) {                                                 \
                   if ((ptr = malloc(len)) == NULL) {                      \
                           ptr = MAP_FAILED;                               \
                           warn("malloc");                                 \
                   } else if (pread(fd, ptr, len, off) != len) {           \
                           free(ptr);                                      \
                           ptr = MAP_FAILED;                               \
                           warn("pread");                                  \
                   }                                                       \
           }                                                               \
   } while (0)
   
   #define MUNMAP(addr, len)       do {                                    \
           if (didmmap)                                                    \
                   munmap(addr, len);                                      \
           else                                                            \
                   free(addr);                                             \
   } while (0)
   
 /*  /*
  * show_symtab()   * show_symtab()
  *      show archive ranlib index (fs5)   *      show archive ranlib index (fs5)
Line 355 
Line 376 
         int *symtab, *ps;          int *symtab, *ps;
         char *strtab, *p;          char *strtab, *p;
         int num, rval = 0;          int num, rval = 0;
         int namelen;          int namelen, didmmap;
   
         if ((symtab = mmap(NULL, len, PROT_READ,          MMAP(symtab, len, PROT_READ, MAP_PRIVATE|MAP_FILE, fileno(fp), off);
             MAP_PRIVATE|MAP_FILE, fileno(fp), off)) == MAP_FAILED) {          if (symtab == MAP_FAILED)
                 warn("%s: mmap", name);  
                 return (1);                  return (1);
         }  
   
         namelen = sizeof(ar_head.ar_name);          namelen = sizeof(ar_head.ar_name);
         if ((p = malloc(sizeof(ar_head.ar_name))) == NULL) {          if ((p = malloc(sizeof(ar_head.ar_name))) == NULL) {
                 warn("%s: malloc", name);                  warn("%s: malloc", name);
                 munmap(symtab, len);                  MUNMAP(symtab, len);
                 return (1);  
         }          }
   
         printf("\nArchive index:\n");          printf("\nArchive index:\n");
Line 397 
Line 415 
         }          }
   
         free(p);          free(p);
         munmap(symtab, len);          MUNMAP(symtab, len);
         return (rval);          return (rval);
 }  }
   
Line 413 
Line 431 
         void *symdef;          void *symdef;
         char *strtab, *p;          char *strtab, *p;
         u_long size;          u_long size;
         int namelen, rval = 0;          int namelen, didmmap, rval = 0;
   
         if ((symdef = mmap(NULL, len, PROT_READ,          MMAP(symdef, len, PROT_READ, MAP_PRIVATE|MAP_FILE, fileno(fp), off);
             MAP_PRIVATE|MAP_FILE, fileno(fp), off)) == MAP_FAILED) {          if (symdef == MAP_FAILED)
                 warn("%s: mmap", name);  
                 return (1);                  return (1);
         }          if (didmmap)
                   (void)madvise(symdef, len, MADV_SEQUENTIAL);
   
         if (madvise(symdef, len, MADV_SEQUENTIAL)) {  
                 warn("%s: madvise", name);  
                 munmap(symdef, len);  
                 return (1);  
         }  
   
         namelen = sizeof(ar_head.ar_name);          namelen = sizeof(ar_head.ar_name);
         if ((p = malloc(sizeof(ar_head.ar_name))) == NULL) {          if ((p = malloc(sizeof(ar_head.ar_name))) == NULL) {
                 warn("%s: malloc", name);                  warn("%s: malloc", name);
                 munmap(symdef, len);                  MUNMAP(symdef, len);
                 return (1);                  return (1);
         }          }
   
Line 464 
Line 476 
         }          }
   
         free(p);          free(p);
         munmap(symdef, len);          MUNMAP(symdef, len);
         return (rval);          return (rval);
 }  }
   
Line 621 
Line 633 
         struct nlist *np;          struct nlist *np;
         Elf_Shdr *shdr;          Elf_Shdr *shdr;
         off_t staboff;          off_t staboff;
         int i, aout;          int i, aout, didmmap;
   
         aout = 0;          aout = 0;
         if (IS_ELF(head->elf) &&          if (IS_ELF(head->elf) &&
Line 731 
Line 743 
                         free(names);                          free(names);
                         return(1);                          return(1);
                 }                  }
                 stabsize = fix_long_order(stabsize, N_GETMID(head->aout));                  MMAP(stab, stabsize, PROT_READ, MAP_PRIVATE|MAP_FILE,
                 if ((stab = mmap(NULL, stabsize, PROT_READ,                      fileno(fp), staboff);
                     MAP_PRIVATE|MAP_FILE, fileno(fp), staboff)) == MAP_FAILED) {                  if (stab == MAP_FAILED) {
                         warn("%s: mmap", name);  
                         free(snames);                          free(snames);
                         free(names);                          free(names);
                         return (1);                          return (1);
Line 775 
Line 786 
                 warn("%s: madvise", name);                  warn("%s: madvise", name);
                 free(snames);                  free(snames);
                 free(names);                  free(names);
                 munmap(stab, stabsize);                  MUNMAP(stab, stabsize);
                 return (1);                  return (1);
         }          }
   
Line 829 
Line 840 
   
         free(snames);          free(snames);
         free(names);          free(names);
         munmap(stab, stabsize);          MUNMAP(stab, stabsize);
         return(0);          return(0);
 }  }
   
Line 840 
Line 851 
         struct nlist *np;          struct nlist *np;
         Elf_Sym sbuf;          Elf_Sym sbuf;
         char *shstr;          char *shstr;
         int i;          int i, didmmap = 0;
   
         shstrsize = shdr[eh->e_shstrndx].sh_size;          shstrsize = shdr[eh->e_shstrndx].sh_size;
         if ((shstr = malloc(shstrsize)) == NULL) {          if ((shstr = malloc(shstrsize)) == NULL) {
Line 871 
Line 882 
                                 return (1);                                  return (1);
                         }                          }
   
                         if ((stab = mmap(NULL, stabsize, PROT_READ,                          MMAP(stab, stabsize, PROT_READ, MAP_PRIVATE|MAP_FILE,
                             MAP_PRIVATE|MAP_FILE, fileno(fp),                              fileno(fp), foff + shdr[i].sh_offset);
                             foff + shdr[i].sh_offset)) == MAP_FAILED) {                          if (stab == MAP_FAILED) {
                                 warn("%s: mmap", name);  
                                 free(shstr);                                  free(shstr);
                                 return (1);                                  return (1);
                         }                          }
Line 886 
Line 896 
                         if (fseeko(fp, foff + shdr[i].sh_offset, SEEK_SET)) {                          if (fseeko(fp, foff + shdr[i].sh_offset, SEEK_SET)) {
                                 warn("%s: fseeko", name);                                  warn("%s: fseeko", name);
                                 if (stab)                                  if (stab)
                                         munmap(stab, stabsize);                                          MUNMAP(stab, stabsize);
                                 free(shstr);                                  free(shstr);
                                 return (1);                                  return (1);
                         }                          }
Line 895 
Line 905 
                         if ((names = calloc(nrawnames, sizeof(*np))) == NULL) {                          if ((names = calloc(nrawnames, sizeof(*np))) == NULL) {
                                 warn("%s: malloc names", name);                                  warn("%s: malloc names", name);
                                 if (stab)                                  if (stab)
                                         munmap(stab, stabsize);                                          MUNMAP(stab, stabsize);
                                 free(names);                                  free(names);
                                 free(shstr);                                  free(shstr);
                                 return (1);                                  return (1);
Line 903 
Line 913 
                         if ((snames = malloc(nrawnames * sizeof(np))) == NULL) {                          if ((snames = malloc(nrawnames * sizeof(np))) == NULL) {
                                 warn("%s: malloc snames", name);                                  warn("%s: malloc snames", name);
                                 if (stab)                                  if (stab)
                                         munmap(stab, stabsize);                                          MUNMAP(stab, stabsize);
                                 free(shstr);                                  free(shstr);
                                 free(names);                                  free(names);
                                 free(snames);                                  free(snames);
Line 915 
Line 925 
                                     fp) != sizeof(sbuf)) {                                      fp) != sizeof(sbuf)) {
                                         warn("%s: read symbol", name);                                          warn("%s: read symbol", name);
                                         if (stab)                                          if (stab)
                                                 munmap(stab, stabsize);                                                  MUNMAP(stab, stabsize);
                                         free(shstr);                                          free(shstr);
                                         free(names);                                          free(names);
                                         free(snames);                                          free(snames);
Legend:
Removed from v.1.21  
changed lines
  Added in v.1.22