src/backends/jvm/generator-jvm-asm.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <stdarg.h>
   4 #include <stdint.h>
   5 #include <stdbool.h>
   6 #include <string.h>
   7 #include <assert.h>
   8
   9 #include <gc.h>
  10
  11 #include "../../oberon-internals.h"
  12 #include "generator-jvm.h"
  13 #include "generator-jvm-abi.h"
  14 #include "generator-jvm-asm.h"
  15 #include "generator-jvm-basic.h"
  16
  17 gen_proc_t *
  18 jvm_create_proc(struct gen_class * class)
  19 {
  20         gen_proc_t * p = GC_MALLOC(sizeof *p);
  21         memset(p, 0, sizeof *p);
  22
  23         struct gen_register_file * rf = GC_MALLOC(sizeof *rf);
  24         memset(rf, 0, sizeof *rf);
  25
  26         struct gen_stack * stack = GC_MALLOC(sizeof *stack);
  27         memset(rf, 0, sizeof *stack);
  28
  29         p -> rf = rf;
  30         p -> stack = stack;
  31         p -> class = class;
  32         p -> label_id = 0;
  33
  34         return p;
  35 }
  36
  37 void
  38 jvm_generate_function_header(gen_proc_t * p, char * access, char * name, char * signature)
  39 {
  40         struct gen_class * class;
  41         class = p -> class;
  42
  43         /* Делаем процедуру текущей в этом классе */
  44         assert(class -> p == NULL);
  45         class -> p = p;
  46
  47         fprintf(class -> fp, ".method %s %s%s\n", access, name, signature);
  48         fprintf(class -> fp, "  start:\n");
  49 }
  50
  51 void
  52 jvm_generate_function_end(gen_proc_t * p)
  53 {
  54         struct gen_class * class;
  55         class = p -> class;
  56
  57         assert(class -> p);
  58         class -> p = NULL;
  59
  60         int pointer = p -> stack -> pointer;
  61         int max_pointer = p -> stack -> max_pointer;
  62         int locals = p -> rf -> num_used;
  63         int max_locals = p -> rf -> max_used;
  64
  65         fprintf(class -> fp, "  .limit stack %i \t; current(%i)\n", max_pointer, pointer);
  66         fprintf(class -> fp, "  .limit locals %i \t; current(%i)\n", max_locals, locals);
  67         fprintf(class -> fp, "  end:\n");
  68         fprintf(class -> fp, ".end method\n\n");
  69 }
  70
  71 struct gen_class *
  72 jvm_create_class(const char * dir, char * full_name)
  73 {
  74         struct gen_class * class = GC_MALLOC(sizeof *class);
  75         memset(class, 0, sizeof *class);
  76
  77         char * fname = new_string("%s/%s.j", dir, full_name);
  78         class -> full_name = new_string(full_name);
  79         class -> fp = fopen(fname, "w");
  80         class -> dir = new_string(dir);
  81
  82         if(class -> fp == NULL)
  83         {
  84                 gen_error("unable to create file %s", fname);
  85         }
  86
  87         return class;
  88 }
  89
  90 void
  91 jvm_destroy_class(struct gen_class * class)
  92 {
  93         assert(class -> p == NULL);
  94         fclose(class -> fp);
  95 }
  96
  97 void
  98 jvm_stack_push(gen_proc_t * p, unsigned size)
  99 {
 100         p -> stack -> pointer += size;
 101         if(p -> stack -> pointer > p -> stack -> max_pointer)
 102         {
 103                 p -> stack -> max_pointer = p -> stack -> pointer;
 104         }
 105 }
 106
 107 void
 108 jvm_stack_pop(gen_proc_t * p, unsigned size)
 109 {
 110         p -> stack -> pointer -= size;
 111
 112         if(p -> stack -> pointer < 0)
 113         {
 114                 printf("WARING: stack pointer %i\n", p -> stack -> pointer);
 115         }
 116 }
 117
 118 void
 119 jvm_generate(gen_proc_t * p, unsigned get, unsigned push, char * format, ...)
 120 {
 121         va_list ptr;
 122         va_start(ptr, format);
 123
 124         jvm_stack_pop(p, get);
 125         fprintf(p -> class -> fp, "  ");
 126         vfprintf(p -> class -> fp, format, ptr);
 127         jvm_stack_push(p, push);
 128         fprintf(p -> class -> fp, " \t ;>>>> %i -- %i : current_stack(%i)\n", get, push, p -> stack -> pointer);
 129
 130         va_end(ptr);
 131 }
 132
 133 void
 134 jvm_generate_comment(gen_proc_t * p, char * format, ...)
 135 {
 136         va_list ptr;
 137         va_start(ptr, format);
 138
 139         fprintf(p -> class -> fp, "  ;;;; ");
 140         vfprintf(p -> class -> fp, format, ptr);
 141         fprintf(p -> class -> fp, "\n");
 142
 143         va_end(ptr);
 144 }
 145
 146 void
 147 jvm_generate_push_int(gen_proc_t * p, int64_t i)
 148 {
 149         if(i == -1)
 150         {
 151                 jvm_generate(p, 0, 1, "iconst_m1");
 152         }
 153         else if(i >= 0 && i <= 5)
 154         {
 155                 jvm_generate(p, 0, 1, "iconst_%li", i);
 156         }
 157         else if(i >= -128 && i <= 127)
 158         {
 159                 jvm_generate(p, 0, 1, "bipush %li", i);
 160         }
 161         else if(i >= -32768 && i <= 32767)
 162         {
 163                 jvm_generate(p, 0, 1, "sipush %li", i);
 164         }
 165         else if(i >= -2147483648 && i <= 2147483647)
 166         {
 167                 jvm_generate(p, 0, 1, "ldc %li", i);
 168         }
 169         else
 170         {
 171                 jvm_generate(p, 0, 2, "ldc2_w %li", i);
 172         }
 173 }
 174
 175 void
 176 jvm_generate_push_int_size(gen_proc_t * p, int64_t i, int size)
 177 {
 178         int pushed_cell = 1;
 179
 180         if(i == -1)
 181         {
 182                 jvm_generate(p, 0, 1, "iconst_m1");
 183         }
 184         else if(i >= 0 && i <= 5)
 185         {
 186                 jvm_generate(p, 0, 1, "iconst_%li", i);
 187         }
 188         else if(i >= -128 && i <= 127)
 189         {
 190                 jvm_generate(p, 0, 1, "bipush %li", i);
 191         }
 192         else if(i >= -32768 && i <= 32767)
 193         {
 194                 jvm_generate(p, 0, 1, "sipush %li", i);
 195         }
 196         else if(i >= -2147483648 && i <= 2147483647)
 197         {
 198                 jvm_generate(p, 0, 1, "ldc %li", i);
 199         }
 200         else
 201         {
 202                 pushed_cell = 2;
 203                 jvm_generate(p, 0, 2, "ldc2_w %li", i);
 204         }
 205
 206         assert(size <= 8);
 207         if(size > 4 && pushed_cell == 1)
 208         {
 209                 jvm_generate(p, pushed_cell, 2, "i2l");
 210         }
 211         else if(size <= 4)
 212         {
 213                 if(pushed_cell > 1)
 214                 {
 215                         jvm_generate(p, 2, 1, "l2i");
 216                 }
 217
 218                 if(size == 2)
 219                 {
 220                         jvm_generate(p, 1, 1, "i2s");
 221                 }
 222                 else if(size == 1)
 223                 {
 224                         jvm_generate(p, 1, 1, "i2b");
 225                 }
 226         }
 227 }
 228
 229 void
 230 jvm_generate_push_float(gen_proc_t * p, double f, int size)
 231 {
 232         if(size <= 4)
 233         {
 234                 if(f == 0.0)
 235                 {
 236                         jvm_generate(p, 0, 1, "fconst_0");
 237                 }
 238                 if(f == 1.0)
 239                 {
 240                         jvm_generate(p, 0, 1, "fconst_1");
 241                 }
 242                 if(f == 2.0)
 243                 {
 244                         jvm_generate(p, 0, 1, "fconst_2");
 245                 }
 246                 else
 247                 {
 248                         jvm_generate(p, 0, 1, "ldc %lf", f);
 249                 }
 250         }
 251         else
 252         {
 253                 if(f == 0.0)
 254                 {
 255                         jvm_generate(p, 0, 2, "dconst_0");
 256                 }
 257                 if(f == 1.0)
 258                 {
 259                         jvm_generate(p, 0, 2, "dconst_1");
 260                 }
 261                 else
 262                 {
 263                         jvm_generate(p, 0, 2, "ldc2_w %lf", f);
 264                 }
 265         }
 266 }
 267
 268 void
 269 jvm_generate_push_string(gen_proc_t * p, char * str, int char_size)
 270 {
 271         assert(char_size == 1);
 272         int len = strlen(str);
 273
 274         jvm_generate_push_int(p, len + 1);
 275         jvm_generate(p, 1, 1, "newarray byte");
 276
 277         for(int i = 0; i < len; i++)
 278         {
 279                 jvm_generate(p, 1, 2, "dup");
 280                 jvm_generate_push_int(p, i);
 281                 jvm_generate_push_int(p, str[i]);
 282                 jvm_generate(p, 3, 0, "bastore");
 283         }
 284 }
 285
 286 int
 287 jvm_new_label_id(gen_proc_t * p)
 288 {
 289         int label_id = p -> label_id;
 290         p -> label_id += 1;
 291         return label_id;
 292 }
 293
 294 void
 295 jvm_generate_label(gen_proc_t * p, int label_id)
 296 {
 297         jvm_generate(p, 0, 0, "L%i:", label_id);
 298 }