_optimizer.c

Go to the documentation of this file.

/*****************************************************************************
 * ugBASIC - an isomorphic BASIC language compiler for retrocomputers        *
 *****************************************************************************
 * Copyright 2021-2026 Marco Spedaletti (asimov@mclink.it)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *----------------------------------------------------------------------------
 * Concesso in licenza secondo i termini della Licenza Apache, versione 2.0
 * (la "Licenza"); è proibito usare questo file se non in conformità alla
 * Licenza. Una copia della Licenza è disponibile all'indirizzo:
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Se non richiesto dalla legislazione vigente o concordato per iscritto,
 * il software distribuito nei termini della Licenza è distribuito
 * "COSÌ COM'È", SENZA GARANZIE O CONDIZIONI DI ALCUN TIPO, esplicite o
 * implicite. Consultare la Licenza per il testo specifico che regola le
 * autorizzazioni e le limitazioni previste dalla medesima.
 ****************************************************************************/
 
 /* Zilog Z80 optimizations for ugBasic by 
  * Based on Motorola 6809 optimizations for ugBasic by S.Devulder
  *
  * The idea here is to look for specific patterns over consecutive (1 to 4)
  * lines of code generated by ugBasic compiler, and reorganize it locally
  * by another pattern that contains a more efficent code achieving the same
  * result.
  *
  * It does multiple passes over the source as local rewrites can be
  * applied on previous rewrites, resulting in a avalanche effects that
  * optimizes the source far away from one can guess from the basic patterns.
  *
  * The optimizer can also perform some data flow analysis. It can for
  * instance see that one of the accumulator is $00 to simplify code. It can
  * also detect that some data in memory are written but never read. These
  * are called dead-data. It will then remove all reference to these data in
  * the code making it smaller and faster (as a useless write is not
  * performed anymore).
  *
  * Real full data-flow analysis should normally be able to detect data which
  * is written two times in a row whithout being read in-between. These are
  * also called dead-data since the first written value is also lost. These
  * dead-data typically appear during the avalanche effect occuring during
  * previous optimizations passes. Write operation to these dead-data can
  * also be removed harmlessly.
  *
  * Unfortunately this version of the optimized doesn't have yet a complete
  * data-flow analyzer. Instead, heuristics is used to guess whether a memory
  * operation accesses a dead data. In that case the optimizer will indicate
  * in the commented-out code that the data is *presumed dead*. The
  * heuristics are carefully choosen from the patterns generated by ugBasic
  * and make good guesses. But if you consider these as too dangerous you
  * can disable all of them with the "ALLOW_UNSAFE" flag below.
  *
  * Last the optimizer will also attempt to reorganize the data to get a
  * faster & shorter code. Some data will be "inlined" in the code, making
  * the code auto-modifiable which is no problem for the mc6809. And some
  * "heavily used" data will be moved into the direct-page location for
  * faster accesses.
  */
 
/****************************************************************************
 * INCLUDE SECTION 
 ****************************************************************************/
 
#include "../../ugbc.h"
#include <stdarg.h>
 
/****************************************************************************
 * CODE SECTION 
 ****************************************************************************/
 
#define DIRECT_PAGE     0x2100
#define LOOK_AHEAD      5
#define ALLOW_UNSAFE    1
#define KEEP_COMMENTS   1
 
#define DO_DIRECT_PAGE  1
#define DO_INLINE       1
#define DO_UNREAD       1
 
/* returns an UPPER-cased char */
static inline char _toUpper(char a) {
    return (a>='a' && a<='z') ? a-'a'+'A' : a;
}
 
/* returns true if char is end of line ? */
static inline int _eol(char c) {
    return c=='\0' || c=='\n';
}
 
/* returns true if both char matches */
static inline int _eq(char pat, char txt) {
    return (pat<=' ') ? (txt<=' ') : (_toUpper(pat)==_toUpper(txt));
}
 
