compilers/imcc/imc.c

   1 /*
   2  * $Id$
   3  * Copyright (C) 2002-2009, Parrot Foundation.
   4  */
   5
   6 /*
   7
   8 =head1 NAME
   9
  10 compilers/imcc/imc.c
  11
  12 =head1 DESCRIPTION
  13
  14 Routines for handling imc_units, which represent subs.
  15
  16 Moved all register allocation and spill code to reg_alloc.c
  17
  18 =head2 Functions
  19
  20 =over 4
  21
  22 =cut
  23
  24 */
  25
  26 #include <string.h>
  27 #include "imc.h"
  28 #include "optimizer.h"
  29
  30 /* HEADERIZER HFILE: compilers/imcc/imc.h */
  31
  32 /* HEADERIZER BEGIN: static */
  33 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
  34
  35 static void imc_free_unit(PARROT_INTERP, ARGMOD(IMC_Unit *unit))
  36         __attribute__nonnull__(1)
  37         __attribute__nonnull__(2)
  38         FUNC_MODIFIES(*unit);
  39
  40 PARROT_CANNOT_RETURN_NULL
  41 PARROT_MALLOC
  42 static IMC_Unit * imc_new_unit(PARROT_INTERP, IMC_Unit_Type t)
  43         __attribute__nonnull__(1);
  44
  45 #define ASSERT_ARGS_imc_free_unit __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
  46        PARROT_ASSERT_ARG(interp) \
  47     , PARROT_ASSERT_ARG(unit))
  48 #define ASSERT_ARGS_imc_new_unit __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
  49        PARROT_ASSERT_ARG(interp))
  50 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
  51 /* HEADERIZER END: static */
  52
  53 #define COMPILE_IMMEDIATE 1
  54
  55 /*
  56
  57 =item C<void imc_compile_all_units(PARROT_INTERP)>
  58
  59 Compiles all imc_units, and free all memory of instructions and structures
  60 afterwards.
  61
  62 =cut
  63
  64 */
  65
  66 void
  67 imc_compile_all_units(PARROT_INTERP)
  68 {
  69     ASSERT_ARGS(imc_compile_all_units)
  70     /* compile all units created during the parse */
  71     IMC_Unit *unit;
  72
  73 #if ! COMPILE_IMMEDIATE
  74     for (unit = IMCC_INFO(interp)->imc_units; unit;) {
  75         IMC_Unit * const unit_next = unit->next;
  76         imc_compile_unit(interp, unit);
  77         unit = unit_next;
  78     }
  79 #endif
  80
  81     emit_close(interp, NULL);
  82
  83     /* All done with compilation, now free all memory allocated
  84      * for instructions and other structures.  */
  85     for (unit = IMCC_INFO(interp)->imc_units; unit;) {
  86         IMC_Unit    * const unit_next = unit->next;
  87         Instruction *ins;
  88
  89         for (ins = unit->instructions; ins;) {
  90             Instruction * const ins_next = ins->next;
  91             free_ins(ins);
  92             ins = ins_next;
  93         }
  94
  95         imc_free_unit(interp, unit);
  96         unit = unit_next;
  97     }
  98
  99     IMCC_INFO(interp)->imc_units = NULL;
 100     IMCC_INFO(interp)->cur_unit  = NULL;
 101     IMCC_INFO(interp)->last_unit = NULL;
 102 }
 103
 104
 105 /*
 106
 107 =item C<void imc_compile_unit(PARROT_INTERP, IMC_Unit *unit)>
 108
 109 Compiles each unit in IMCC.  This is the main loop of the compiler; it operates
 110 on a single compilation unit at a time.
 111
 112 =cut
 113
 114 */
 115
 116 void
 117 imc_compile_unit(PARROT_INTERP, ARGIN(IMC_Unit *unit))
 118 {
 119     ASSERT_ARGS(imc_compile_unit)
 120     /* Not much here for now except the allocator */
 121     IMCC_INFO(interp)->cur_unit = unit;
 122
 123     imc_reg_alloc(interp, unit);
 124     emit_flush(interp, NULL, unit);
 125 }
 126
 127
 128 /*
 129
 130 =item C<void imc_cleanup(PARROT_INTERP, void *yyscanner)>
 131
 132 Cleans up the compiler state in preparation for another compiler invocation.
 133
 134 =cut
 135
 136 */
 137
 138 void
 139 imc_cleanup(PARROT_INTERP, ARGIN_NULLOK(void *yyscanner))
 140 {
 141     ASSERT_ARGS(imc_cleanup)
 142     IMCC_pop_parser_state(interp, yyscanner);
 143     clear_globals(interp);
 144     mem_sys_free(IMCC_INFO(interp)->ghash.data);
 145     IMCC_INFO(interp)->ghash.data = NULL;
 146
 147     if (IMCC_INFO(interp)->state) {
 148         mem_sys_free(IMCC_INFO(interp)->state->file);
 149         IMCC_INFO(interp)->state->file = NULL;
 150     }
 151 }
 152
 153
 154 /*
 155
 156 =item C<static IMC_Unit * imc_new_unit(PARROT_INTERP, IMC_Unit_Type t)>
 157
 158 Creates a new IMC_Unit of the given IMC_Unit_Type C<t>.
 159
 160 =cut
 161
 162 */
 163
 164 PARROT_CANNOT_RETURN_NULL
 165 PARROT_MALLOC
 166 static IMC_Unit *
 167 imc_new_unit(PARROT_INTERP, IMC_Unit_Type t)
 168 {
 169     ASSERT_ARGS(imc_new_unit)
 170     IMC_Unit * const unit = mem_gc_allocate_zeroed_typed(interp, IMC_Unit);
 171     create_symhash(interp, &unit->hash);
 172     unit->type = t;
 173     return unit;
 174 }
 175
 176
 177 /*
 178
 179 =item C<IMC_Unit * imc_open_unit(PARROT_INTERP, IMC_Unit_Type t)>
 180
 181 Creates a new IMC_Unit and "open" it for construction.  This sets the current
 182 state of the parser.  You can close the unit later while retaining all the
 183 current state.
 184
 185 =cut
 186
 187 */
 188
 189 PARROT_CANNOT_RETURN_NULL
 190 IMC_Unit *
 191 imc_open_unit(PARROT_INTERP, IMC_Unit_Type t)
 192 {
 193     ASSERT_ARGS(imc_open_unit)
 194     IMC_Unit   * const unit     = imc_new_unit(interp, t);
 195     imc_info_t * const imc_info = IMCC_INFO(interp);
 196
 197     if (!imc_info->imc_units)
 198         imc_info->imc_units = unit;
 199
 200     if (!imc_info->ghash.data)
 201         create_symhash(interp, &imc_info->ghash);
 202
 203     unit->prev = imc_info->last_unit;
 204
 205     if (imc_info->last_unit)
 206         imc_info->last_unit->next = unit;
 207
 208     imc_info->last_unit = unit;
 209     imc_info->n_comp_units++;
 210
 211     unit->file      = imc_info->state->file;
 212     unit->pasm_file = imc_info->state->pasm_file;
 213
 214     return unit;
 215 }
 216
 217
 218 /*
 219
 220 =item C<void imc_close_unit(PARROT_INTERP, IMC_Unit *unit)>
 221
 222 Closes a unit from compilation.  This does not destroy the unit, but leaves it
 223 on the list of units.
 224
 225 =cut
 226
 227 */
 228
 229 void
 230 imc_close_unit(PARROT_INTERP, ARGIN_NULLOK(IMC_Unit *unit))
 231 {
 232     ASSERT_ARGS(imc_close_unit)
 233 #if COMPILE_IMMEDIATE
 234     if (unit)
 235         imc_compile_unit(interp, unit);
 236 #endif
 237
 238     IMCC_INFO(interp)->cur_unit = NULL;
 239 }
 240
 241
 242 /*
 243
 244 =item C<static void imc_free_unit(PARROT_INTERP, IMC_Unit *unit)>
 245
 246 Frees an IMC_Unit and all of its associated memory.
 247
 248 =cut
 249
 250 */
 251
 252 static void
 253 imc_free_unit(PARROT_INTERP, ARGMOD(IMC_Unit *unit))
 254 {
 255     ASSERT_ARGS(imc_free_unit)
 256     imc_info_t * const imc = IMCC_INFO(interp);
 257
 258     free_reglist(unit);
 259
 260     /* and cfg ... */
 261     clear_basic_blocks(unit);
 262
 263     if (!imc->n_comp_units)
 264         IMCC_fatal(interp, 1, "imc_free_unit: non existent unit\n");
 265
 266     imc->n_comp_units--;
 267
 268     clear_locals(unit);
 269
 270     if (unit->_namespace && unit->owns_namespace)
 271         free_sym(unit->_namespace);
 272     if (unit->vtable_name)
 273         mem_sys_free(unit->vtable_name);
 274     if (unit->instance_of)
 275         mem_sys_free(unit->instance_of);
 276
 277     mem_sys_free(unit->hash.data);
 278     mem_sys_free(unit);
 279 }
 280
 281 /*
 282
 283 =back
 284
 285 =cut
 286
 287 */
 288
 289 /*
 290  * Local variables:
 291  *   c-file-style: "parrot"
 292  * End:
 293  * vim: expandtab shiftwidth=4:
 294  */