Acse.y 26 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719
  1. %{
  2. /*
  3. * Andrea Di Biagio
  4. * Politecnico di Milano, 2007
  5. *
  6. * Acse.y
  7. * Formal Languages & Compilers Machine, 2007/2008
  8. *
  9. */
  10. /*************************************************************************
  11. Compiler for the language LANCE
  12. ***************************************************************************/
  13. #include <stdio.h>
  14. #include <stdlib.h>
  15. #include <assert.h>
  16. #include "axe_struct.h"
  17. #include "axe_engine.h"
  18. #include "symbol_table.h"
  19. #include "axe_errors.h"
  20. #include "collections.h"
  21. #include "axe_expressions.h"
  22. #include "axe_gencode.h"
  23. #include "axe_utils.h"
  24. #include "axe_array.h"
  25. #include "axe_cflow_graph.h"
  26. #include "cflow_constants.h"
  27. #include "axe_transform.h"
  28. #include "axe_reg_alloc.h"
  29. #include "reg_alloc_constants.h"
  30. #include "axe_io_manager.h"
  31. #ifndef NDEBUG
  32. # include "axe_debug.h"
  33. #endif
  34. /* global variables */
  35. int line_num; /* this variable will keep track of the
  36. * source code line number. Every time that a newline
  37. * is encountered while parsing the input file, this
  38. * value is increased by 1. This value is then used
  39. * for error tracking: if the parser returns an error
  40. * or a warning, this value is used in order to notify
  41. * in which line of code the error has been found */
  42. int num_error; /* the number of errors found in the code. This value
  43. * is increased by 1 every time a new error is found
  44. * in the code. */
  45. int num_warning; /* As for the `num_error' global variable, this one
  46. * keeps track of all the warning messages displayed */
  47. /* errorcode is defined inside "axe_engine.c" */
  48. extern int errorcode; /* this variable is used to test if an error is found
  49. * while parsing the input file. It also is set
  50. * to notify if the compiler internal state is invalid.
  51. * When the parsing process is started, the value
  52. * of `errorcode' is set to the value of the macro
  53. * `AXE_OK' defined in "axe_constants.h".
  54. * As long as everything (the parsed source code and
  55. * the internal state of the compiler) is correct,
  56. * the value of `errorcode' is set to `AXE_OK'.
  57. * When an error occurs (because the input file contains
  58. * one or more syntax errors or because something went
  59. * wrong in the machine internal state), the errorcode
  60. * is set to a value that is different from `AXE_OK'. */
  61. extern int cflow_errorcode; /* As for `errorcode' this value is used to
  62. * test if an error occurs during the creation process of
  63. * a control flow graph. More informations can be found
  64. * analyzing the file `axe_cflow_graph.h'. */
  65. /* program informations */
  66. t_program_infos *program; /* The singleton instance of `program'.
  67. * An instance of `t_program_infos' holds in its
  68. * internal structure, all the useful informations
  69. * about a program. For example: the assembly
  70. * (code and directives); the symbol table;
  71. * the label manager (see axe_labels.h) etc. */
  72. t_cflow_Graph *graph; /* An instance of a control flow graph. This instance
  73. * will be generated starting from `program' and will
  74. * be used during the register allocation process */
  75. t_reg_allocator *RA; /* Register allocator. It implements the "Linear scan"
  76. * algorythm */
  77. t_io_infos *file_infos; /* input and output files used by the compiler */
  78. %}
  79. %expect 1
  80. /*=========================================================================
  81. SEMANTIC RECORDS
  82. =========================================================================*/
  83. %union {
  84. int intval;
  85. char *svalue;
  86. t_axe_expression expr;
  87. t_axe_declaration *decl;
  88. t_list *list;
  89. t_axe_label *label;
  90. t_while_statement while_stmt;
  91. }
  92. /*=========================================================================
  93. TOKENS
  94. =========================================================================*/
  95. %start program
  96. %token LBRACE RBRACE LPAR RPAR LSQUARE RSQUARE
  97. %token SEMI COLON PLUS MINUS MUL_OP DIV_OP MOD_OP
  98. %token AND_OP OR_OP NOT_OP
  99. %token ASSIGN LT GT SHL_OP SHR_OP EQ NOTEQ LTEQ GTEQ
  100. %token ANDAND OROR
  101. %token COMMA
  102. %token FOR
  103. %token RETURN
  104. %token READ
  105. %token WRITE
  106. %token PLUSINFTY MINUSINFTY UNDEF
  107. %token <label> DO
  108. %token <while_stmt> WHILE
  109. %token <label> IF
  110. %token <label> ELSE
  111. %token <intval> TYPE
  112. %token <svalue> IDENTIFIER
  113. %token <intval> NUMBER
  114. %type <expr> exp
  115. %type <decl> declaration
  116. %type <list> declaration_list
  117. %type <label> if_stmt
  118. /*=========================================================================
  119. OPERATOR PRECEDENCES
  120. =========================================================================*/
  121. %left COMMA
  122. %left ASSIGN
  123. %left OROR
  124. %left ANDAND
  125. %left OR_OP
  126. %left AND_OP
  127. %left EQ NOTEQ
  128. %left LT GT LTEQ GTEQ
  129. %left SHL_OP SHR_OP
  130. %left MINUS PLUS
  131. %left MUL_OP DIV_OP
  132. %right NOT
  133. /*=========================================================================
  134. BISON GRAMMAR
  135. =========================================================================*/
  136. %%
  137. /* `program' is the starting non-terminal of the grammar.
  138. * A program is composed by:
  139. 1. declarations (zero or more);
  140. 2. A list of instructions. (at least one instruction!).
  141. * When the rule associated with the non-terminal `program' is executed,
  142. * the parser notify it to the `program' singleton instance. */
  143. program : var_declarations statements
  144. {
  145. /* Notify the end of the program. Once called
  146. * the function `set_end_Program' - if necessary -
  147. * introduces a `HALT' instruction into the
  148. * list of instructions. */
  149. set_end_Program(program);
  150. /* return from yyparse() */
  151. YYACCEPT;
  152. }
  153. ;
  154. var_declarations : var_declarations var_declaration { /* does nothing */ }
  155. | /* empty */ { /* does nothing */ }
  156. ;
  157. var_declaration : TYPE declaration_list SEMI
  158. {
  159. /* update the program infos by adding new variables */
  160. set_new_variables(program, $1, $2);
  161. }
  162. ;
  163. declaration_list : declaration_list COMMA declaration
  164. { /* add the new declaration to the list of declarations */
  165. $$ = addElement($1, $3, -1);
  166. if (! $3->isArray) {
  167. char *s = malloc(sizeof(char)*strlen($3->ID) + 3);
  168. strcpy(s, $3->ID);
  169. s = strcat(s, "_i");
  170. $$ = addElement($$, alloc_declaration(s, 0, 0, 0), -1);
  171. }
  172. }
  173. | declaration
  174. {
  175. /* add the new declaration to the list of declarations */
  176. $$ = addElement(NULL, $1, -1);
  177. if (! $1->isArray) {
  178. char *s = malloc(sizeof(char)*strlen($1->ID) + 3);
  179. strcpy(s, $1->ID);
  180. s = strcat(s, "_i");
  181. $$ = addElement($$, alloc_declaration(s, 0, 0, 0), -1);
  182. }
  183. }
  184. ;
  185. declaration : IDENTIFIER ASSIGN NUMBER
  186. {
  187. /* create a new instance of t_axe_declaration */
  188. $$ = alloc_declaration($1, 0, 0, $3);
  189. /* test if an `out of memory' occurred */
  190. if ($$ == NULL)
  191. notifyError(AXE_OUT_OF_MEMORY);
  192. }
  193. | IDENTIFIER LSQUARE NUMBER RSQUARE
  194. {
  195. /* create a new instance of t_axe_declaration */
  196. $$ = alloc_declaration($1, 1, $3, 0);
  197. /* test if an `out of memory' occurred */
  198. if ($$ == NULL)
  199. notifyError(AXE_OUT_OF_MEMORY);
  200. }
  201. | IDENTIFIER
  202. {
  203. /* create a new instance of t_axe_declaration */
  204. $$ = alloc_declaration($1, 0, 0, 0);
  205. /* test if an `out of memory' occurred */
  206. if ($$ == NULL)
  207. notifyError(AXE_OUT_OF_MEMORY);
  208. }
  209. ;
  210. /* A block of code can be either a single statement or
  211. * a set of statements enclosed between braces */
  212. code_block : statement { /* does nothing */ }
  213. | LBRACE statements RBRACE { /* does nothing */ }
  214. ;
  215. /* One or more code statements */
  216. statements : statements statement { /* does nothing */ }
  217. | statement { /* does nothing */ }
  218. ;
  219. /* A statement can be either an assignment statement or a control statement
  220. * or a read/write statement or a semicolon */
  221. statement : assign_statement SEMI { /* does nothing */ }
  222. | control_statement { /* does nothing */ }
  223. | read_write_statement SEMI { /* does nothing */ }
  224. | SEMI { gen_nop_instruction(program); }
  225. ;
  226. control_statement : if_statement { /* does nothing */ }
  227. | while_statement { /* does nothing */ }
  228. | do_while_statement SEMI { /* does nothing */ }
  229. | return_statement SEMI { /* does nothing */ }
  230. ;
  231. read_write_statement : read_statement { /* does nothing */ }
  232. | write_statement { /* does nothing */ }
  233. ;
  234. assign_statement : IDENTIFIER LSQUARE exp RSQUARE ASSIGN exp
  235. {
  236. /* Notify to `program' that the value $6
  237. * have to be assigned to the location
  238. * addressed by $1[$3]. Where $1 is obviously
  239. * the array/pointer identifier, $3 is an expression
  240. * that holds an integer value. That value will be
  241. * used as an index for the array $1 */
  242. storeArrayElement(program, $1, $3, $6);
  243. /* free the memory associated with the IDENTIFIER.
  244. * The use of the free instruction is required
  245. * because of the value associated with IDENTIFIER.
  246. * The value of IDENTIFIER is a string created
  247. * by a call to the function `strdup' (see Acse.lex) */
  248. free($1);
  249. }
  250. | IDENTIFIER ASSIGN exp
  251. {
  252. int location, infty;
  253. t_axe_instruction *instr;
  254. /* in order to assign a value to a variable, we have to
  255. * know where the variable is located (i.e. in which register).
  256. * the function `get_symbol_location' is used in order
  257. * to retrieve the register location assigned to
  258. * a given identifier.
  259. * A symbol table keeps track of the location of every
  260. * declared variable.
  261. * `get_symbol_location' perform a query on the symbol table
  262. * in order to discover the correct location of
  263. * the variable with $1 as identifier */
  264. /* get the location of the symbol with the given ID. */
  265. location = get_symbol_location(program, $1, 0);
  266. infty = get_symbol_location(program, strcat($1, "_i"), 0);
  267. /* update the value of location */
  268. if ($3.expression_type == IMMEDIATE) {
  269. gen_move_immediate(program, location, $3.value);
  270. gen_addi_instruction(program, infty, REG_0, $3.infty);
  271. }
  272. else
  273. instr = gen_add_instruction
  274. (program, location, REG_0, $3.value, CG_DIRECT_ALL);
  275. gen_add_instruction(program, infty, REG_0, $3.infty,
  276. CG_DIRECT_ALL);
  277. /* free the memory associated with the IDENTIFIER */
  278. free($1);
  279. }
  280. ;
  281. if_statement : if_stmt
  282. {
  283. /* fix the `label_else' */
  284. assignLabel(program, $1);
  285. }
  286. | if_stmt ELSE
  287. {
  288. /* reserve a new label that points to the address where to jump if
  289. * `exp' is verified */
  290. $2 = newLabel(program);
  291. /* exit from the if-else */
  292. gen_bt_instruction (program, $2, 0);
  293. /* fix the `label_else' */
  294. assignLabel(program, $1);
  295. }
  296. code_block
  297. {
  298. /* fix the `label_else' */
  299. assignLabel(program, $2);
  300. }
  301. ;
  302. if_stmt : IF
  303. {
  304. /* the label that points to the address where to jump if
  305. * `exp' is not verified */
  306. $1 = newLabel(program);
  307. }
  308. LPAR exp RPAR
  309. {
  310. if ($4.expression_type == IMMEDIATE)
  311. gen_load_immediate(program, $4.value);
  312. else
  313. gen_andb_instruction(program, $4.value,
  314. $4.value, $4.value, CG_DIRECT_ALL);
  315. /* if `exp' returns FALSE, jump to the label $1 */
  316. gen_beq_instruction (program, $1, 0);
  317. }
  318. code_block { $$ = $1; }
  319. ;
  320. while_statement : WHILE
  321. {
  322. /* initialize the value of the non-terminal */
  323. $1 = create_while_statement();
  324. /* reserve and fix a new label */
  325. $1.label_condition
  326. = assignNewLabel(program);
  327. }
  328. LPAR exp RPAR
  329. {
  330. if ($4.expression_type == IMMEDIATE)
  331. gen_load_immediate(program, $4.value);
  332. else
  333. gen_andb_instruction(program, $4.value,
  334. $4.value, $4.value, CG_DIRECT_ALL);
  335. /* reserve a new label. This new label will point
  336. * to the first instruction after the while code
  337. * block */
  338. $1.label_end = newLabel(program);
  339. /* if `exp' returns FALSE, jump to the label $1.label_end */
  340. gen_beq_instruction (program, $1.label_end, 0);
  341. }
  342. code_block
  343. {
  344. /* jump to the beginning of the loop */
  345. gen_bt_instruction
  346. (program, $1.label_condition, 0);
  347. /* fix the label `label_end' */
  348. assignLabel(program, $1.label_end);
  349. }
  350. ;
  351. do_while_statement : DO
  352. {
  353. /* the label that points to the address where to jump if
  354. * `exp' is not verified */
  355. $1 = newLabel(program);
  356. /* fix the label */
  357. assignLabel(program, $1);
  358. }
  359. code_block WHILE LPAR exp RPAR
  360. {
  361. if ($6.expression_type == IMMEDIATE)
  362. gen_load_immediate(program, $6.value);
  363. else
  364. gen_andb_instruction(program, $6.value,
  365. $6.value, $6.value, CG_DIRECT_ALL);
  366. /* if `exp' returns TRUE, jump to the label $1 */
  367. gen_bne_instruction (program, $1, 0);
  368. }
  369. ;
  370. return_statement : RETURN
  371. {
  372. /* insert an HALT instruction */
  373. gen_halt_instruction(program);
  374. }
  375. ;
  376. read_statement : READ LPAR IDENTIFIER RPAR
  377. {
  378. int locationi, infty;
  379. /* read from standard input an integer value and assign
  380. * it to a variable associated with the given identifier */
  381. /* get the location of the symbol with the given ID */
  382. /* lookup the symbol table and fetch the register location
  383. * associated with the IDENTIFIER $3. */
  384. location = get_symbol_location(program, $3, 0);
  385. infty = get_symbol_location(program, strcat($3, "_i"), 0);
  386. /* insert a read instruction */
  387. gen_read_instruction (program, location);
  388. gen_addi_instruction(program, infty, REG_0, 1)
  389. /* free the memory associated with the IDENTIFIER */
  390. free($3);
  391. }
  392. ;
  393. write_statement : WRITE LPAR exp RPAR
  394. {
  395. int location, infty;
  396. if ($3.expression_type == IMMEDIATE)
  397. {
  398. /* load `immediate' into a new register. Returns the new register
  399. * identifier or REG_INVALID if an error occurs */
  400. location = gen_load_immediate(program, $3.value);
  401. infty = gen_load_immediate(program, $3.infty);
  402. }
  403. else {
  404. location = $3.value;
  405. infty = $3.infty;
  406. }
  407. /* write to standard output an integer value */
  408. gen_write_instruction (program, location);
  409. gen_write_instruction (program, infty);
  410. }
  411. ;
  412. exp: NUMBER { $$ = create_expression ($1, 1, IMMEDIATE); }
  413. | UNDEF { $$ = create_expression (0, 0, IMMEDIATE); }
  414. | PLUSINFTY { $$ = create_expression (1, -1, IMMEDIATE); }
  415. | MINUSINFTY { $$ = create_expression (2, -1, IMMEDIATE); }
  416. | IDENTIFIER {
  417. int location, infty;
  418. /* get the location of the symbol with the given ID */
  419. location = get_symbol_location(program, $1, 0);
  420. infty = get_symbol_location(program, strcat($1, "_i"), 0);
  421. /* return the register location of IDENTIFIER as
  422. * a value for `exp' */
  423. $$ = create_expression (location, infty, REGISTER);
  424. /* free the memory associated with the IDENTIFIER */
  425. free($1);
  426. }
  427. | IDENTIFIER LSQUARE exp RSQUARE {
  428. int reg;
  429. /* load the value IDENTIFIER[exp]
  430. * into `arrayElement' */
  431. reg = loadArrayElement(program, $1, $3);
  432. /* create a new expression */
  433. $$ = create_expression (reg, REGISTER);
  434. /* free the memory associated with the IDENTIFIER */
  435. free($1);
  436. }
  437. | NOT_OP NUMBER { if ($2 == 0)
  438. $$ = create_expression (1, IMMEDIATE);
  439. else
  440. $$ = create_expression (0, IMMEDIATE);
  441. }
  442. | NOT_OP IDENTIFIER {
  443. int identifier_location;
  444. int output_register;
  445. /* get the location of the symbol with the given ID */
  446. identifier_location =
  447. get_symbol_location(program, $2, 0);
  448. /* generate a NOT instruction. In order to do this,
  449. * at first we have to ask for a free register where
  450. * to store the result of the NOT instruction. */
  451. output_register = getNewRegister(program);
  452. /* Now we are able to generate a NOT instruction */
  453. gen_notl_instruction (program, output_register
  454. , identifier_location);
  455. $$ = create_expression (output_register, REGISTER);
  456. /* free the memory associated with the IDENTIFIER */
  457. free($2);
  458. }
  459. | exp AND_OP exp {
  460. $$ = handle_bin_numeric_op(program, $1, $3, ANDB);
  461. }
  462. | exp OR_OP exp {
  463. $$ = handle_bin_numeric_op(program, $1, $3, ORB);
  464. }
  465. | exp PLUS exp {
  466. $$ = handle_bin_numeric_op(program, $1, $3, ADD);
  467. }
  468. | exp MINUS exp {
  469. $$ = handle_bin_numeric_op(program, $1, $3, SUB);
  470. }
  471. | exp MUL_OP exp {
  472. $$ = handle_bin_numeric_op(program, $1, $3, MUL);
  473. }
  474. | exp DIV_OP exp {
  475. $$ = handle_bin_numeric_op(program, $1, $3, DIV);
  476. }
  477. | exp LT exp {
  478. $$ = handle_binary_comparison (program, $1, $3, _LT_);
  479. }
  480. | exp GT exp {
  481. $$ = handle_binary_comparison (program, $1, $3, _GT_);
  482. }
  483. | exp EQ exp {
  484. ` if (($1.expression_type == IMMEDIATE) &&
  485. ($3.expression_type == IMMEDIATE)) {
  486. int undef = ($1.infty * $3.infty != 0);
  487. int value = (($1.infty + $3.infty) * ($1.value == $3.value)) != 0;
  488. $$ = create_expression_inf(value, undef, IMMEDIATE);
  489. }
  490. else {
  491. int temp_reg = getNewRegister(program);
  492. int infty_reg = getNewRegister(program);
  493. int value_reg = getNewRegister(program);
  494. gen_mul_instruction(program, infty_reg, $1.infty, $3.infty,
  495. CG_DIRECT_ALL);
  496. gen_sne_instruction(program, infty_reg);
  497. gen_eorl_instruction(program, value_reg, $1.infty, $3.infty,
  498. CG_DIRECT_ALL);
  499. gen_seq_instruction(program, value_reg);
  500. gen_sub_instruction(program, temp_reg, $1.value, $3.value,
  501. CG_DIRECT_ALL);
  502. gen_seq_instruction(program, temp_reg);
  503. gen_mul_instruction(program, value_reg, temp_reg, value_reg,
  504. CG_DIRECT_ALL);
  505. $$ = create_expression_inf(value_reg, infty_reg, REGISTER);
  506. }
  507. }
  508. | exp NOTEQ exp {
  509. $$ = handle_binary_comparison (program, $1, $3, _NOTEQ_);
  510. }
  511. | exp LTEQ exp {
  512. $$ = handle_binary_comparison (program, $1, $3, _LTEQ_);
  513. }
  514. | exp GTEQ exp {
  515. $$ = handle_binary_comparison (program, $1, $3, _GTEQ_);
  516. }
  517. | exp SHL_OP exp { $$ = handle_bin_numeric_op(program, $1, $3, SHL); }
  518. | exp SHR_OP exp { $$ = handle_bin_numeric_op(program, $1, $3, SHR); }
  519. | exp ANDAND exp { $$ = handle_bin_numeric_op(program, $1, $3, ANDL); }
  520. | exp OROR exp { $$ = handle_bin_numeric_op(program, $1, $3, ORL); }
  521. | LPAR exp RPAR { $$ = $2; }
  522. | MINUS exp {
  523. if ($2.expression_type == IMMEDIATE)
  524. {
  525. $$ = $2;
  526. $$.value = - ($$.value);
  527. }
  528. else
  529. {
  530. t_axe_expression exp_r0;
  531. /* create an expression for regisrer REG_0 */
  532. exp_r0.value = REG_0;
  533. exp_r0.expression_type = REGISTER;
  534. $$ = handle_bin_numeric_op
  535. (program, exp_r0, $2, SUB);
  536. }
  537. }
  538. ;
  539. %%
  540. /*=========================================================================
  541. MAIN
  542. =========================================================================*/
  543. int main (int argc, char **argv)
  544. {
  545. /* initialize all the compiler data structures and global variables */
  546. init_compiler(argc, argv);
  547. /* start the parsing procedure */
  548. yyparse();
  549. #ifndef NDEBUG
  550. fprintf(stdout, "Parsing process completed. \n");
  551. #endif
  552. /* test if the parsing process completed succesfully */
  553. checkConsistency();
  554. #ifndef NDEBUG
  555. fprintf(stdout, "Creating a control flow graph. \n");
  556. #endif
  557. /* create the control flow graph */
  558. graph = createFlowGraph(program->instructions);
  559. checkConsistency();
  560. #ifndef NDEBUG
  561. assert(program != NULL);
  562. assert(program->sy_table != NULL);
  563. assert(file_infos != NULL);
  564. assert(file_infos->syTable_output != NULL);
  565. printSymbolTable(program->sy_table, file_infos->syTable_output);
  566. printGraphInfos(graph, file_infos->cfg_1, 0);
  567. fprintf(stdout, "Updating the basic blocks. \n");
  568. #endif
  569. /* update the control flow graph by inserting load and stores inside
  570. * every basic block */
  571. graph = insertLoadAndStoreInstr(program, graph);
  572. #ifndef NDEBUG
  573. fprintf(stdout, "Executing a liveness analysis on the intermediate code \n");
  574. #endif
  575. performLivenessAnalysis(graph);
  576. checkConsistency();
  577. #ifndef NDEBUG
  578. printGraphInfos(graph, file_infos->cfg_2, 1);
  579. #endif
  580. #ifndef NDEBUG
  581. fprintf(stdout, "Starting the register allocation process. \n");
  582. #endif
  583. /* initialize the register allocator by using the control flow
  584. * informations stored into the control flow graph */
  585. RA = initializeRegAlloc(graph);
  586. /* execute the linear scan algorythm */
  587. execute_linear_scan(RA);
  588. #ifndef NDEBUG
  589. printRegAllocInfos(RA, file_infos->reg_alloc_output);
  590. #endif
  591. #ifndef NDEBUG
  592. fprintf(stdout, "Updating the control flow informations. \n");
  593. #endif
  594. /* apply changes to the program informations by using the informations
  595. * of the register allocation process */
  596. updateProgramInfos(program, graph, RA);
  597. #ifndef NDEBUG
  598. fprintf(stdout, "Writing the assembly file... \n");
  599. #endif
  600. writeAssembly(program, file_infos->output_file_name);
  601. #ifndef NDEBUG
  602. fprintf(stdout, "Assembly written on file \"%s\".\n", file_infos->output_file_name);
  603. #endif
  604. /* shutdown the compiler */
  605. shutdownCompiler(0);
  606. return 0;
  607. }
  608. /*=========================================================================
  609. YYERROR
  610. =========================================================================*/
  611. int yyerror(const char* errmsg)
  612. {
  613. errorcode = AXE_SYNTAX_ERROR;
  614. return 0;
  615. }