/* returns true if the POBuffer matches a comment or and empty line */
int isAComment( POBuffer buf ) {
    char * _buffer = buf->str;
 
    if ( ! *_buffer ) {
        return 1;
    }
    if ( *_buffer == '\r' || *_buffer == '\n' ) {
        return 1;
    }
    while( * _buffer ) {
        if ( *_buffer == ' ' || *_buffer == '\t' ) { 
            ++_buffer;
        } else if ( *_buffer == ';' ) {
            return 1;
        } else {
            return 0;
        }
    }
    return 0;
}
 
/* number of lines changed */
static int change        = 0;
static int peephole_pass = 0;
static int num_dp        = 0; /* number of variables relocated to direct-page */
static int num_inlined   = 0; /* number of variables inlined */
static int num_unread    = 0; /* number of variables not read */
 
#ifdef __GNUC__
static void optim(POBuffer buf, const char *rule, const char *repl, ...)
    __attribute__ ((format (printf, 3, 4)));
#endif
 
#define R__(X)  #X
#define R_(X)  R__(X)
#define RULE "r" R_(__LINE__) " "
 
/* replaces the POBuffer with an optimized code */
/* original POBuffer is kept as comment */
static void optim(POBuffer buf, const char *rule, const char *repl, ...) {
    va_list ap;
    POBuffer tmp = TMP_BUF;
    char *s;
 
    va_start(ap, repl);
    po_buf_cpy(tmp, "");
 
    /* add our own comment if any */
    if(rule) po_buf_printf(tmp, "; peephole(%d): %s\n", peephole_pass, rule);
 
    /* comment out line */
    po_buf_cat(tmp, ";");
 
    /* copy upto the end of string or upto end of string */
    if ( (s = strchr(buf->str, '\n')) != NULL) *s = '\0'; /* cut at \n */
    po_buf_cat(tmp, buf->str);
    if( s != NULL ) po_buf_add(tmp, *s++ = '\n'); /* restore \n */
 
    /* insert replacement if provided */
    if(repl) {
        po_buf_vprintf(tmp, repl, ap);
        po_buf_cat(tmp, "\n");
    }
 
    /* copy remaining comments */
    if(s) po_buf_cat(tmp, s);
 
    /* write result back into input POBuffer */
    po_buf_cpy(buf, tmp->str);
 
    /* one more change */
    ++change;
 
    va_end(ap);
}
 
/* returns true if the POBuffer matches a zero value */
static int isZero(char *s) {
    if(*s == '$') ++s;
    while(*s == '0') ++s;
    return _eq(' ', *s);
}
static int _isZero(POBuffer buf) {
    return buf!=NULL && isZero(buf->str);
}
 
