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

   1 /*****************************************************************************/
   2 /*                                                                           */
   3 /*                                loadexpr.c                                 */
   4 /*                                                                           */
   5 /*               Load an expression into the primary register                */
   6 /*                                                                           */
   7 /*                                                                           */
   8 /*                                                                           */
   9 /* (C) 2004-2009, 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 /* cc65 */
  37 #include "codegen.h"
  38 #include "error.h"
  39 #include "exprdesc.h"
  40 #include "global.h"
  41 #include "loadexpr.h"
  42
  43
  44
  45 /*****************************************************************************/
  46 /*                                   Code                                    */
  47 /*****************************************************************************/
  48
  49
  50
  51 static void LoadConstant (unsigned Flags, ExprDesc* Expr)
  52 /* Load the primary register with some constant value. */
  53 {
  54     switch (ED_GetLoc (Expr)) {
  55
  56         case E_LOC_ABS:
  57             /* Number constant */
  58             g_getimmed (Flags | TypeOf (Expr->Type) | CF_CONST, Expr->IVal, 0);
  59             break;
  60
  61         case E_LOC_GLOBAL:
  62             /* Global symbol, load address */
  63             g_getimmed ((Flags | CF_EXTERNAL) & ~CF_CONST, Expr->Name, Expr->IVal);
  64             break;
  65
  66         case E_LOC_STATIC:
  67         case E_LOC_LITERAL:
  68             /* Static symbol or literal, load address */
  69             g_getimmed ((Flags | CF_STATIC) & ~CF_CONST, Expr->Name, Expr->IVal);
  70             break;
  71
  72         case E_LOC_REGISTER:
  73             /* Register variable. Taking the address is usually not
  74              * allowed.
  75              */
  76             if (IS_Get (&AllowRegVarAddr) == 0) {
  77                 Error ("Cannot take the address of a register variable");
  78             }
  79             g_getimmed ((Flags | CF_REGVAR) & ~CF_CONST, Expr->Name, Expr->IVal);
  80             break;
  81
  82         case E_LOC_STACK:
  83             g_leasp (Expr->IVal);
  84             break;
  85
  86         default:
  87             Internal ("Unknown constant type: %04X", Expr->Flags);
  88     }
  89 }
  90
  91
  92
  93 void LoadExpr (unsigned Flags, struct ExprDesc* Expr)
  94 /* Load an expression into the primary register if it is not already there. */
  95 {
  96     if (ED_IsLVal (Expr)) {
  97
  98         /* Dereferenced lvalue */
  99         Flags |= TypeOf (Expr->Type);
 100         if (ED_NeedsTest (Expr)) {
 101             Flags |= CF_TEST;
 102         }
 103
 104         switch (ED_GetLoc (Expr)) {
 105
 106             case E_LOC_ABS:
 107                 /* Absolute: numeric address or const */
 108                 g_getstatic (Flags | CF_ABSOLUTE, Expr->IVal, 0);
 109                 break;
 110
 111             case E_LOC_GLOBAL:
 112                 /* Global variable */
 113                 g_getstatic (Flags | CF_EXTERNAL, Expr->Name, Expr->IVal);
 114                 break;
 115
 116             case E_LOC_STATIC:
 117             case E_LOC_LITERAL:
 118                 /* Static variable or literal in the literal pool */
 119                 g_getstatic (Flags | CF_STATIC, Expr->Name, Expr->IVal);
 120                 break;
 121
 122             case E_LOC_REGISTER:
 123                 /* Register variable */
 124                 g_getstatic (Flags | CF_REGVAR, Expr->Name, Expr->IVal);
 125                 break;
 126
 127             case E_LOC_STACK:
 128                 /* Value on the stack */
 129                 g_getlocal (Flags, Expr->IVal);
 130                 break;
 131
 132             case E_LOC_PRIMARY:
 133                 /* The primary register - just test if necessary */
 134                 if (Flags & CF_TEST) {
 135                     g_test (Flags);
 136                 }
 137                 break;
 138
 139             case E_LOC_EXPR:
 140                 /* Reference to address in primary with offset in Expr */
 141                 g_getind (Flags, Expr->IVal);
 142                 break;
 143
 144             default:
 145                 Internal ("Invalid location in LoadExpr: 0x%04X", ED_GetLoc (Expr));
 146         }
 147
 148         /* Handle bit fields. The actual type may have been casted or
 149          * converted, so be sure to always use unsigned ints for the
 150          * operations.
 151          */
 152         if (ED_IsBitField (Expr)) {
 153             unsigned F = CF_INT | CF_UNSIGNED | CF_CONST | (Flags & CF_TEST);
 154             /* Shift right by the bit offset */
 155             g_asr (F, Expr->BitOffs);
 156             /* And by the width */
 157             g_and (F, (0x0001U << Expr->BitWidth) - 1U);
 158         }
 159
 160         /* Expression was tested */
 161         ED_TestDone (Expr);
 162
 163     } else {
 164         /* An rvalue */
 165         if (ED_IsLocExpr (Expr)) {
 166             if (Expr->IVal != 0) {
 167                 /* We have an expression in the primary plus a constant
 168                  * offset. Adjust the value in the primary accordingly.
 169                  */
 170                 Flags |= TypeOf (Expr->Type);
 171                 g_inc (Flags | CF_CONST, Expr->IVal);
 172             }
 173         } else {
 174             /* Constant of some sort, load it into the primary */
 175             LoadConstant (Flags, Expr);
 176         }
 177
 178         /* Are we testing this value? */
 179         if (ED_NeedsTest (Expr)) {
 180             /* Yes, force a test */
 181             Flags |= TypeOf (Expr->Type);
 182             g_test (Flags);
 183             ED_TestDone (Expr);
 184         }
 185     }
 186
 187 }
 188
 189
 190