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

   1 /*****************************************************************************/
   2 /*                                                                           */
   3 /*                                coptpush.c                                 */
   4 /*                                                                           */
   5 /*                          Optimize push sequences                          */
   6 /*                                                                           */
   7 /*                                                                           */
   8 /*                                                                           */
   9 /* (C) 2001-2002 Ullrich von Bassewitz                                       */
  10 /*               Wacholderweg 14                                             */
  11 /*               D-70597 Stuttgart                                           */
  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 "codeent.h"
  38 #include "codeinfo.h"
  39 #include "coptpush.h"
  40
  41
  42
  43 /*****************************************************************************/
  44 /*                                   Code                                    */
  45 /*****************************************************************************/
  46
  47
  48
  49 unsigned OptPush1 (CodeSeg* S)
  50 /* Given a sequence
  51  *
  52  *     jsr     ldaxysp
  53  *     jsr     pushax
  54  *
  55  * If a/x are not used later, and Y is known, replace that by
  56  *
  57  *     ldy     #xx+2
  58  *     jsr     pushwysp
  59  *
  60  * saving 3 bytes and several cycles.
  61  */
  62 {
  63     unsigned I;
  64     unsigned Changes = 0;
  65
  66     /* Generate register info */
  67     CS_GenRegInfo (S);
  68
  69     /* Walk over the entries */
  70     I = 0;
  71     while (I < CS_GetEntryCount (S)) {
  72
  73         CodeEntry* L[2];
  74
  75         /* Get next entry */
  76         L[0] = CS_GetEntry (S, I);
  77
  78         /* Check for the sequence */
  79         if (CE_IsCallTo (L[0], "ldaxysp")               &&
  80             RegValIsKnown (L[0]->RI->In.RegY)           &&
  81             L[0]->RI->In.RegY < 0xFE                    &&
  82             (L[1] = CS_GetNextEntry (S, I)) != 0        &&
  83             !CE_HasLabel (L[1])                         &&
  84             CE_IsCallTo (L[1], "pushax")                &&
  85             !RegAXUsed (S, I+2)) {
  86
  87             /* Insert new code behind the pushax */
  88             const char* Arg;
  89             CodeEntry* X;
  90
  91             /* ldy     #xx+1 */
  92             Arg = MakeHexArg (L[0]->RI->In.RegY+2);
  93             X = NewCodeEntry (OP65_LDY, AM65_IMM, Arg, 0, L[0]->LI);
  94             CS_InsertEntry (S, X, I+2);
  95
  96             /* jsr pushwysp */
  97             X = NewCodeEntry (OP65_JSR, AM65_ABS, "pushwysp", 0, L[1]->LI);
  98             CS_InsertEntry (S, X, I+3);
  99
 100             /* Delete the old code */
 101             CS_DelEntries (S, I, 2);
 102
 103             /* Remember, we had changes */
 104             ++Changes;
 105
 106         }
 107
 108         /* Next entry */
 109         ++I;
 110
 111     }
 112
 113     /* Free the register info */
 114     CS_FreeRegInfo (S);
 115
 116     /* Return the number of changes made */
 117     return Changes;
 118 }
 119
 120
 121
 122 unsigned OptPush2 (CodeSeg* S)
 123 /* A sequence
 124  *
 125  *     jsr     ldaxidx
 126  *     jsr     pushax
 127  *
 128  * may get replaced by
 129  *
 130  *     jsr     pushwidx
 131  *
 132  */
 133 {
 134     unsigned I;
 135     unsigned Changes = 0;
 136
 137     /* Generate register info */
 138     CS_GenRegInfo (S);
 139
 140     /* Walk over the entries */
 141     I = 0;
 142     while (I < CS_GetEntryCount (S)) {
 143
 144         CodeEntry* L[2];
 145
 146         /* Get next entry */
 147         L[0] = CS_GetEntry (S, I);
 148
 149         /* Check for the sequence */
 150         if (CE_IsCallTo (L[0], "ldaxidx")               &&
 151             (L[1] = CS_GetNextEntry (S, I)) != 0        &&
 152             !CE_HasLabel (L[1])                         &&
 153             CE_IsCallTo (L[1], "pushax")) {
 154
 155             /* Insert new code behind the pushax */
 156             CodeEntry* X;
 157
 158             /* jsr pushwidx */
 159             X = NewCodeEntry (OP65_JSR, AM65_ABS, "pushwidx", 0, L[1]->LI);
 160             CS_InsertEntry (S, X, I+2);
 161
 162             /* Delete the old code */
 163             CS_DelEntries (S, I, 2);
 164
 165             /* Remember, we had changes */
 166             ++Changes;
 167
 168         }
 169
 170         /* Next entry */
 171         ++I;
 172
 173     }
 174
 175     /* Free the register info */
 176     CS_FreeRegInfo (S);
 177
 178     /* Return the number of changes made */
 179     return Changes;
 180 }
 181
 182
 183