/* perform basic peephole optimization with a length-4 look-ahead */
static void basic_peephole(POBuffer buf[LOOK_AHEAD], int zA, int zB) {
    /* allows presumably safe operations */
    int unsafe = ALLOW_UNSAFE;
 
    /* various local buffers */
    POBuffer v1 = TMP_BUF;
    POBuffer v2 = TMP_BUF;
    POBuffer v3 = TMP_BUF;
    POBuffer v4 = TMP_BUF;
    
    /* a bunch of rules */
 
    // ;Instead of:
    //  ld a,0
    // ;Try this:
    //  xor a    ;disadvantages: changes flags
    // ;or
    //  sub a    ;disadvantages: changes flags
    // ; -> save 1 byte and 3 T-states    
    if( po_buf_match( buf[0], " LD *, 0", v1) && strchr( "A", _toUpper(*v1->str) ) != NULL ) {
        optim( buf[0], RULE "(LD A, 0)->(XOR A)", "\tXOR %c", _toUpper(*v1->str) );
    }
 
    // ;Instead of
    // ld b,$20
    // ld c,$30
    // ;try this
    //     ld bc,$2030
    // ;or this
    //     ld bc,(b_num * 256) + c_num      ;where b_num goes to b register and c_num to c register
    // ; -> save 1 byte and 4 T-states
    if( po_buf_match( buf[0], " LD B, $*", v1) && po_buf_match( buf[1], " LD C, $*", v2) ) {
        optim( buf[0], RULE "(LD B, x; LD C, x)->(LD BC, xx)", "\tLD BC, ($%s * 256) + $%s", v1->str, v2->str );
        optim( buf[1], "", NULL );
    }
 
    //
    if( po_buf_match( buf[0], " LD A, *", v1) && 
        po_buf_match( buf[1], " LD (*), A", v2) &&
        po_buf_match( buf[2], " LD A, *", v3) &&
        po_buf_strcmp(v1,v3)==0
        ) {
        optim( buf[2], RULE "(LD A, x; LD (x), A; LD A, x)->(LD A, x; LD (x), A)", NULL );
    }
 
    if( po_buf_match(buf[0], " LD HL, $*", v1)
    &&  po_buf_match(buf[1], " LD A, $*", v2)
    && (strtol(v1->str, NULL, 16) == strtol(v2->str, NULL, 16))
        ) {
        optim(buf[0], RULE "(LD HL, LD A, same value)->(LD A)", NULL );
    }
 
    // ;Instead of
    // ld a,$42
    // ld (hl),a
    // ;try this
    // ld (hl),$42
    // ; -> save 1 byte and 4 T-states
    // if( po_buf_match( buf[0], " LD A, $*", v1) && 
    //     po_buf_match( buf[1], " LD (HL), A")
    //     ) {
    //  optim( buf[0], RULE "(LD A, x; LD (HL), A)->(LD (HL), x)", "\tLD HL, $%s", v1->str );
    //  optim( buf[1], NULL, NULL );
    // }
 
    // ;Instead of
    //     ld A, (var)
    //     inc a
    //     ld (var),a
    // ;try this    ;Note: if hl is not tied up, use indirection:
    //     ld hl,var
    //     inc (hl)
    //     ld A, (hl) ;if you don't need (hl) in a, delete this line
    // ; -> save 2 bytes and 2 T-states
    // if( po_buf_match( buf[0], " LD A, (*)", v1) && 
    //     po_buf_match( buf[1], " INC A") &&
    //     po_buf_match( buf[2], " LD (*), A", v2 ) &&
    //     po_buf_strcmp( v1, v2 ) == 0
    //     ) {
    //  optim( buf[0], RULE "(LD A, (x); INC A; LD (x), A)->(LD HL, x; INC (HL); LD A, (HL)", "\tLD HL, %s", v1->str );
    //  optim( buf[1], NULL, "\tINC (HL)" );
    //  optim( buf[2], NULL, "\tLD A, (HL)" );
    // }
 
    // ; Instead of :
    // ld a, (hl)
    // ld (de), a
    // inc hl
    // inc de
    // ; Use :
    // ldi
    // inc bc
    // ; -> save 1 byte and 4 T-states
    // if( po_buf_match( buf[0], " LD A, (HL)") && 
    //     po_buf_match( buf[1], " LD (DE), A" ) &&
    //     po_buf_match( buf[2], " INC HL" ) &&
    //     po_buf_match( buf[3], " INC DE" )
    //     ) {
    //  optim( buf[0], RULE "(LD A, (HL); LD (DE), A; INC HL; INC DE)->(LDI; INC BC)", "\tLDI" );
    //  optim( buf[1], NULL, "\tINC BC" );
    //  optim( buf[2], NULL, NULL );
    //  optim( buf[3], NULL, NULL );
    // }
 
    // ;Instead of:
    //  cp 0
    // ;Use
    //  or a
    // ; -> save 1 byte and 3 T-states
    // if( po_buf_match( buf[0], " CP 0") ) {
    //  optim( buf[0], RULE "(CP 0)->(OR A)", "\tOR A" );
    // }
 
    //   xor %11111111
    // ; >
    //   cpl
    // ; -> save 1 byte and 3 T-states
    if( po_buf_match( buf[0], " XOR $FF") ) {
        optim( buf[0], RULE "(XOR $FF)->(CPL)", "\tCPL" );
    }
 
    // ;Instead of
    //     ld de,767
    //     or a       ;reset carry so sbc works as a sub
    //     sbc hl,de
    // ;try this
    //     ld de,-767 ;negation of de
    //     add hl,de
    // ; -> 2 bytes and 8 T-states !
    // if( 
    //     po_buf_match( buf[0], " LD DE, $*", v1 ) &&
    //     po_buf_match( buf[1], " OR A" ) &&
    //     po_buf_match( buf[2], " SBC HL, DE" ) 
    // ) {
    //  optim( buf[0], RULE "(LD DE, x; OR A; SBC HL, DE)->(LD DE, -x; ADD HL, DE)", "\tLD DE, -$%s", v1->str );
    //  optim( buf[1], NULL, "\tADD HL, DE" );
    // }
 
    // ;Instead of
    //   sla l
    //   rl h         ; I've actually seen this!
    // ; >
    //   add hl,hl
    // ; -> save 3 bytes and 5 T-states
    if( 
        po_buf_match( buf[0], " SLA L" ) &&
        po_buf_match( buf[1], " RL H" )
    ) {
        optim( buf[0], RULE "(SLA+RL)->(ADD)", "\tADD HL, HL" );
        optim( buf[1], NULL, NULL );
    }
 
    // ; Instead of
    //   and 1
    //   cp 1
    //   jr z,foo
    // ; >
    //   and 1         ;and sets zero flag, no need for cp
    //   jr nz,foo
    // ; -> save 2 bytes and 7 T-states
    // if( 
    //     po_buf_match( buf[0], " AND $*", v1 ) &&
    //     po_buf_match( buf[1], " CP $*", v2 ) &&
    //     po_buf_match( buf[2], " JR Z, *", v3 ) &&
    //     po_buf_strcmp( v1, v2 ) == 0
    // ) {
    //  optim( buf[1], NULL, NULL );
    //  optim( buf[2], RULE "(AND+CP+JZ)->(AND+JNZ)", " JR NZ, %s", v3->str );
    // }
 
    // ;Instead of
    // call xxxx
    // ret
    // ;try this
    // jp xxxx
    // ;only do this if the pushed pc to stack is not passed to the call. Example: some kind of inline vputs.
    // ; -> save 1 byte and 17 T-states
    if( 
        po_buf_match( buf[0], " CALL *", v1 ) &&
        po_buf_match( buf[1], " RET" )
    ) {
        optim( buf[0], RULE "(CALL+RET)->(JP)", "\tJP %s", v1->str );
        optim( buf[1], NULL, NULL );
    }
 
    // ;Never use:
    //     dec B
    //     jr NZ,loop    ;I have seen this...
    // ;Use:
    //     djnz loop
    // ; save 1 byte and 3 T-states
    if( 
        po_buf_match( buf[0], " DEC B" ) &&
        po_buf_match( buf[1], " JR NZ, *", v1 )
    ) {
        optim( buf[0], RULE "(DEC B+JR NZ)->(DJNZ)", "\tDJNZ %s", v1->str );
        optim( buf[1], NULL, NULL );
    }
 
    if( 
        po_buf_match( buf[0], " LD A, *", v1 ) &&
        po_buf_match( buf[2], " LD A, *", v3 ) &&
        po_buf_strcmp( v1, v3 ) == 0
    ) {
        optim( buf[2], RULE "(LD A, *; LD A, *)->(LD, A)", NULL );
    }
 
}
 
