tools/mkbridge.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4
   5 #include "my_assert.h"
   6 #include "my_str.h"
   7
   8 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
   9 #define IS(w, y) !strcmp(w, y)
  10
  11 #include "protoparse.h"
  12
  13 static int is_x86_reg_saved(const char *reg)
  14 {
  15         static const char *nosave_regs[] = { "eax", "edx", "ecx" };
  16         int nosave = 0;
  17         int r;
  18
  19         for (r = 0; r < ARRAY_SIZE(nosave_regs); r++)
  20                 if (strcmp(reg, nosave_regs[r]) == 0)
  21                         nosave = 1;
  22
  23         return !nosave;
  24 }
  25
  26 static void out_toasm_x86(FILE *f, const char *sym_in,
  27         const char *sym_out, const struct parsed_proto *pp)
  28 {
  29         int must_save = 0;
  30         int sarg_ofs = 1; // stack offset to args, in DWORDs
  31         int args_repushed = 0;
  32         int argc_repush;
  33         int i;
  34
  35         argc_repush = pp->argc;
  36         if (pp->is_vararg)
  37                 argc_repush = ARRAY_SIZE(pp->arg); // hopefully enough?
  38
  39         for (i = 0; i < pp->argc; i++) {
  40                 if (pp->arg[i].reg != NULL)
  41                         must_save |= is_x86_reg_saved(pp->arg[i].reg);
  42         }
  43
  44         fprintf(f, ".global _%s\n", sym_in);
  45         fprintf(f, "_%s:\n", sym_in);
  46
  47         if (pp->argc_reg == 0) {
  48                 fprintf(f, "\tjmp %s\n\n", sym_out);
  49                 return;
  50         }
  51
  52         if (pp->argc_stack == 0 && !must_save && !pp->is_stdcall
  53              && !pp->is_vararg)
  54         {
  55                 // load arg regs
  56                 for (i = 0; i < pp->argc; i++) {
  57                         fprintf(f, "\tmovl %d(%%esp), %%%s\n",
  58                                 (i + sarg_ofs) * 4, pp->arg[i].reg);
  59                 }
  60                 fprintf(f, "\tjmp %s\n\n", sym_out);
  61                 return;
  62         }
  63
  64         // save the regs
  65         for (i = 0; i < pp->argc; i++) {
  66                 if (pp->arg[i].reg != NULL && is_x86_reg_saved(pp->arg[i].reg)) {
  67                         fprintf(f, "\tpushl %%%s\n", pp->arg[i].reg);
  68                         sarg_ofs++;
  69                 }
  70         }
  71
  72         // reconstruct arg stack
  73         for (i = argc_repush - 1; i >= 0; i--) {
  74                 if (pp->arg[i].reg == NULL) {
  75                         fprintf(f, "\tmovl %d(%%esp), %%eax\n",
  76                                 (i + sarg_ofs) * 4);
  77                         fprintf(f, "\tpushl %%eax\n");
  78                         sarg_ofs++;
  79                         args_repushed++;
  80                 }
  81         }
  82         // my_assert(args_repushed, pp->argc_stack);
  83
  84         // load arg regs
  85         for (i = 0; i < pp->argc; i++) {
  86                 if (pp->arg[i].reg != NULL) {
  87                         fprintf(f, "\tmovl %d(%%esp), %%%s\n",
  88                                 (i + sarg_ofs) * 4, pp->arg[i].reg);
  89                 }
  90         }
  91
  92         fprintf(f, "\n\t# %s\n", pp->is_stdcall ? "__stdcall" : "__cdecl");
  93         fprintf(f, "\tcall %s\n\n", sym_out);
  94
  95         if (args_repushed && !pp->is_stdcall)
  96                 fprintf(f, "\tadd $%d,%%esp\n", args_repushed * 4);
  97
  98         // restore regs
  99         for (i = pp->argc - 1; i >= 0; i--) {
 100                 if (pp->arg[i].reg != NULL && is_x86_reg_saved(pp->arg[i].reg))
 101                         fprintf(f, "\tpopl %%%s\n", pp->arg[i].reg);
 102         }
 103
 104         fprintf(f, "\tret\n\n");
 105 }
 106
 107 static void out_fromasm_x86(FILE *f, const char *sym,
 108         const struct parsed_proto *pp)
 109 {
 110         int sarg_ofs = 1; // stack offset to args, in DWORDs
 111         int saved_regs = 0;
 112         int argc_repush;
 113         int stack_args;
 114         int ret64;
 115         int i;
 116
 117         argc_repush = pp->argc;
 118         stack_args = pp->argc_stack;
 119         if (pp->is_vararg) {
 120                 argc_repush = ARRAY_SIZE(pp->arg); // hopefully enough?
 121                 stack_args = argc_repush - pp->argc_reg;
 122         }
 123
 124         ret64 = strstr(pp->ret_type.name, "int64") != NULL;
 125
 126         fprintf(f, "# %s", pp->is_stdcall ? "__stdcall" : "__cdecl");
 127         if (ret64)
 128                  fprintf(f, " ret64");
 129         fprintf(f, "\n.global %s\n", sym);
 130         fprintf(f, "%s:\n", sym);
 131
 132         if (pp->argc_reg == 0) {
 133                 //fprintf(f, "\tjmp _%s\n\n", sym);
 134                 fprintf(f, "\tjmp _%s", sym);
 135                 if (pp->is_stdcall && pp->argc > 0)
 136                         fprintf(f, "@%d", pp->argc * 4);
 137                 fprintf(f, "\n\n");
 138                 return;
 139         }
 140
 141         // at least sc sub_47B150 needs edx to be preserved
 142         // int64 returns use edx:eax - no edx save
 143         // we use ecx also as scratch
 144         fprintf(f, "\tpushl %%ecx\n");
 145         saved_regs++;
 146         sarg_ofs++;
 147         if (!ret64) {
 148                 fprintf(f, "\tpushl %%edx\n");
 149                 saved_regs++;
 150                 sarg_ofs++;
 151         }
 152
 153         // construct arg stack
 154         for (i = argc_repush - 1; i >= 0; i--) {
 155                 if (pp->arg[i].reg == NULL) {
 156                         fprintf(f, "\tmovl %d(%%esp), %%ecx\n",
 157                                 (sarg_ofs + stack_args - 1) * 4);
 158                         fprintf(f, "\tpushl %%ecx\n");
 159                         stack_args--;
 160                 }
 161                 else {
 162                         if (IS(pp->arg[i].reg, "ecx"))
 163                                 // must reload original ecx
 164                                 fprintf(f, "\tmovl %d(%%esp), %%ecx\n",
 165                                         (sarg_ofs - 2) * 4);
 166
 167                         fprintf(f, "\tpushl %%%s\n", pp->arg[i].reg);
 168                 }
 169                 sarg_ofs++;
 170         }
 171
 172         // no worries about calling conventions - always __cdecl
 173         fprintf(f, "\n\tcall _%s\n\n", sym);
 174
 175         if (sarg_ofs > saved_regs + 1)
 176                 fprintf(f, "\tadd $%d,%%esp\n",
 177                         (sarg_ofs - (saved_regs + 1)) * 4);
 178
 179         if (!ret64)
 180                 fprintf(f, "\tpopl %%edx\n");
 181         fprintf(f, "\tpopl %%ecx\n");
 182
 183         if (pp->is_stdcall && pp->argc_stack)
 184                 fprintf(f, "\tret $%d\n\n", pp->argc_stack * 4);
 185         else
 186                 fprintf(f, "\tret\n\n");
 187 }
 188
 189 int main(int argc, char *argv[])
 190 {
 191         FILE *fout, *fsyms_to, *fsyms_from, *fhdr;
 192         const struct parsed_proto *pp;
 193         char line[256];
 194         char sym_noat[256];
 195         char sym[256];
 196         char *p;
 197         int ret = 1;
 198
 199         if (argc != 5) {
 200                 printf("usage:\n%s <bridge.s> <toasm_symf> <fromasm_symf> <hdrf>\n",
 201                         argv[0]);
 202                 return 1;
 203         }
 204
 205         hdrfn = argv[4];
 206         fhdr = fopen(hdrfn, "r");
 207         my_assert_not(fhdr, NULL);
 208
 209         fsyms_from = fopen(argv[3], "r");
 210         my_assert_not(fsyms_from, NULL);
 211
 212         fsyms_to = fopen(argv[2], "r");
 213         my_assert_not(fsyms_to, NULL);
 214
 215         fout = fopen(argv[1], "w");
 216         my_assert_not(fout, NULL);
 217
 218         fprintf(fout, ".text\n\n");
 219         fprintf(fout, "# to asm\n\n");
 220
 221         while (fgets(line, sizeof(line), fsyms_to))
 222         {
 223                 next_word(sym, sizeof(sym), line);
 224                 if (sym[0] == 0 || sym[0] == ';' || sym[0] == '#')
 225                         continue;
 226
 227                 // IDA asm doesn't do '@' notation..
 228                 strcpy(sym_noat, sym);
 229                 p = strchr(sym_noat, '@');
 230                 if (p != NULL)
 231                         *p = 0;
 232
 233                 pp = proto_parse(fhdr, sym_noat);
 234                 if (pp == NULL)
 235                         goto out;
 236
 237                 out_toasm_x86(fout, sym, sym_noat, pp);
 238         }
 239
 240         fprintf(fout, "# from asm\n\n");
 241
 242         while (fgets(line, sizeof(line), fsyms_from))
 243         {
 244                 next_word(sym, sizeof(sym), line);
 245                 if (sym[0] == 0 || sym[0] == ';' || sym[0] == '#')
 246                         continue;
 247
 248                 pp = proto_parse(fhdr, sym);
 249                 if (pp == NULL)
 250                         goto out;
 251
 252                 out_fromasm_x86(fout, sym, pp);
 253         }
 254
 255         ret = 0;
 256 out:
 257         fclose(fout);
 258         fclose(fsyms_to);
 259         fclose(fsyms_from);
 260         fclose(fhdr);
 261         if (ret)
 262                 remove(argv[1]);
 263
 264         return ret;
 265 }