tools/mkbridge.c

   1 /*
   2  * ia32rtools
   3  * (C) notaz, 2013,2014
   4  *
   5  * This work is licensed under the terms of 3-clause BSD license.
   6  * See COPYING file in the top-level directory.
   7  */
   8
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12
  13 #include "my_assert.h"
  14 #include "my_str.h"
  15 #include "common.h"
  16
  17 #include "protoparse.h"
  18
  19 static const char *c_save_regs[] = { "ebx", "esi", "edi", "ebp" };
  20
  21 static int is_x86_reg_saved(const char *reg)
  22 {
  23         static const char *nosave_regs[] = { "eax", "edx", "ecx" };
  24         int nosave = 0;
  25         int r;
  26
  27         for (r = 0; r < ARRAY_SIZE(nosave_regs); r++)
  28                 if (strcmp(reg, nosave_regs[r]) == 0)
  29                         nosave = 1;
  30
  31         return !nosave;
  32 }
  33
  34 // output decorated name
  35 static const char *pp_to_name(const struct parsed_proto *pp)
  36 {
  37         static char buf[256];
  38         char atval[16];
  39
  40         if (!pp->is_fastcall && pp->argc_reg != 0) {
  41                 // can only be handled by __cdecl C func
  42                 snprintf(buf, sizeof(buf), "_%s", pp->name);
  43                 return buf;
  44         }
  45
  46         atval[0] = 0;
  47         if (pp->is_stdcall) {
  48                 snprintf(atval, sizeof(atval), "@%d",
  49                         pp->argc * 4);
  50         }
  51         snprintf(buf, sizeof(buf), "%s%s%s",
  52                 pp->is_fastcall ? "@" : "_",
  53                 pp->name, atval);
  54
  55         return buf;
  56 }
  57
  58 static void out_toasm_x86(FILE *f, const char *sym_out,
  59         const struct parsed_proto *pp)
  60 {
  61         int must_save = 0;
  62         int sarg_ofs = 1; // stack offset to args, in DWORDs
  63         int args_repushed = 0;
  64         int argc_repush;
  65         const char *name;
  66         int i;
  67
  68         argc_repush = pp->argc;
  69         if (pp->is_vararg)
  70                 argc_repush = ARRAY_SIZE(pp->arg); // hopefully enough?
  71
  72         for (i = 0; i < pp->argc; i++) {
  73                 if (pp->arg[i].reg != NULL)
  74                         must_save |= is_x86_reg_saved(pp->arg[i].reg);
  75         }
  76
  77         name = pp_to_name(pp);
  78         fprintf(f, ".global %s\n", name);
  79         fprintf(f, "%s:\n", name);
  80
  81         if (pp->argc_reg == 0 || pp->is_fastcall) {
  82                 fprintf(f, "\t# %s\n",
  83                   pp->is_fastcall ? "__fastcall" :
  84                   (pp->is_stdcall ? "__stdcall" : "__cdecl"));
  85                 fprintf(f, "\tjmp %s\n\n", sym_out);
  86                 return;
  87         }
  88
  89         if (pp->argc_stack == 0 && !must_save && !pp->is_stdcall
  90              && !pp->is_vararg && !pp->has_retreg)
  91         {
  92                 // load arg regs
  93                 for (i = 0; i < pp->argc; i++) {
  94                         fprintf(f, "\tmovl %d(%%esp), %%%s\n",
  95                                 (i + sarg_ofs) * 4, pp->arg[i].reg);
  96                 }
  97                 fprintf(f, "\tjmp %s\n\n", sym_out);
  98                 return;
  99         }
 100
 101         // asm_stack_args | saved_regs | ra | args_from_c
 102
 103         // save the regs
 104         // because we don't always know what we are calling,
 105         // be safe and save everything that has to be saved in __cdecl
 106         for (i = 0; i < ARRAY_SIZE(c_save_regs); i++) {
 107                 fprintf(f, "\tpushl %%%s\n", c_save_regs[i]);
 108                 sarg_ofs++;
 109         }
 110
 111         // reconstruct arg stack for asm
 112         for (i = argc_repush - 1; i >= 0; i--) {
 113                 if (pp->arg[i].reg == NULL) {
 114                         fprintf(f, "\tmovl %d(%%esp), %%eax\n",
 115                                 (i + sarg_ofs) * 4);
 116                         fprintf(f, "\tpushl %%eax\n");
 117                         sarg_ofs++;
 118                         args_repushed++;
 119                 }
 120         }
 121
 122         // load arg regs
 123         for (i = 0; i < pp->argc; i++) {
 124                 if (pp->arg[i].reg != NULL) {
 125                         fprintf(f, "\tmovl %d(%%esp), %%%s\n",
 126                                 (i + sarg_ofs) * 4, pp->arg[i].reg);
 127                         if (pp->arg[i].type.is_retreg)
 128                                 fprintf(f, "\tmovl (%%%s), %%%s\n",
 129                                         pp->arg[i].reg, pp->arg[i].reg);
 130                 }
 131         }
 132
 133         fprintf(f, "\n\t# %s\n", pp->is_stdcall ? "__stdcall" : "__cdecl");
 134         fprintf(f, "\tcall %s\n\n", sym_out);
 135
 136         if (args_repushed && !pp->is_stdcall) {
 137                 fprintf(f, "\tadd $%d,%%esp\n", args_repushed * 4);
 138                 sarg_ofs -= args_repushed;
 139         }
 140
 141         // update the retreg regs
 142         if (pp->has_retreg) {
 143                 for (i = 0; i < pp->argc; i++) {
 144                         if (pp->arg[i].type.is_retreg) {
 145                                 fprintf(f, "\tmovl %d(%%esp), %%ecx\n"
 146                                            "\tmovl %%%s, (%%ecx)\n",
 147                                         (i + sarg_ofs) * 4, pp->arg[i].reg);
 148                         }
 149                 }
 150         }
 151
 152         // restore regs
 153         for (i = ARRAY_SIZE(c_save_regs) - 1; i >= 0; i--)
 154                 fprintf(f, "\tpopl %%%s\n", c_save_regs[i]);
 155
 156         fprintf(f, "\tret\n\n");
 157 }
 158
 159 static void out_fromasm_x86(FILE *f, const char *sym,
 160         const struct parsed_proto *pp)
 161 {
 162         int reg_ofs[ARRAY_SIZE(pp->arg)];
 163         int sarg_ofs = 1; // stack offset to args, in DWORDs
 164         int saved_regs = 0;
 165         int ecx_ofs = -1;
 166         int edx_ofs = -1;
 167         int c_is_stdcall;
 168         int argc_repush;
 169         int stack_args;
 170         int ret64;
 171         int i;
 172
 173         argc_repush = pp->argc;
 174         stack_args = pp->argc_stack;
 175         if (pp->is_vararg) {
 176                 argc_repush = ARRAY_SIZE(pp->arg); // hopefully enough?
 177                 stack_args = argc_repush - pp->argc_reg;
 178         }
 179
 180         ret64 = strstr(pp->ret_type.name, "int64") != NULL;
 181
 182         fprintf(f, "# %s",
 183           pp->is_fastcall ? "__fastcall" :
 184           (pp->is_stdcall ? "__stdcall" : "__cdecl"));
 185         if (ret64)
 186                 fprintf(f, " ret64");
 187         if (!pp->is_fastcall && pp->argc_reg != 0)
 188                 fprintf(f, " +reg");
 189
 190         if (pp->is_stdcall && !pp->is_fastcall && pp->argc_reg != 0
 191             && !IS_START(sym, "sub_") && !IS_START(sym, "f_"))
 192         {
 193                 // alias for possible .def export
 194                 char sym2[256];
 195
 196                 snprintf(sym2, sizeof(sym2), "_%s@%d",
 197                          sym, pp->argc * 4);
 198                 fprintf(f, "\n.global %s # for .def\n", sym2);
 199                 fprintf(f, "%s:", sym2);
 200         }
 201         fprintf(f, "\n.global %s\n", sym);
 202         fprintf(f, "%s:\n", sym);
 203
 204         if ((pp->argc_reg == 0 || pp->is_fastcall)
 205             && !IS(pp->name, "storm_491")) // wants edx save :(
 206         {
 207                 fprintf(f, "\tjmp %s\n\n", pp_to_name(pp));
 208                 return;
 209         }
 210
 211         c_is_stdcall = (pp->argc_reg == 0 && pp->is_stdcall);
 212
 213         // at least sc sub_47B150 needs edx to be preserved
 214         // int64 returns use edx:eax - no edx save
 215         // we use ecx also as scratch
 216         fprintf(f, "\tpushl %%ecx\n");
 217         saved_regs++;
 218         sarg_ofs++;
 219         ecx_ofs = sarg_ofs;
 220         if (!ret64) {
 221                 fprintf(f, "\tpushl %%edx\n");
 222                 saved_regs++;
 223                 sarg_ofs++;
 224                 edx_ofs = sarg_ofs;
 225         }
 226
 227         // need space for retreg args
 228         if (pp->has_retreg) {
 229                 for (i = 0; i < pp->argc; i++) {
 230                         if (!pp->arg[i].type.is_retreg)
 231                                 continue;
 232                         if (IS(pp->arg[i].reg, "ecx") && ecx_ofs >= 0) {
 233                                 reg_ofs[i] = ecx_ofs;
 234                                 continue;
 235                         }
 236                         if (IS(pp->arg[i].reg, "edx") && edx_ofs >= 0) {
 237                                 reg_ofs[i] = edx_ofs;
 238                                 continue;
 239                         }
 240                         fprintf(f, "\tpushl %%%s\n", pp->arg[i].reg);
 241                         saved_regs++;
 242                         sarg_ofs++;
 243                         reg_ofs[i] = sarg_ofs;
 244                 }
 245         }
 246
 247         // construct arg stack
 248         for (i = argc_repush - 1; i >= 0; i--) {
 249                 if (pp->arg[i].reg == NULL) {
 250                         fprintf(f, "\tmovl %d(%%esp), %%ecx\n",
 251                                 (sarg_ofs + stack_args - 1) * 4);
 252                         fprintf(f, "\tpushl %%ecx\n");
 253                         stack_args--;
 254                 }
 255                 else {
 256                         const char *reg = pp->arg[i].reg;
 257                         if (pp->arg[i].type.is_retreg) {
 258                                 reg = "ecx";
 259                                 fprintf(f, "\tlea %d(%%esp), %%ecx\n",
 260                                   (sarg_ofs - reg_ofs[i]) * 4);
 261                         }
 262                         else if (IS(reg, "ecx"))
 263                                 // must reload original ecx
 264                                 fprintf(f, "\tmovl %d(%%esp), %%ecx\n",
 265                                         (sarg_ofs - 2) * 4);
 266
 267                         fprintf(f, "\tpushl %%%s\n", reg);
 268                 }
 269                 sarg_ofs++;
 270         }
 271
 272         fprintf(f, "\n\tcall %s\n\n", pp_to_name(pp));
 273
 274         if (!c_is_stdcall && sarg_ofs > saved_regs + 1)
 275                 fprintf(f, "\tadd $%d,%%esp\n",
 276                         (sarg_ofs - (saved_regs + 1)) * 4);
 277
 278         // pop retregs
 279         if (pp->has_retreg) {
 280                 for (i = pp->argc - 1; i >= 0; i--) {
 281                         if (!pp->arg[i].type.is_retreg)
 282                                 continue;
 283                         if (IS(pp->arg[i].reg, "ecx") && ecx_ofs >= 0) {
 284                                 continue;
 285                         }
 286                         if (IS(pp->arg[i].reg, "edx") && edx_ofs >= 0) {
 287                                 continue;
 288                         }
 289                         fprintf(f, "\tpopl %%%s\n", pp->arg[i].reg);
 290                 }
 291         }
 292
 293         if (!ret64)
 294                 fprintf(f, "\tpopl %%edx\n");
 295         fprintf(f, "\tpopl %%ecx\n");
 296
 297         if (pp->is_stdcall && pp->argc_stack)
 298                 fprintf(f, "\tret $%d\n\n", pp->argc_stack * 4);
 299         else
 300                 fprintf(f, "\tret\n\n");
 301 }
 302
 303 int main(int argc, char *argv[])
 304 {
 305         FILE *fout, *fsyms_to, *fsyms_from, *fhdr;
 306         const struct parsed_proto *pp;
 307         char line[256];
 308         char sym_noat[256];
 309         char sym[256];
 310         char *p;
 311         int ret = 1;
 312
 313         if (argc != 5) {
 314                 printf("usage:\n%s <bridge.s> <toasm_symf> <fromasm_symf> <hdrf>\n",
 315                         argv[0]);
 316                 return 1;
 317         }
 318
 319         hdrfn = argv[4];
 320         fhdr = fopen(hdrfn, "r");
 321         my_assert_not(fhdr, NULL);
 322
 323         fsyms_from = fopen(argv[3], "r");
 324         my_assert_not(fsyms_from, NULL);
 325
 326         fsyms_to = fopen(argv[2], "r");
 327         my_assert_not(fsyms_to, NULL);
 328
 329         fout = fopen(argv[1], "w");
 330         my_assert_not(fout, NULL);
 331
 332         fprintf(fout, ".text\n\n");
 333         fprintf(fout, "# C -> asm\n\n");
 334
 335         while (fgets(line, sizeof(line), fsyms_to))
 336         {
 337                 next_word(sym, sizeof(sym), line);
 338                 if (sym[0] == 0 || sym[0] == ';' || sym[0] == '#')
 339                         continue;
 340
 341                 // IDA asm doesn't do '@' notation..
 342                 strcpy(sym_noat, sym);
 343                 p = strchr(sym_noat, '@');
 344                 if (p != NULL)
 345                         *p = 0;
 346
 347                 pp = proto_parse(fhdr, sym_noat, 0);
 348                 if (pp == NULL)
 349                         goto out;
 350
 351                 out_toasm_x86(fout, sym_noat, pp);
 352         }
 353
 354         fprintf(fout, "# asm -> C\n\n");
 355
 356         while (fgets(line, sizeof(line), fsyms_from))
 357         {
 358                 next_word(sym, sizeof(sym), line);
 359                 if (sym[0] == 0 || sym[0] == ';' || sym[0] == '#')
 360                         continue;
 361
 362                 pp = proto_parse(fhdr, sym, 0);
 363                 if (pp == NULL)
 364                         goto out;
 365
 366                 out_fromasm_x86(fout, sym, pp);
 367         }
 368
 369         ret = 0;
 370 out:
 371         fclose(fout);
 372         fclose(fsyms_to);
 373         fclose(fsyms_from);
 374         fclose(fhdr);
 375         if (ret)
 376                 remove(argv[1]);
 377
 378         return ret;
 379 }