/* optimizations related to variables */
 
/* variables database */
static struct {
    struct var {
        char *name;
#define NO_REORG  1
#define NO_DP     2
#define NO_INLINE 4
#define NO_REMOVE 8
        int flags;
        int size;
        int nb_rd;
        int nb_wr;
        int offset; /* 0=unchanged, >0 offset to page 0; -1 = candidate for inlining, -2 = inlined */
        char *init;
    } *tab;
    int capacity;
    int size;
    int page0_max;
} vars;
 
/* clears the database */
static void vars_clear(void) {
    int i;
    for(i=0; i<vars.size; ++i) {
        struct var *v = &vars.tab[i];
        free(v->name);
        if(v->init) free(v->init);
    }
    vars.size = 0;
    vars.page0_max = 0;
}
 
/* gets (or creates) an entry for a variable from the data-base */
struct var *vars_get(POBuffer _name) {
    char *name = _name->str;
    struct var *ret = NULL;
    int i;
 
    char *s=strchr(name,'+');
    if(s) *s='\0';
 
    for(i=0; i<vars.size ; ++i) {
        if(strcmp(vars.tab[i].name, name)==0) {
            ret = &vars.tab[i];
        }
    }
    if(ret == NULL) {
        if(vars.size == vars.capacity) {
            vars.capacity += 16;
            vars.tab = realloc(vars.tab, sizeof(*vars.tab)*vars.capacity);
        }
        ret = &vars.tab[vars.size++];
        ret->name   = strdup(name);
        ret->flags  = 0;
        ret->size   = 0;
        ret->nb_rd  = 0;
        ret->nb_wr  = 0;
        ret->offset = 0;
        ret->init   = NULL;
    }
    if(s) *s='+';
 
