outcode.c

   1 /**
   2  * Author: Humberto Naves (hsnaves@gmail.com)
   3  */
   4
   5 #include <stdio.h>
   6 #include <ctype.h>
   7
   8 #include "output.h"
   9 #include "utils.h"
  10
  11
  12 static
  13 void print_block (FILE *out, struct basicblock *block, int identsize, int reversecond)
  14 {
  15   element opel;
  16   int options = 0;
  17
  18   if (reversecond) options |= OPTS_REVERSECOND;
  19   opel = list_head (block->operations);
  20   while (opel) {
  21     struct operation *op = element_getvalue (opel);
  22     if (!(op->status & OP_STAT_DEFERRED)) {
  23       if (op != block->jumpop)
  24         print_operation (out, op, identsize, options);
  25     }
  26     opel = element_next (opel);
  27   }
  28   if (block->jumpop)
  29     print_operation (out, block->jumpop, identsize, options);
  30 }
  31
  32 static
  33 void print_block_recursive (FILE *out, struct basicblock *block)
  34 {
  35   element ref;
  36   struct basicedge *edge;
  37   int identsize = block->st->identsize;
  38   int revcond = block->status & BLOCK_STAT_REVCOND;
  39   int first = TRUE, isloop = FALSE;
  40
  41   if (g_verbosity > 1) {
  42     ident_line (out, identsize + 1);
  43     fprintf (out, "/** Block %d\n", block->node.dfsnum);
  44     if (block->type == BLOCK_SIMPLE){
  45       struct location *loc;
  46       loc = block->info.simple.begin;
  47       while (1) {
  48         ident_line (out, identsize + 1);
  49         fprintf (out, " * %s\n", allegrex_disassemble (loc->opc, loc->address, TRUE));
  50         if (loc++ == block->info.simple.end) break;
  51       }
  52     }
  53     ident_line (out, identsize + 1);
  54     fprintf (out, " */\n");
  55   }
  56
  57   if (block->status & BLOCK_STAT_ISSWITCHTARGET) {
  58     ref = list_head (block->inrefs);
  59     while (ref) {
  60       edge = element_getvalue (ref);
  61       if (edge->from->status & BLOCK_STAT_ISSWITCH) {
  62         ident_line (out, identsize);
  63         fprintf (out, "case %d:\n", edge->fromnum);
  64       }
  65       ref = element_next (ref);
  66     }
  67   }
  68
  69   if (block->status & BLOCK_STAT_HASLABEL) {
  70     fprintf (out, "\n");
  71     ident_line (out, identsize);
  72     fprintf (out, "label%d:\n", block->node.dfsnum);
  73   }
  74
  75   if (block->st->start == block && block->st->type == CONTROL_LOOP) {
  76     isloop = TRUE;
  77     ident_line (out, identsize);
  78     fprintf (out, "while (1) {\n");
  79   }
  80
  81   block->mark1 = 1;
  82   print_block (out, block, identsize + 1, revcond);
  83
  84   if (block->status & BLOCK_STAT_ISSWITCH) {
  85     revcond = TRUE;
  86     ident_line (out, identsize + 1);
  87     fprintf (out, "switch () {\n");
  88   }
  89
  90   if (revcond) ref = list_head (block->outrefs);
  91   else ref = list_tail (block->outrefs);
  92
  93   while (ref) {
  94     edge = element_getvalue (ref);
  95
  96     switch (edge->type) {
  97     case EDGE_BREAK:
  98     case EDGE_CONTINUE:
  99     case EDGE_INVALID:
 100     case EDGE_GOTO:
 101     case EDGE_IFENTER:
 102       ident_line (out, identsize + 1);
 103       if (first && list_size (block->outrefs) == 2 &&
 104           !(block->status & BLOCK_STAT_ISSWITCH) && edge->type != EDGE_IFENTER)
 105         ident_line (out, 1);
 106       break;
 107
 108     case EDGE_CASE:
 109     case EDGE_NEXT:
 110     case EDGE_RETURN:
 111     case EDGE_IFEXIT:
 112     case EDGE_UNKNOWN:
 113       break;
 114     }
 115
 116     switch (edge->type) {
 117     case EDGE_BREAK:
 118       fprintf (out, "break;\n");
 119       break;
 120     case EDGE_CONTINUE:
 121       fprintf (out, "continue;\n");
 122       break;
 123     case EDGE_INVALID:
 124     case EDGE_GOTO:
 125       fprintf (out, "goto label%d;\n", edge->to->node.dfsnum);
 126       break;
 127     case EDGE_UNKNOWN:
 128     case EDGE_IFEXIT:
 129       break;
 130     case EDGE_CASE:
 131       if (!edge->to->mark1)
 132         print_block_recursive (out, edge->to);
 133       break;
 134     case EDGE_NEXT:
 135     case EDGE_RETURN:
 136       print_block_recursive (out, edge->to);
 137       break;
 138     case EDGE_IFENTER:
 139       fprintf (out, "{\n");
 140       print_block_recursive (out, edge->to);
 141       ident_line (out, identsize + 1);
 142       fprintf (out, "}\n");
 143       break;
 144     }
 145
 146     if (revcond) ref = element_next (ref);
 147     else ref = element_previous (ref);
 148
 149     if ((block->status & BLOCK_STAT_HASELSE) && ref) {
 150       ident_line (out, identsize + 1);
 151       fprintf (out, "else\n");
 152     }
 153     first = FALSE;
 154   }
 155
 156   if (block->ifst) {
 157     if (block->ifst->hasendgoto) {
 158       ident_line (out, identsize + 1);
 159       fprintf (out, "goto label%d;\n", block->ifst->end->node.dfsnum);
 160     } else if (block->ifst->endfollow) {
 161       print_block_recursive (out, block->ifst->end);
 162     }
 163   }
 164
 165   if (block->status & BLOCK_STAT_ISSWITCH) {
 166     ident_line (out, identsize + 1);
 167     fprintf (out, "}\n");
 168   }
 169
 170   if (block->st->start == block && block->st->type == CONTROL_LOOP) {
 171     ident_line (out, identsize);
 172     fprintf (out, "}\n");
 173     if (block->st->hasendgoto) {
 174       ident_line (out, identsize);
 175       fprintf (out, "goto label%d;\n", block->st->end->node.dfsnum);
 176     } else if (block->st->endfollow) {
 177       print_block_recursive (out, block->st->end);
 178     }
 179   }
 180
 181 }
 182
 183 static
 184 void print_subroutine (FILE *out, struct subroutine *sub)
 185 {
 186   if (sub->import) { return; }
 187
 188   fprintf (out, "/**\n * Subroutine at address 0x%08X\n", sub->begin->address);
 189   fprintf (out, " */\n");
 190   print_subroutine_declaration (out, sub);
 191   fprintf (out, "\n{\n");
 192
 193   if (sub->haserror) {
 194     struct location *loc;
 195     for (loc = sub->begin; ; loc++) {
 196       fprintf (out, "%s\n", allegrex_disassemble (loc->opc, loc->address, TRUE));
 197       if (loc == sub->end) break;
 198     }
 199   } else {
 200     element el;
 201     reset_marks (sub);
 202
 203     el = list_head (sub->blocks);
 204     while (el) {
 205       struct basicblock *block = element_getvalue (el);
 206       if (!block->mark1)
 207         print_block_recursive (out, block);
 208       el = element_next (el);
 209     }
 210   }
 211   fprintf (out, "}\n\n");
 212 }
 213
 214 static
 215 void print_source (FILE *out, struct code *c, char *headerfilename)
 216 {
 217   uint32 i, j;
 218   element el;
 219
 220   fprintf (out, "#include <pspsdk.h>\n");
 221   fprintf (out, "#include \"%s\"\n\n", headerfilename);
 222
 223   for (i = 0; i < c->file->modinfo->numimports; i++) {
 224     struct prx_import *imp = &c->file->modinfo->imports[i];
 225
 226     fprintf (out, "/*\n * Imports from library: %s\n */\n", imp->name);
 227     for (j = 0; j < imp->nfuncs; j++) {
 228       struct prx_function *func = &imp->funcs[j];
 229       if (func->pfunc) {
 230         fprintf (out, "extern ");
 231         print_subroutine_declaration (out, func->pfunc);
 232         fprintf (out, ";\n");
 233       }
 234     }
 235     fprintf (out, "\n");
 236   }
 237
 238   el = list_head (c->subroutines);
 239   while (el) {
 240     struct subroutine *sub;
 241     sub = element_getvalue (el);
 242
 243     print_subroutine (out, sub);
 244     el = element_next (el);
 245   }
 246
 247 }
 248
 249 static
 250 void print_header (FILE *out, struct code *c, char *headerfilename)
 251 {
 252   uint32 i, j;
 253   char buffer[256];
 254   int pos = 0;
 255
 256   while (pos < sizeof (buffer) - 1) {
 257     char c = headerfilename[pos];
 258     if (!c) break;
 259     if (c == '.') c = '_';
 260     else c = toupper (c);
 261     buffer[pos++] =  c;
 262   }
 263   buffer[pos] = '\0';
 264
 265   fprintf (out, "#ifndef __%s\n", buffer);
 266   fprintf (out, "#define __%s\n\n", buffer);
 267
 268   for (i = 0; i < c->file->modinfo->numexports; i++) {
 269     struct prx_export *exp = &c->file->modinfo->exports[i];
 270
 271     fprintf (out, "/*\n * Exports from library: %s\n */\n", exp->name);
 272     for (j = 0; j < exp->nfuncs; j++) {
 273       struct prx_function *func = &exp->funcs[j];
 274       if (func->name) {
 275         fprintf (out, "void %s (void);\n",func->name);
 276       } else {
 277         fprintf (out, "void %s_%08X (void);\n", exp->name, func->nid);
 278       }
 279     }
 280     fprintf (out, "\n");
 281   }
 282
 283   fprintf (out, "#endif /* __%s */\n", buffer);
 284 }
 285
 286
 287 int print_code (struct code *c, char *prxname)
 288 {
 289   char buffer[64];
 290   char basename[32];
 291   FILE *cout, *hout;
 292
 293
 294   get_base_name (prxname, basename, sizeof (basename));
 295   sprintf (buffer, "%s.c", basename);
 296
 297   cout = fopen (buffer, "w");
 298   if (!cout) {
 299     xerror (__FILE__ ": can't open file for writing `%s'", buffer);
 300     return 0;
 301   }
 302
 303   sprintf (buffer, "%s.h", basename);
 304   hout = fopen (buffer, "w");
 305   if (!hout) {
 306     xerror (__FILE__ ": can't open file for writing `%s'", buffer);
 307     return 0;
 308   }
 309
 310
 311   print_header (hout, c, buffer);
 312   print_source (cout, c, buffer);
 313
 314   fclose (cout);
 315   fclose (hout);
 316   return 1;
 317 }