labels.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 1996-2016 The NASM Authors - All Rights Reserved
   4  *   See the file AUTHORS included with the NASM distribution for
   5  *   the specific copyright holders.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following
   9  *   conditions are met:
  10  *
  11  *   * Redistributions of source code must retain the above copyright
  12  *     notice, this list of conditions and the following disclaimer.
  13  *   * Redistributions in binary form must reproduce the above
  14  *     copyright notice, this list of conditions and the following
  15  *     disclaimer in the documentation and/or other materials provided
  16  *     with the distribution.
  17  *
  18  *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  19  *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  20  *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  21  *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22  *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  23  *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  25  *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  26  *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  29  *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  30  *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  * ----------------------------------------------------------------------- */
  33
  34 /*
  35  * labels.c  label handling for the Netwide Assembler
  36  */
  37
  38 #include "compiler.h"
  39
  40 #include <stdio.h>
  41 #include <string.h>
  42 #include <stdlib.h>
  43 #include <inttypes.h>
  44
  45 #include "nasm.h"
  46 #include "nasmlib.h"
  47 #include "hashtbl.h"
  48 #include "labels.h"
  49
  50 /*
  51  * A local label is one that begins with exactly one period. Things
  52  * that begin with _two_ periods are NASM-specific things.
  53  *
  54  * If TASM compatibility is enabled, a local label can also begin with
  55  * @@, so @@local is a TASM compatible local label. Note that we only
  56  * check for the first @ symbol, although TASM requires both.
  57  */
  58 #define islocal(l)                                                      \
  59         (tasm_compatible_mode ?                                         \
  60                 (((l)[0] == '.' || (l)[0] == '@') && (l)[1] != '.') :   \
  61                 ((l)[0] == '.' && (l)[1] != '.'))
  62 #define islocalchar(c)                                                  \
  63         (tasm_compatible_mode ?                                         \
  64                 ((c) == '.' || (c) == '@') :                            \
  65                 ((c) == '.'))
  66
  67 #define LABEL_BLOCK     128     /* no. of labels/block */
  68 #define LBLK_SIZE       (LABEL_BLOCK * sizeof(union label))
  69
  70 #define END_LIST        -3      /* don't clash with NO_SEG! */
  71 #define END_BLOCK       -2
  72 #define BOGUS_VALUE     -4
  73
  74 #define PERMTS_SIZE     16384   /* size of text blocks */
  75 #if (PERMTS_SIZE < IDLEN_MAX)
  76  #error "IPERMTS_SIZE must be greater than or equal to IDLEN_MAX"
  77 #endif
  78
  79 /* values for label.defn.is_global */
  80 #define DEFINED_BIT     1
  81 #define GLOBAL_BIT      2
  82 #define EXTERN_BIT      4
  83 #define COMMON_BIT      8
  84
  85 #define NOT_DEFINED_YET         0
  86 #define TYPE_MASK               3
  87 #define LOCAL_SYMBOL            (DEFINED_BIT)
  88 #define GLOBAL_PLACEHOLDER      (GLOBAL_BIT)
  89 #define GLOBAL_SYMBOL           (DEFINED_BIT | GLOBAL_BIT)
  90
  91 union label {                   /* actual label structures */
  92     struct {
  93         int32_t segment;
  94         int64_t offset;
  95         char *label, *special;
  96         int is_global, is_norm;
  97     } defn;
  98     struct {
  99         int32_t movingon;
 100         int64_t dummy;
 101         union label *next;
 102     } admin;
 103 };
 104
 105 struct permts {                 /* permanent text storage */
 106     struct permts *next;        /* for the linked list */
 107     int size, usage;            /* size and used space in ... */
 108     char data[PERMTS_SIZE];     /* ... the data block itself */
 109 };
 110
 111 extern int64_t global_offset_changed;   /* defined in nasm.c */
 112
 113 static struct hash_table ltab;          /* labels hash table */
 114 static union label *ldata;              /* all label data blocks */
 115 static union label *lfree;              /* labels free block */
 116 static struct permts *perm_head;        /* start of perm. text storage */
 117 static struct permts *perm_tail;        /* end of perm. text storage */
 118
 119 static void init_block(union label *blk);
 120 static char *perm_copy(const char *string);
 121
 122 static char *prevlabel;
 123
 124 static bool initialized = false;
 125
 126 char lprefix[PREFIX_MAX] = { 0 };
 127 char lpostfix[PREFIX_MAX] = { 0 };
 128
 129 /*
 130  * Emit a symdef to the output and the debug format backends.
 131  */
 132 static void out_symdef(char *name, int32_t segment, int64_t offset,
 133                        int is_global, char *special)
 134 {
 135     ofmt->symdef(name, segment, offset, is_global, special);
 136
 137     /*
 138      * NASM special symbols are not passed to the debug format; none
 139      * of the current backends want to see them.
 140      */
 141     if (!(name[0] == '.' && name[1] == '.' && name[2] != '@'))
 142         dfmt->debug_deflabel(name, segment, offset, is_global, special);
 143 }
 144
 145 /*
 146  * Internal routine: finds the `union label' corresponding to the
 147  * given label name. Creates a new one, if it isn't found, and if
 148  * `create' is true.
 149  */
 150 static union label *find_label(char *label, int create, int *created)
 151 {
 152     char *prev;
 153     int prevlen, len;
 154     union label *lptr, **lpp;
 155     char label_str[IDLEN_MAX];
 156     struct hash_insert ip;
 157
 158     if (islocal(label)) {
 159         prev = prevlabel;
 160         prevlen = strlen(prev);
 161         len = strlen(label);
 162         if (prevlen + len >= IDLEN_MAX) {
 163             nasm_error(ERR_NONFATAL, "identifier length exceed %i bytes",
 164                        IDLEN_MAX);
 165             return NULL;
 166         }
 167         memcpy(label_str, prev, prevlen);
 168         memcpy(label_str+prevlen, label, len+1);
 169         label = label_str;
 170     } else {
 171         prev = "";
 172         prevlen = 0;
 173     }
 174
 175     lpp = (union label **) hash_find(&ltab, label, &ip);
 176     lptr = lpp ? *lpp : NULL;
 177
 178     if (lptr || !create) {
 179         if (created)
 180             *created = 0;
 181         return lptr;
 182     }
 183
 184     /* Create a new label... */
 185     if (lfree->admin.movingon == END_BLOCK) {
 186         /*
 187          * must allocate a new block
 188          */
 189         lfree->admin.next = (union label *)nasm_malloc(LBLK_SIZE);
 190         lfree = lfree->admin.next;
 191         init_block(lfree);
 192     }
 193
 194     if (created)
 195         *created = 1;
 196
 197     lfree->admin.movingon = BOGUS_VALUE;
 198     lfree->defn.label = perm_copy(label);
 199     lfree->defn.special = NULL;
 200     lfree->defn.is_global = NOT_DEFINED_YET;
 201
 202     hash_add(&ip, lfree->defn.label, lfree);
 203     return lfree++;
 204 }
 205
 206 bool lookup_label(char *label, int32_t *segment, int64_t *offset)
 207 {
 208     union label *lptr;
 209
 210     if (!initialized)
 211         return false;
 212
 213     lptr = find_label(label, 0, NULL);
 214     if (lptr && (lptr->defn.is_global & DEFINED_BIT)) {
 215         *segment = lptr->defn.segment;
 216         *offset = lptr->defn.offset;
 217         return true;
 218     }
 219
 220     return false;
 221 }
 222
 223 bool is_extern(char *label)
 224 {
 225     union label *lptr;
 226
 227     if (!initialized)
 228         return false;
 229
 230     lptr = find_label(label, 0, NULL);
 231     return (lptr && (lptr->defn.is_global & EXTERN_BIT));
 232 }
 233
 234 void redefine_label(char *label, int32_t segment, int64_t offset, char *special,
 235                     bool is_norm, bool isextrn)
 236 {
 237     union label *lptr;
 238     int exi, created;
 239
 240     /* This routine possibly ought to check for phase errors.  Most assemblers
 241      * check for phase errors at this point.  I don't know whether phase errors
 242      * are even possible, nor whether they are checked somewhere else
 243      */
 244
 245     (void)special;              /* Don't warn that this parameter is unused */
 246     (void)is_norm;              /* Don't warn that this parameter is unused */
 247     (void)isextrn;              /* Don't warn that this parameter is unused */
 248
 249 #ifdef DEBUG
 250 #if DEBUG < 3
 251     if (!strncmp(label, "debugdump", 9))
 252 #endif
 253         nasm_error(ERR_DEBUG, "redefine_label (%s, %"PRIx32", %"PRIx64", %s, %d, %d)",
 254               label, segment, offset, special, is_norm, isextrn);
 255 #endif
 256
 257     lptr = find_label(label, 1, &created);
 258     if (!lptr)
 259         nasm_panic(0, "can't find label `%s' on pass two", label);
 260
 261     if (created)
 262             nasm_error(ERR_WARNING, "label `%s' defined on pass two", label);
 263
 264     if (!islocal(label)) {
 265         if (!islocalchar(*label) && lptr->defn.is_norm)
 266             prevlabel = lptr->defn.label;
 267     }
 268
 269     if (lptr->defn.offset != offset)
 270         global_offset_changed++;
 271
 272     lptr->defn.offset = offset;
 273     lptr->defn.segment = segment;
 274
 275     if (pass0 == 1) {
 276         exi = !!(lptr->defn.is_global & GLOBAL_BIT);
 277         if (exi) {
 278             char *xsymbol;
 279             int slen;
 280             slen = strlen(lprefix);
 281             slen += strlen(lptr->defn.label);
 282             slen += strlen(lpostfix);
 283             slen++;             /* room for that null char */
 284             xsymbol = nasm_malloc(slen);
 285             snprintf(xsymbol, slen, "%s%s%s", lprefix, lptr->defn.label,
 286                      lpostfix);
 287
 288             out_symdef(xsymbol, segment, offset, exi,
 289                        special ? special : lptr->defn.special);
 290             /** nasm_free(xsymbol);  ! outobj.c stores the pointer; ouch!!! **/
 291         } else {
 292             if ((lptr->defn.is_global & (GLOBAL_BIT | EXTERN_BIT)) != EXTERN_BIT) {
 293                 out_symdef(lptr->defn.label, segment, offset, exi,
 294                            special ? special : lptr->defn.special);
 295             }
 296         }
 297     }   /* if (pass0 == 1) */
 298 }
 299
 300 void define_label(char *label, int32_t segment, int64_t offset, char *special,
 301                   bool is_norm, bool isextrn)
 302 {
 303     union label *lptr;
 304     int exi;
 305
 306 #ifdef DEBUG
 307 #if DEBUG<3
 308     if (!strncmp(label, "debugdump", 9))
 309 #endif
 310         nasm_error(ERR_DEBUG, "define_label (%s, %"PRIx32", %"PRIx64", %s, %d, %d)",
 311               label, segment, offset, special, is_norm, isextrn);
 312 #endif
 313     lptr = find_label(label, 1, NULL);
 314     if (!lptr)
 315         return;
 316     if (lptr->defn.is_global & DEFINED_BIT) {
 317         nasm_error(ERR_NONFATAL, "symbol `%s' redefined", label);
 318         return;
 319     }
 320     lptr->defn.is_global |= DEFINED_BIT;
 321     if (isextrn)
 322         lptr->defn.is_global |= EXTERN_BIT;
 323
 324     if (!islocalchar(label[0]) && is_norm) {
 325         /* not local, but not special either */
 326         prevlabel = lptr->defn.label;
 327     } else if (islocal(label) && !*prevlabel) {
 328         nasm_error(ERR_NONFATAL, "attempt to define a local label before any"
 329               " non-local labels");
 330     }
 331
 332     lptr->defn.segment = segment;
 333     lptr->defn.offset = offset;
 334     lptr->defn.is_norm = (!islocalchar(label[0]) && is_norm);
 335
 336     if (pass0 == 1 || (!is_norm && !isextrn && (segment > 0) && (segment & 1))) {
 337         exi = !!(lptr->defn.is_global & GLOBAL_BIT);
 338         if (exi) {
 339             char *xsymbol;
 340             int slen;
 341             slen = strlen(lprefix);
 342             slen += strlen(lptr->defn.label);
 343             slen += strlen(lpostfix);
 344             slen++;             /* room for that null char */
 345             xsymbol = nasm_malloc(slen);
 346             snprintf(xsymbol, slen, "%s%s%s", lprefix, lptr->defn.label,
 347                      lpostfix);
 348
 349             out_symdef(xsymbol, segment, offset, exi,
 350                        special ? special : lptr->defn.special);
 351             /** nasm_free(xsymbol);  ! outobj.c stores the pointer; ouch!!! **/
 352         } else {
 353             if ((lptr->defn.is_global & (GLOBAL_BIT | EXTERN_BIT)) != EXTERN_BIT) {
 354                 out_symdef(lptr->defn.label, segment, offset, exi,
 355                            special ? special : lptr->defn.special);
 356             }
 357         }
 358     }   /* if (pass0 == 1) */
 359 }
 360
 361 void define_common(char *label, int32_t segment, int32_t size, char *special)
 362 {
 363     union label *lptr;
 364
 365     lptr = find_label(label, 1, NULL);
 366     if (!lptr)
 367         return;
 368     if ((lptr->defn.is_global & DEFINED_BIT) &&
 369         (passn == 1 || !(lptr->defn.is_global & COMMON_BIT))) {
 370             nasm_error(ERR_NONFATAL, "symbol `%s' redefined", label);
 371             return;
 372     }
 373     lptr->defn.is_global |= DEFINED_BIT|COMMON_BIT;
 374
 375     if (!islocalchar(label[0])) {
 376         prevlabel = lptr->defn.label;
 377     } else {
 378         nasm_error(ERR_NONFATAL, "attempt to define a local label as a "
 379               "common variable");
 380         return;
 381     }
 382
 383     lptr->defn.segment = segment;
 384     lptr->defn.offset = 0;
 385
 386     if (pass0 == 0)
 387         return;
 388
 389     out_symdef(lptr->defn.label, segment, size, 2,
 390                special ? special : lptr->defn.special);
 391 }
 392
 393 void declare_as_global(char *label, char *special)
 394 {
 395     union label *lptr;
 396
 397     if (islocal(label)) {
 398         nasm_error(ERR_NONFATAL, "attempt to declare local symbol `%s' as"
 399               " global", label);
 400         return;
 401     }
 402     lptr = find_label(label, 1, NULL);
 403     if (!lptr)
 404         return;
 405     switch (lptr->defn.is_global & TYPE_MASK) {
 406     case NOT_DEFINED_YET:
 407         lptr->defn.is_global = GLOBAL_PLACEHOLDER;
 408         lptr->defn.special = special ? perm_copy(special) : NULL;
 409         break;
 410     case GLOBAL_PLACEHOLDER:   /* already done: silently ignore */
 411     case GLOBAL_SYMBOL:
 412         break;
 413     case LOCAL_SYMBOL:
 414         if (!(lptr->defn.is_global & EXTERN_BIT)) {
 415             nasm_error(ERR_WARNING, "symbol `%s': GLOBAL directive "
 416                   "after symbol definition is an experimental feature", label);
 417             lptr->defn.is_global = GLOBAL_SYMBOL;
 418         }
 419         break;
 420     }
 421 }
 422
 423 int init_labels(void)
 424 {
 425     hash_init(&ltab, HASH_LARGE);
 426
 427     ldata = lfree = (union label *)nasm_malloc(LBLK_SIZE);
 428     init_block(lfree);
 429
 430     perm_head = perm_tail =
 431         (struct permts *)nasm_malloc(sizeof(struct permts));
 432
 433     perm_head->next = NULL;
 434     perm_head->size = PERMTS_SIZE;
 435     perm_head->usage = 0;
 436
 437     prevlabel = "";
 438
 439     initialized = true;
 440
 441     return 0;
 442 }
 443
 444 void cleanup_labels(void)
 445 {
 446     union label *lptr, *lhold;
 447
 448     initialized = false;
 449
 450     hash_free(&ltab);
 451
 452     lptr = lhold = ldata;
 453     while (lptr) {
 454         lptr = &lptr[LABEL_BLOCK-1];
 455         lptr = lptr->admin.next;
 456         nasm_free(lhold);
 457         lhold = lptr;
 458     }
 459
 460     while (perm_head) {
 461         perm_tail = perm_head;
 462         perm_head = perm_head->next;
 463         nasm_free(perm_tail);
 464     }
 465 }
 466
 467 static void init_block(union label *blk)
 468 {
 469     int j;
 470
 471     for (j = 0; j < LABEL_BLOCK - 1; j++)
 472         blk[j].admin.movingon = END_LIST;
 473     blk[LABEL_BLOCK - 1].admin.movingon = END_BLOCK;
 474     blk[LABEL_BLOCK - 1].admin.next = NULL;
 475 }
 476
 477 static char *perm_copy(const char *string)
 478 {
 479     char *p;
 480     int len = strlen(string)+1;
 481
 482     nasm_assert(len <= PERMTS_SIZE);
 483
 484     if (perm_tail->size - perm_tail->usage < len) {
 485         perm_tail->next =
 486             (struct permts *)nasm_malloc(sizeof(struct permts));
 487         perm_tail = perm_tail->next;
 488         perm_tail->next = NULL;
 489         perm_tail->size = PERMTS_SIZE;
 490         perm_tail->usage = 0;
 491     }
 492     p = perm_tail->data + perm_tail->usage;
 493     memcpy(p, string, len);
 494     perm_tail->usage += len;
 495
 496     return p;
 497 }
 498
 499 char *local_scope(char *label)
 500 {
 501    return islocal(label) ? prevlabel : "";
 502 }
 503
 504 /*
 505  * Notes regarding bug involving redefinition of external segments.
 506  *
 507  * Up to and including v0.97, the following code didn't work. From 0.97
 508  * developers release 2 onwards, it will generate an error.
 509  *
 510  * EXTERN extlabel
 511  * newlabel EQU extlabel + 1
 512  *
 513  * The results of allowing this code through are that two import records
 514  * are generated, one for 'extlabel' and one for 'newlabel'.
 515  *
 516  * The reason for this is an inadequacy in the defined interface between
 517  * the label manager and the output formats. The problem lies in how the
 518  * output format driver tells that a label is an external label for which
 519  * a label import record must be produced. Most (all except bin?) produce
 520  * the record if the segment number of the label is not one of the internal
 521  * segments that the output driver is producing.
 522  *
 523  * A simple fix to this would be to make the output formats keep track of
 524  * which symbols they've produced import records for, and make them not
 525  * produce import records for segments that are already defined.
 526  *
 527  * The best way, which is slightly harder but reduces duplication of code
 528  * and should therefore make the entire system smaller and more stable is
 529  * to change the interface between assembler, define_label(), and
 530  * the output module. The changes that are needed are:
 531  *
 532  * The semantics of the 'isextern' flag passed to define_label() need
 533  * examining. This information may or may not tell us what we need to
 534  * know (ie should we be generating an import record at this point for this
 535  * label). If these aren't the semantics, the semantics should be changed
 536  * to this.
 537  *
 538  * The output module interface needs changing, so that the `isextern' flag
 539  * is passed to the module, so that it can be easily tested for.
 540  */