    return ret;
}
 
static int vars_ok(POBuffer name) {
 
    if(po_buf_match(name, "^_Tstr"))   return 0;
    if(po_buf_match(name, "_^_Tstr"))   return 0;
    if(po_buf_match(name, "_label"))  return 0;
 
    if(name->str[0]=='_')      return 1;
    if(po_buf_match(name, "CLIP"))    return 1;
    if(po_buf_match(name, "XCUR"))    return 1;
    if(po_buf_match(name, "YCUR"))    return 1;
    if(po_buf_match(name, "CURRENT")) return 1;
    if(po_buf_match(name, "FONT"))    return 1;
    if(po_buf_match(name, "TEXT"))    return 1;
    if(po_buf_match(name, "LAST"))    return 1;
    if(po_buf_match(name, "XGR"))     return 1;
    if(po_buf_match(name, "YGR"))     return 1;
    if(po_buf_match(name, "FREE_"))   return 1;
    
    return 0;
}
 
/* look for variable uses and collect data about he variables */
static void vars_scan(POBuffer buf[LOOK_AHEAD]) {
    POBuffer tmp = TMP_BUF;
    POBuffer arg = TMP_BUF;
    POBuffer ofs = TMP_BUF;
 
    // if( match( buf[0], " * _*+", NULL, buf) ) {
        // struct var *v = vars_get(buf);
        // v->flags |= NO_INLINE;
    // }
 
    if( po_buf_match( buf[0], " LD *, (*+*)",  tmp, arg, ofs ) ) { if(vars_ok(arg)) {
        struct var *v = vars_get(arg);
        v->nb_rd++;
    } } else if( po_buf_match( buf[0], " LD *, (*)",  tmp, arg ) ) { if(vars_ok(arg)) {
        struct var *v = vars_get(arg);
        v->nb_rd++;
    } }
 
    if( po_buf_match( buf[0], " LD *, *",  tmp, arg ) &&
        strstr("A B C D E AD BC DE HL IX IY", tmp->str)!=NULL
        ) if(vars_ok(arg)) {
        struct var *v = vars_get(arg);
        v->nb_rd++;
    }
 
    if (po_buf_match( buf[0], " LD (*+*), *", arg, ofs, tmp) ) { if(vars_ok(arg)) {
        struct var *v = vars_get(arg);
        v->nb_wr++;
    } } else if (po_buf_match( buf[0], " LD (*), *", arg, tmp) ) { if(vars_ok(arg)) {
        struct var *v = vars_get(arg);
        v->nb_wr++;
    } }
 
    if (po_buf_match( buf[0], " LD *, *", arg, tmp) &&
        strstr("A B C D E AD BC DE HL IX IY", tmp->str)!=NULL        
        ) if(vars_ok(arg)) {
        struct var *v = vars_get(arg);
        v->nb_wr++;
    }
 
    if( po_buf_match( buf[0], " *: defs *", tmp, arg) && vars_ok(tmp)) {
        struct var *v = vars_get(tmp);
        v->size = atoi(arg->str);
        v->init = strdup("1-1");
    }
 
    if( po_buf_match(buf[0], " *: defb *", tmp, arg) && vars_ok(tmp) && strchr(buf[0]->str,',')==NULL) {
        struct var *v = vars_get(tmp);
        v->size = 1;
        v->init = strdup(isZero(arg->str) ? "1-1" : arg->str);
    }
 
    if( po_buf_match(buf[0], " *: defw *", tmp, arg) && vars_ok(tmp) && strchr(buf[0]->str,',')==NULL) {
        struct var *v = vars_get(tmp);
        v->size = 2;
        v->init = strdup(arg->str);
    }
 
}
 
