git.sur5r.net Git - cc65/blob - src/cc65/locals.c

   1 /*****************************************************************************/
   2 /*                                                                           */
   3 /*                                 locals.c                                  */
   4 /*                                                                           */
   5 /*              Local variable handling for the cc65 C compiler              */
   6 /*                                                                           */
   7 /*                                                                           */
   8 /*                                                                           */
   9 /* (C) 2000-2013, Ullrich von Bassewitz                                      */
  10 /*                Roemerstrasse 52                                           */
  11 /*                D-70794 Filderstadt                                        */
  12 /* EMail:         uz@cc65.org                                                */
  13 /*                                                                           */
  14 /*                                                                           */
  15 /* This software is provided 'as-is', without any expressed or implied       */
  16 /* warranty.  In no event will the authors be held liable for any damages    */
  17 /* arising from the use of this software.                                    */
  18 /*                                                                           */
  19 /* Permission is granted to anyone to use this software for any purpose,     */
  20 /* including commercial applications, and to alter it and redistribute it    */
  21 /* freely, subject to the following restrictions:                            */
  22 /*                                                                           */
  23 /* 1. The origin of this software must not be misrepresented; you must not   */
  24 /*    claim that you wrote the original software. If you use this software   */
  25 /*    in a product, an acknowledgment in the product documentation would be  */
  26 /*    appreciated but is not required.                                       */
  27 /* 2. Altered source versions must be plainly marked as such, and must not   */
  28 /*    be misrepresented as being the original software.                      */
  29 /* 3. This notice may not be removed or altered from any source              */
  30 /*    distribution.                                                          */
  31 /*                                                                           */
  32 /*****************************************************************************/
  33
  34
  35
  36 /* common */
  37 #include "xmalloc.h"
  38 #include "xsprintf.h"
  39
  40 /* cc65 */
  41 #include "anonname.h"
  42 #include "asmlabel.h"
  43 #include "codegen.h"
  44 #include "declare.h"
  45 #include "error.h"
  46 #include "expr.h"
  47 #include "function.h"
  48 #include "global.h"
  49 #include "loadexpr.h"
  50 #include "locals.h"
  51 #include "stackptr.h"
  52 #include "standard.h"
  53 #include "symtab.h"
  54 #include "typeconv.h"
  55 #include "input.h"
  56
  57
  58
  59 /*****************************************************************************/
  60 /*                                   Code                                    */
  61 /*****************************************************************************/
  62
  63
  64
  65 static unsigned AllocLabel (void (*UseSeg) ())
  66 /* Switch to a segment, define a local label and return it */
  67 {
  68     unsigned Label;
  69
  70     /* Switch to the segment */
  71     UseSeg ();
  72
  73     /* Define the variable label */
  74     Label = GetLocalLabel ();
  75     g_defdatalabel (Label);
  76
  77     /* Return the label */
  78     return Label;
  79 }
  80
  81
  82
  83 static void AllocStorage (unsigned Label, void (*UseSeg) (), unsigned Size)
  84 /* Reserve Size bytes of BSS storage prefixed by a local label. */
  85 {
  86     /* Switch to the segment */
  87     UseSeg ();
  88
  89     /* Define the variable label */
  90     g_defdatalabel (Label);
  91
  92     /* Reserve space for the data */
  93     g_res (Size);
  94 }
  95
  96
  97
  98 static void ParseRegisterDecl (Declaration* Decl, int Reg)
  99 /* Parse the declaration of a register variable. Reg is the offset of the
 100 ** variable in the register bank.
 101 */
 102 {
 103     SymEntry* Sym;
 104
 105     /* Determine if this is a compound variable */
 106     int IsCompound = IsClassStruct (Decl->Type) || IsTypeArray (Decl->Type);
 107
 108     /* Get the size of the variable */
 109     unsigned Size = SizeOf (Decl->Type);
 110
 111     /* Save the current contents of the register variable on stack */
 112     F_AllocLocalSpace (CurrentFunc);
 113     g_save_regvars (Reg, Size);
 114
 115     /* Add the symbol to the symbol table. We do that now, because for register
 116     ** variables the current stack pointer is implicitly used as location for
 117     ** the save area.
 118     */
 119     Sym = AddLocalSym (Decl->Ident, Decl->Type, Decl->StorageClass, Reg);
 120
 121     /* Check for an optional initialization */
 122     if (CurTok.Tok == TOK_ASSIGN) {
 123
 124         ExprDesc Expr;
 125
 126         /* Skip the '=' */
 127         NextToken ();
 128
 129         /* Special handling for compound types */
 130         if (IsCompound) {
 131
 132             /* Switch to read only data and define a label for the
 133             ** initialization data.
 134             */
 135             unsigned InitLabel = AllocLabel (g_userodata);
 136
 137             /* Parse the initialization generating a memory image of the
 138             ** data in the RODATA segment. The function does return the size
 139             ** of the initialization data, which may be greater than the
 140             ** actual size of the type, if the type is a structure with a
 141             ** flexible array member that has been initialized. Since we must
 142             ** know the size of the data in advance for register variables,
 143             ** we cannot allow that here.
 144             */
 145             if (ParseInit (Sym->Type) != Size) {
 146                 Error ("Cannot initialize flexible array members of storage class `register'");
 147             }
 148
 149             /* Generate code to copy this data into the variable space */
 150             g_initregister (InitLabel, Reg, Size);
 151
 152         } else {
 153
 154             /* Parse the expression */
 155             hie1 (&Expr);
 156
 157             /* Convert it to the target type */
 158             TypeConversion (&Expr, Sym->Type);
 159
 160             /* Load the value into the primary */
 161             LoadExpr (CF_NONE, &Expr);
 162
 163             /* Store the value into the variable */
 164             g_putstatic (CF_REGVAR | TypeOf (Sym->Type), Reg, 0);
 165
 166         }
 167
 168         /* Mark the variable as referenced */
 169         Sym->Flags |= SC_REF;
 170     }
 171
 172     /* Cannot allocate a variable of zero size */
 173     if (Size == 0) {
 174         Error ("Variable `%s' has unknown size", Decl->Ident);
 175     }
 176 }
 177
 178
 179
 180 static void ParseAutoDecl (Declaration* Decl)
 181 /* Parse the declaration of an auto variable. */
 182 {
 183     unsigned  Flags;
 184     SymEntry* Sym;
 185
 186     /* Determine if this is a compound variable */
 187     int IsCompound = IsClassStruct (Decl->Type) || IsTypeArray (Decl->Type);
 188
 189     /* Get the size of the variable */
 190     unsigned Size = SizeOf (Decl->Type);
 191
 192     /* Check if this is a variable on the stack or in static memory */
 193     if (IS_Get (&StaticLocals) == 0) {
 194
 195         /* Add the symbol to the symbol table. The stack offset we use here
 196         ** may get corrected later.
 197         */
 198         Sym = AddLocalSym (Decl->Ident, Decl->Type,
 199                            Decl->StorageClass,
 200                            F_GetStackPtr (CurrentFunc) - (int) Size);
 201
 202         /* Check for an optional initialization */
 203         if (CurTok.Tok == TOK_ASSIGN) {
 204
 205             ExprDesc Expr;
 206
 207             /* Skip the '=' */
 208             NextToken ();
 209
 210             /* Special handling for compound types */
 211             if (IsCompound) {
 212
 213                 /* Switch to read only data and define a label for the
 214                 ** initialization data.
 215                 */
 216                 unsigned InitLabel = AllocLabel (g_userodata);
 217
 218                 /* Parse the initialization generating a memory image of the
 219                 ** data in the RODATA segment. The function will return the
 220                 ** actual size of the initialization data, which may be
 221                 ** greater than the size of the variable if it is a struct
 222                 ** that contains a flexible array member and we're not in
 223                 ** ANSI mode.
 224                 */
 225                 Size = ParseInit (Sym->Type);
 226
 227                 /* Now reserve space for the variable on the stack and correct
 228                 ** the offset in the symbol table entry.
 229                 */
 230                 Sym->V.Offs = F_ReserveLocalSpace (CurrentFunc, Size);
 231
 232                 /* Next, allocate the space on the stack. This means that the
 233                 ** variable is now located at offset 0 from the current sp.
 234                 */
 235                 F_AllocLocalSpace (CurrentFunc);
 236
 237                 /* Generate code to copy the initialization data into the
 238                 ** variable space
 239                 */
 240                 g_initauto (InitLabel, Size);
 241
 242             } else {
 243
 244                 /* Allocate previously reserved local space */
 245                 F_AllocLocalSpace (CurrentFunc);
 246
 247                 /* Setup the type flags for the assignment */
 248                 Flags = (Size == SIZEOF_CHAR)? CF_FORCECHAR : CF_NONE;
 249
 250                 /* Parse the expression */
 251                 hie1 (&Expr);
 252
 253                 /* Convert it to the target type */
 254                 TypeConversion (&Expr, Sym->Type);
 255
 256                 /* If the value is not const, load it into the primary.
 257                 ** Otherwise pass the information to the code generator.
 258                 */
 259                 if (ED_IsConstAbsInt (&Expr)) {
 260                     Flags |= CF_CONST;
 261                 } else {
 262                     LoadExpr (CF_NONE, &Expr);
 263                     ED_MakeRVal (&Expr);
 264                 }
 265
 266                 /* Push the value */
 267                 g_push (Flags | TypeOf (Sym->Type), Expr.IVal);
 268
 269             }
 270
 271             /* Mark the variable as referenced */
 272             Sym->Flags |= SC_REF;
 273
 274             /* Make note of auto variables initialized in current block.
 275                We abuse the Collection somewhat by using it to store line
 276                numbers. */
 277             CollReplace (&CurrentFunc->LocalsBlockStack, (void *)(long)GetCurrentLine (),
 278                 CollCount (&CurrentFunc->LocalsBlockStack) - 1);
 279
 280         } else {
 281             /* Non-initialized local variable. Just keep track of
 282             ** the space needed.
 283             */
 284             F_ReserveLocalSpace (CurrentFunc, Size);
 285         }
 286
 287     } else {
 288
 289         unsigned DataLabel;
 290
 291
 292         /* Static local variables. */
 293         Decl->StorageClass = (Decl->StorageClass & ~SC_AUTO) | SC_STATIC;
 294
 295         /* Generate a label, but don't define it */
 296         DataLabel = GetLocalLabel ();
 297
 298         /* Add the symbol to the symbol table. */
 299         Sym = AddLocalSym (Decl->Ident, Decl->Type, Decl->StorageClass, DataLabel);
 300
 301         /* Allow assignments */
 302         if (CurTok.Tok == TOK_ASSIGN) {
 303
 304             ExprDesc Expr;
 305
 306             /* Skip the '=' */
 307             NextToken ();
 308
 309             if (IsCompound) {
 310
 311                 /* Switch to read only data and define a label for the
 312                 ** initialization data.
 313                 */
 314                 unsigned InitLabel = AllocLabel (g_userodata);
 315
 316                 /* Parse the initialization generating a memory image of the
 317                 ** data in the RODATA segment.
 318                 */
 319                 Size = ParseInit (Sym->Type);
 320
 321                 /* Allocate space for the variable */
 322                 AllocStorage (DataLabel, g_usebss, Size);
 323
 324                 /* Generate code to copy this data into the variable space */
 325                 g_initstatic (InitLabel, DataLabel, Size);
 326
 327             } else {
 328
 329                 /* Allocate space for the variable */
 330                 AllocStorage (DataLabel, g_usebss, Size);
 331
 332                 /* Parse the expression */
 333                 hie1 (&Expr);
 334
 335                 /* Convert it to the target type */
 336                 TypeConversion (&Expr, Sym->Type);
 337
 338                 /* Load the value into the primary */
 339                 LoadExpr (CF_NONE, &Expr);
 340
 341                 /* Store the value into the variable */
 342                 g_putstatic (TypeOf (Sym->Type), DataLabel, 0);
 343             }
 344
 345             /* Mark the variable as referenced */
 346             Sym->Flags |= SC_REF;
 347
 348         } else {
 349
 350             /* No assignment - allocate a label and space for the variable */
 351             AllocStorage (DataLabel, g_usebss, Size);
 352
 353         }
 354     }
 355
 356     /* Cannot allocate a variable of zero size */
 357     if (Size == 0) {
 358         Error ("Variable `%s' has unknown size", Decl->Ident);
 359     }
 360 }
 361
 362
 363
 364 static void ParseStaticDecl (Declaration* Decl)
 365 /* Parse the declaration of a static variable. */
 366 {
 367     unsigned Size;
 368
 369     /* Generate a label, but don't define it */
 370     unsigned DataLabel = GetLocalLabel ();
 371
 372     /* Add the symbol to the symbol table. */
 373     SymEntry* Sym = AddLocalSym (Decl->Ident, Decl->Type,
 374                                  Decl->StorageClass,
 375                                  DataLabel);
 376
 377     /* Static data */
 378     if (CurTok.Tok == TOK_ASSIGN) {
 379
 380         /* Initialization ahead, switch to data segment and define the label.
 381         ** For arrays, we need to check the elements of the array for
 382         ** constness, not the array itself.
 383         */
 384         if (IsQualConst (GetBaseElementType (Sym->Type))) {
 385             g_userodata ();
 386         } else {
 387             g_usedata ();
 388         }
 389         g_defdatalabel (DataLabel);
 390
 391         /* Skip the '=' */
 392         NextToken ();
 393
 394         /* Allow initialization of static vars */
 395         Size = ParseInit (Sym->Type);
 396
 397         /* Mark the variable as referenced */
 398         Sym->Flags |= SC_REF;
 399
 400     } else {
 401
 402         /* Get the size of the variable */
 403         Size = SizeOf (Decl->Type);
 404
 405         /* Allocate a label and space for the variable in the BSS segment */
 406         AllocStorage (DataLabel, g_usebss, Size);
 407
 408     }
 409
 410     /* Cannot allocate a variable of zero size */
 411     if (Size == 0) {
 412         Error ("Variable `%s' has unknown size", Decl->Ident);
 413     }
 414 }
 415
 416
 417
 418 static void ParseOneDecl (const DeclSpec* Spec)
 419 /* Parse one variable declaration */
 420 {
 421     Declaration Decl;           /* Declaration data structure */
 422
 423
 424     /* Read the declaration */
 425     ParseDecl (Spec, &Decl, DM_NEED_IDENT);
 426
 427     /* Set the correct storage class for functions */
 428     if ((Decl.StorageClass & SC_FUNC) == SC_FUNC) {
 429         /* Function prototypes are always external */
 430         if ((Decl.StorageClass & SC_EXTERN) == 0) {
 431             Warning ("Function must be extern");
 432         }
 433         Decl.StorageClass |= SC_EXTERN;
 434     }
 435
 436     /* If we don't have a name, this was flagged as an error earlier.
 437     ** To avoid problems later, use an anonymous name here.
 438     */
 439     if (Decl.Ident[0] == '\0') {
 440         AnonName (Decl.Ident, "param");
 441     }
 442
 443     /* If the symbol is not marked as external, it will be defined now */
 444     if ((Decl.StorageClass & SC_EXTERN) == 0) {
 445         Decl.StorageClass |= SC_DEF;
 446     }
 447
 448     /* Handle anything that needs storage (no functions, no typdefs) */
 449     if ((Decl.StorageClass & SC_FUNC) != SC_FUNC &&
 450          (Decl.StorageClass & SC_TYPEMASK) != SC_TYPEDEF) {
 451
 452         /* If we have a register variable, try to allocate a register and
 453         ** convert the declaration to "auto" if this is not possible.
 454         */
 455         int Reg = 0;    /* Initialize to avoid gcc complains */
 456         if ((Decl.StorageClass & SC_REGISTER) != 0 &&
 457             (Reg = F_AllocRegVar (CurrentFunc, Decl.Type)) < 0) {
 458             /* No space for this register variable, convert to auto */
 459             Decl.StorageClass = (Decl.StorageClass & ~SC_REGISTER) | SC_AUTO;
 460         }
 461
 462         /* Check the variable type */
 463         if ((Decl.StorageClass & SC_REGISTER) == SC_REGISTER) {
 464             /* Register variable */
 465             ParseRegisterDecl (&Decl, Reg);
 466         } else if ((Decl.StorageClass & SC_AUTO) == SC_AUTO) {
 467             /* Auto variable */
 468             ParseAutoDecl (&Decl);
 469         } else if ((Decl.StorageClass & SC_EXTERN) == SC_EXTERN) {
 470             /* External identifier - may not get initialized */
 471             if (CurTok.Tok == TOK_ASSIGN) {
 472                 Error ("Cannot initialize externals");
 473             }
 474             /* Add the external symbol to the symbol table */
 475             AddLocalSym (Decl.Ident, Decl.Type, Decl.StorageClass, 0);
 476         } else if ((Decl.StorageClass & SC_STATIC) == SC_STATIC) {
 477             /* Static variable */
 478             ParseStaticDecl (&Decl);
 479         } else {
 480             Internal ("Invalid storage class in ParseOneDecl: %04X", Decl.StorageClass);
 481         }
 482
 483     } else {
 484
 485         /* Add the symbol to the symbol table */
 486         AddLocalSym (Decl.Ident, Decl.Type, Decl.StorageClass, 0);
 487
 488     }
 489 }
 490
 491
 492
 493 void DeclareLocals (void)
 494 /* Declare local variables and types. */
 495 {
 496     /* Remember the current stack pointer */
 497     int InitialStack = StackPtr;
 498
 499     /* A place to store info about potential initializations of auto variables */
 500     CollAppend (&CurrentFunc->LocalsBlockStack, 0);
 501
 502     /* Loop until we don't find any more variables */
 503     while (1) {
 504
 505         /* Check variable declarations. We need to distinguish between a
 506         ** default int type and the end of variable declarations. So we
 507         ** will do the following: If there is no explicit storage class
 508         ** specifier *and* no explicit type given, *and* no type qualifiers
 509         ** have been read, it is assumed that we have reached the end of
 510         ** declarations.
 511         */
 512         DeclSpec Spec;
 513         ParseDeclSpec (&Spec, SC_AUTO, T_INT);
 514         if ((Spec.Flags & DS_DEF_STORAGE) != 0 &&       /* No storage spec */
 515             (Spec.Flags & DS_DEF_TYPE) != 0    &&       /* No type given */
 516             GetQualifier (Spec.Type) == T_QUAL_NONE) {  /* No type qualifier */
 517             break;
 518         }
 519
 520         /* Accept type only declarations */
 521         if (CurTok.Tok == TOK_SEMI) {
 522             /* Type declaration only */
 523             CheckEmptyDecl (&Spec);
 524             NextToken ();
 525             continue;
 526         }
 527
 528         /* Parse a comma separated variable list */
 529         while (1) {
 530
 531             /* Parse one declaration */
 532             ParseOneDecl (&Spec);
 533
 534             /* Check if there is more */
 535             if (CurTok.Tok == TOK_COMMA) {
 536                 /* More to come */
 537                 NextToken ();
 538             } else {
 539                 /* Done */
 540                 break;
 541             }
 542         }
 543
 544         /* A semicolon must follow */
 545         ConsumeSemi ();
 546     }
 547
 548     /* Be sure to allocate any reserved space for locals */
 549     F_AllocLocalSpace (CurrentFunc);
 550
 551     /* No auto variables were inited. No new block on the stack then. */
 552     if (CollLast (&CurrentFunc->LocalsBlockStack) == NULL) {
 553         CollPop (&CurrentFunc->LocalsBlockStack);
 554     }
 555
 556     /* In case we've allocated local variables in this block, emit a call to
 557     ** the stack checking routine if stack checks are enabled.
 558     */
 559     if (IS_Get (&CheckStack) && InitialStack != StackPtr) {
 560         g_cstackcheck ();
 561     }
 562 }