/* compares two variables according to their access-count */
static int vars_cmp(const void *_a, const void *_b) {
    const struct var *a = _a;
    const struct var *b = _b;
 
    int diff = ((a->nb_rd + a->nb_wr) - (b->nb_rd + b->nb_wr));
 
    return -(diff!=0 ? diff : strcmp(a->name, b->name)); // Ttmp < Tstr
}
 
/* removes unread variables */
static void vars_remove(Environment * _environment, POBuffer buf[LOOK_AHEAD]) {
    POBuffer var = TMP_BUF;
    POBuffer op  = TMP_BUF;
    POBuffer ofs = TMP_BUF;
    
    if(!DO_UNREAD) return;
    
    /* unread */
    if(po_buf_match( buf[0], " LD (*+*), *", var, ofs, op) && vars_ok(var)) {
        struct var *v = vars_get(var);
        if(v->nb_rd == 0 && v->offset!=-2) {
            v->offset = 0;
            optim(buf[0], "unread", NULL);
            ++_environment->removedAssemblyLines;
        }
    } else if(po_buf_match( buf[0], " LD (*), *", var, op) && vars_ok(var)) {
        struct var *v = vars_get(var);
        if(v->nb_rd == 0 && v->offset!=-2) {
            v->offset = 0;
            optim(buf[0], "unread", NULL);
            ++_environment->removedAssemblyLines;
        }
    }
 
    /* remove changed variables */
    if(po_buf_match( buf[0], " *: DEFS ", var)
    || po_buf_match( buf[0], " *: DEFB ", var)
    || po_buf_match( buf[0], " *: DEFW ", var) ) if(vars_ok(var)) {
        struct var *v = vars_get(var);
        if(v->nb_rd==0 && 0<v->size && v->size<=4 && 0==(v->flags & NO_REMOVE) && v->offset!=-2) {
            optim(buf[0], "unread",NULL);
            ++num_unread;
            ++_environment->removedAssemblyLines;
        }             
     }
}            
 
/* collapse all heading spaces into a single tabulation */
static void out(FILE *f, POBuffer _buf) {
    char *s = _buf->str;
    int tab = 0;
    while(*s==' ' || *s=='\t') {tab = 1; ++s;}
    if(tab) fputs("\t", f);
    fputs(s, f);
}
 
/* remove space that is sometimes used in indexing mode and makes the optimized produce bad dcode */
static void fixes_indexed_syntax(POBuffer buf) {
    char *s = buf->str;
 
    /* not an instruction */
    if(!_eq(' ', *s)) return;
 
    /* skip over spaces */
    do ++s; while(*s && _eq(' ', *s));
 
    /* comment */
    if(*s==';') return;
 
    /* skip over instruction */
    while(*s && !_eq(' ', *s)) ++s;
    if(!*s) return;
 
    /* skip over spaces */
    do ++s; while(*s && _eq(' ', *s));
    if(!*s) return;
 
    /* process argment */
    do ++s; while(*s && !_eq(' ', *s));
    if(!*s) return;
 
}
 
/* various kind of optimization */
static int optim_pass( Environment * _environment, POBuffer buf[LOOK_AHEAD], PeepHoleOptimizationKind kind) {
    char fileNameOptimized[MAX_TEMPORARY_STORAGE];
    FILE * fileAsm;
    FILE * fileOptimized;
    int i;
    int still_to_go = LOOK_AHEAD;
 
    int line = 0;
    int zA = 0, zB = 0;
 
    int sourceLine = -1;
 
    _environment->currentSourceLineAnalyzed = 0;
    _environment->removedAssemblyLines = 0;
 
    adiline2( "POP:0:%d:%d", peephole_pass, kind );
 
    sprintf( fileNameOptimized, "%s.asm", get_temporary_filename( _environment ) );
        
    /* prepare for phase */
    switch(kind) {
        case DEADVARS:
        ++peephole_pass;
        num_unread  = 0;
        break;
        
        case RELOCATION1:
        ++peephole_pass;
        // vars_prepare_relocation();
        break;
        
        case RELOCATION2:
        break;
        
        case PEEPHOLE:
        ++peephole_pass;
        // vars_clear();
        break;
    }
 
    fileAsm = fopen( _environment->asmFileName, "rt" );
    if(fileAsm == NULL) {
        perror(_environment->asmFileName);
        exit(-1);
    }
 
    fileOptimized = fopen( fileNameOptimized, "wt" );
    if(fileOptimized == NULL) {
        perror(fileNameOptimized);
        exit(-1);
    }            
    
    /* clears our look-ahead buffers */
    for(i = 0; i<LOOK_AHEAD; ++i) po_buf_cpy(buf[i], "");
 
    /* global change flag */
    change = 0;
 
    while( still_to_go ) {
        /* print out oldest POBuffer */
        if ( line >= LOOK_AHEAD ) out(fileOptimized, buf[0]);
 
        /* shift the buffers */
        for(i=0; i<LOOK_AHEAD-1; ++i) po_buf_cpy(buf[i], buf[i+1]->str);
 
        /* read next line, merging adjacent comments */
        if(feof(fileAsm)) {
            --still_to_go;
            po_buf_cpy(buf[LOOK_AHEAD-1], "");
        } else do {
            /* read next line */
            po_buf_fgets( buf[LOOK_AHEAD-1], fileAsm );
            fixes_indexed_syntax(buf[LOOK_AHEAD-1]);
            /* merge comment with previous line if we do not overflow the POBuffer */
            if(isAComment(buf[LOOK_AHEAD-1])) {
                POBuffer ln = TMP_BUF;
                if (po_buf_match( buf[LOOK_AHEAD-1], " ; L:*", ln ) ) {
                    sourceLine = atoi( ln->str );
                    if ( ( sourceLine != _environment->currentSourceLineAnalyzed ) ) {
                        adiline3( "POL:0:%d:%d:%d", 
                            peephole_pass, _environment->currentSourceLineAnalyzed, _environment->removedAssemblyLines );
                        _environment->currentSourceLineAnalyzed = sourceLine;
                        _environment->removedAssemblyLines = 0;
                    }
                }                
                if(KEEP_COMMENTS) po_buf_cat(buf[LOOK_AHEAD-2], buf[LOOK_AHEAD-1]->str);
                po_buf_cpy(buf[LOOK_AHEAD-1], "");
            } else break;
        } while(!feof(fileAsm));
 
        switch(kind) {
            case PEEPHOLE:
            basic_peephole(buf, zA, zB);
            
            /* only look fo variable when no peephole has been performed */
            if(change == 0) vars_scan(buf);
            break;
            
            case DEADVARS:
            vars_remove(_environment, buf);
            break;
            
            case RELOCATION1:
            case RELOCATION2:
            // vars_relocate(buf);
            break;
        }
 
        ++line;
    }
 
    adiline3( "POL:0:%d:%d:%d", 
        peephole_pass, _environment->currentSourceLineAnalyzed, _environment->removedAssemblyLines );
 
    /* log info at the end of the file */
    switch(kind) {
        case PEEPHOLE:
        fprintf(fileOptimized, "; peephole: pass %d, %d change%s.\n", peephole_pass, 
            change, change>1 ?"s":"");
        break;
        
        case DEADVARS:
        fprintf(fileOptimized, "; peephole: pass %d, %d var%s removed.\n", peephole_pass, 
            num_unread, num_unread>1 ?"s":"");
        break;
        
        case RELOCATION2:
        fprintf(fileOptimized, "; peephole: pass %d, %d var%s moved to dp, %d var%s inlined.\n", peephole_pass, 
            num_dp, num_dp>1 ?"s":"", 
            num_inlined, num_inlined>1 ? "s":"");
        break;
        
        default:
        break;
    }
    
    (void)fclose(fileAsm);
    (void)fclose(fileOptimized);
 
    /* makes our generated file the new asm file */
    remove(_environment->asmFileName);
    BUILD_SAFE_MOVE( _environment, fileNameOptimized, _environment->asmFileName );
    
    return change;
}
 
/* main entry-point for this service */
void target_peephole_optimizer( Environment * _environment ) {
    if ( _environment->peepholeOptimizationLimit > 0 ) {
        POBuffer buf[LOOK_AHEAD];
        int i;
 
        for(i=0; i<LOOK_AHEAD; ++i) buf[i] = po_buf_new(0);
 
        int optimization_limit_count = _environment->peepholeOptimizationLimit;
 
        do {
            while(optim_pass(_environment, buf, PEEPHOLE)&&optimization_limit_count) {
                --optimization_limit_count;
            };
            optim_pass(_environment, buf, DEADVARS);
        } while(change&&optimization_limit_count);
        optim_pass(_environment, buf, RELOCATION1);
        optim_pass(_environment, buf, RELOCATION2);
 
        for(i=0; i<LOOK_AHEAD; ++i) buf[i] = po_buf_del(buf[i]);
        TMP_BUF_CLR;
    }
}
 
void target_finalize( Environment * _environment ) {
 
    if ( _environment->additionalInfoFile ) {
 
        char fileNameOptimized[MAX_TEMPORARY_STORAGE];
        FILE * fileAsm;
        FILE * fileListing;
        POBuffer bufferAsm = TMP_BUF;
        POBuffer bufferListing = TMP_BUF;
        POBuffer bufferLine = TMP_BUF;
        POBuffer bufferAddress = TMP_BUF;
        POBuffer bufferBytes = TMP_BUF;
 
        int sourceLine = -1;
 
        _environment->currentSourceLineAnalyzed = 0;
        _environment->bytesProduced = 0;
 
        adiline0( "A:0" );
 
        fileAsm = fopen( _environment->asmFileName, "rb" );
        if(fileAsm == NULL) {
            perror(_environment->asmFileName);
            exit(-1);
        }
 
        fileListing = fopen( _environment->listingFileName, "rb" );
        if(fileListing == NULL) {
            perror(_environment->listingFileName);
            exit(-1);
        }            
        
        while( !feof(fileAsm) && !feof(fileListing)) {
 
            po_buf_fgets( bufferAsm, fileAsm );
            int leftPadding = po_buf_trim( bufferAsm );
 
            if ( isAComment( bufferAsm ) ) {
                POBuffer ln = TMP_BUF;
                if (po_buf_match( bufferAsm, "; L:*", ln ) ) {
                    sourceLine = atoi( ln->str );
                    if ( ( sourceLine != _environment->currentSourceLineAnalyzed ) ) {
                        adiline2( "AB:0:%d:%d", 
                            _environment->currentSourceLineAnalyzed, _environment->bytesProduced );
                        _environment->currentSourceLineAnalyzed = sourceLine;
                        _environment->bytesProduced = 0;
                    }
                }
                continue;
            }
 
            *bufferListing->str = 0;
            int pos = ftell( fileListing );
            po_buf_trim( bufferAsm );
            while( !feof(fileListing) && (strstr( bufferListing->str, bufferAsm->str ) == NULL) ) {
                po_buf_fgets( bufferListing, fileListing );
                po_buf_trim( bufferListing );
            }
 
            if ( feof(fileListing) ) {
 
            } else {
                pos = ftell( fileListing );
                char * bufferAsmEscaped = strdup( bufferAsm->str );
                for( int i=0, c=strlen(bufferAsmEscaped); i<c; ++i ) {
                    if ( bufferAsmEscaped[i] == ':' ) {
                        bufferAsmEscaped[i] = 6;
                    }
                    if ( bufferAsmEscaped[i] == 9 ) {
                        bufferAsmEscaped[i] = ' ';
                    }
                }
                if ( po_buf_match( bufferListing, "* * * ", bufferLine, bufferAddress, bufferBytes ) ) {
                    _environment->bytesProduced += bufferBytes->len >> 1;
                }
                adiline4( "AL:0:%d:%*s%s", 
                    _environment->currentSourceLineAnalyzed, leftPadding, "", bufferAsmEscaped );
            }
 
            fseek( fileListing, pos, SEEK_SET );
            
        }
 
        if ( _environment->currentSourceLineAnalyzed ) {
            adiline1( "AF:0:%d", 
                _environment->bytesProduced );
        }
 
        (void)fclose(fileListing);
        (void)fclose(fileAsm);
 
    }
 
}