author | Mario de Sousa <msousa@fe.up.pt> |
Mon, 19 Nov 2012 18:59:12 +0000 | |
changeset 736 | a591ed23c370 |
parent 735 | 0304ff59fd7f |
child 774 | 979af2009d88 |
permissions | -rw-r--r-- |
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
1 |
/* |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
2 |
* matiec - a compiler for the programming languages defined in IEC 61131-3 |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
3 |
* |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
4 |
* Copyright (C) 2003-2011 Mario de Sousa (msousa@fe.up.pt) |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
5 |
* Copyright (C) 2012 Manuele Conti (conti.ma@alice.it) |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
6 |
* |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
7 |
* This program is free software: you can redistribute it and/or modify |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
8 |
* it under the terms of the GNU General Public License as published by |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
9 |
* the Free Software Foundation, either version 3 of the License, or |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
10 |
* (at your option) any later version. |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
11 |
* |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
12 |
* This program is distributed in the hope that it will be useful, |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
13 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
14 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
15 |
* GNU General Public License for more details. |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
16 |
* |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
17 |
* You should have received a copy of the GNU General Public License |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
18 |
* along with this program. If not, see <http://www.gnu.org/licenses/>. |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
19 |
* |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
20 |
* |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
21 |
* This code is made available on the understanding that it will not be |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
22 |
* used in safety-critical situations without a full and competent review. |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
23 |
*/ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
24 |
|
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
25 |
/* |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
26 |
* An IEC 61131-3 compiler. |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
27 |
* |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
28 |
* Based on the |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
29 |
* FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10) |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
30 |
* |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
31 |
*/ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
32 |
|
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
33 |
|
572
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
34 |
|
640 | 35 |
/* TODO: |
36 |
* - Add support for comparison (= and !=) of enumeration literals! |
|
37 |
* We will need to add another const_value entry to the symbol_c, containing the |
|
38 |
* possible enumeration value of the enum constant! |
|
39 |
* Doing this will allow us to more easily implement a constant_propagation_c later on! |
|
40 |
* |
|
41 |
* - Add support for comparison (= and !=) of the exact same variable |
|
42 |
* (e.g. if (int_v = int_v) then ...) |
|
43 |
*/ |
|
44 |
||
572
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
45 |
|
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
46 |
|
569
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
47 |
/* Do constant folding... |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
48 |
* |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
49 |
* I.e., Determine the value of all expressions in which only constant values (i.e. literals) are used. |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
50 |
* The (constant) result of each operation is stored (annotated) in the respective operation symbol |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
51 |
* (e.g.: add_expression_c) in the abstract syntax tree, |
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
52 |
* |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
53 |
* For example: |
569
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
54 |
* 2 + 3 -> the constant value '5' is stored in the add_expression_c symbol. |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
55 |
* 22.2 - 5.0 -> the constant value '17.2' is stored in the add_expression_c symbol. |
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
56 |
* etc... |
569
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
57 |
* |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
58 |
* |
572
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
59 |
* NOTE 1 |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
60 |
* Some operations and constants can have multiple data types. For example, |
569
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
61 |
* 1 AND 0 |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
62 |
* may be either a BOOL, BYTE, WORD or LWORD. |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
63 |
* |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
64 |
* The same happens with |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
65 |
* 1 + 2 |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
66 |
* which may be signed (e.g. INT) or unsigned (UINT) |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
67 |
* |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
68 |
* For the above reason, instead of storing a single constant value, we actually store 4: |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
69 |
* - bool |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
70 |
* - uint64 |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
71 |
* - int64 |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
72 |
* - real64 |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
73 |
* |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
74 |
* Additionally, since the result of an operation may result in an overflow, we actually |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
75 |
* store the result inside a struct (defined in absyntax.hh) |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
76 |
* |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
77 |
* ** During stage 3 (semantic analysis/checking) we will be doing constant folding. |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
78 |
* * That algorithm will anotate the abstract syntax tree with the result of operations |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
79 |
* * on literals (i.e. 44 + 55 will store the result 99). |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
80 |
* * Since the same source code (e.g. 1 + 0) may actually be a BOOL or an ANY_INT, |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
81 |
* * or an ANY_BIT, we need to handle all possibilities, and determine the result of the |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
82 |
* * operation assuming each type. |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
83 |
* * For this reason, we have one entry for each possible type, with some expressions |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
84 |
* * having more than one entry filled in! |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
85 |
* ** |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
86 |
* typedef enum { cs_undefined, // not defined --> const_value is not valid! |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
87 |
* cs_const_value, // const value is valid |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
88 |
* cs_overflow // result produced overflow or underflow --> const_value is not valid! |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
89 |
* } const_status_t; |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
90 |
* |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
91 |
* typedef struct { |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
92 |
* const_status_t status; |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
93 |
* real64_t value; |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
94 |
* } const_value_real64_t; |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
95 |
* const_value_real64_t *const_value_real64; // when NULL --> UNDEFINED |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
96 |
* |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
97 |
* typedef struct { |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
98 |
* const_status_t status; |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
99 |
* int64_t value; |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
100 |
* } const_value_int64_t; |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
101 |
* const_value_int64_t *const_value_int64; // when NULL --> UNDEFINED |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
102 |
* |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
103 |
* typedef struct { |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
104 |
* const_status_t status; |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
105 |
* uint64_t value; |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
106 |
* } const_value_uint64_t; |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
107 |
* const_value_uint64_t *const_value_uint64; // when NULL --> UNDEFINED |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
108 |
* |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
109 |
* typedef struct { |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
110 |
* const_status_t status; |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
111 |
* bool value; |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
112 |
* } const_value_bool_t; |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
113 |
* const_value_bool_t *const_value_bool; // when NULL --> UNDEFINED |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
114 |
* |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
115 |
* |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
116 |
* |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
117 |
* NOTE 2 |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
118 |
* This file does not print out any error messages! |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
119 |
* We cannot really print out error messages when we find an overflow. Since each operation |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
120 |
* (symbol in the absract syntax tree for that operation) will have up to 4 constant results, |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
121 |
* it may happen that some of them overflow, while other do not. |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
122 |
* We must wait for data type checking to determine the exact data type of each expression |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
123 |
* before we can decide whether or not we should print out an overflow error message. |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
124 |
* |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
125 |
* For this reason, this visitor merely annotates the abstract syntax tree, and leaves the |
572
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
126 |
* actuall printing of errors for the print_datatype_errors_c class! |
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
127 |
*/ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
128 |
|
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
129 |
#include "constant_folding.hh" |
565
8acbddf75333
Fix a few bugs of previous commit.
Mario de Sousa <msousa@fe.up.pt>
parents:
564
diff
changeset
|
130 |
#include <stdlib.h> /* required for malloc() */ |
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
131 |
|
596
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
132 |
#include <string.h> /* required for strlen() */ |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
133 |
// #include <stdlib.h> /* required for atoi() */ |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
134 |
#include <errno.h> /* required for errno */ |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
135 |
|
607
be9ba3531afb
cleaning up code. Changing HUGE_VAL to INFINITY.
Mario de Sousa <msousa@fe.up.pt>
parents:
604
diff
changeset
|
136 |
#include "../main.hh" // required for uint8_t, real_64_t, ..., and the macros NAN, INFINITY, INT8_MAX, REAL32_MAX, ... */ |
579
983a3b743085
Fix 'overflow' detection for real64.
Mario de Sousa <msousa@fe.up.pt>
parents:
578
diff
changeset
|
137 |
|
983a3b743085
Fix 'overflow' detection for real64.
Mario de Sousa <msousa@fe.up.pt>
parents:
578
diff
changeset
|
138 |
|
983a3b743085
Fix 'overflow' detection for real64.
Mario de Sousa <msousa@fe.up.pt>
parents:
578
diff
changeset
|
139 |
|
983a3b743085
Fix 'overflow' detection for real64.
Mario de Sousa <msousa@fe.up.pt>
parents:
578
diff
changeset
|
140 |
|
568
5f79478142d7
make the compiler platform independent (i.e. no longer assume sizeof(double)==8).
Mario de Sousa <msousa@fe.up.pt>
parents:
567
diff
changeset
|
141 |
|
5f79478142d7
make the compiler platform independent (i.e. no longer assume sizeof(double)==8).
Mario de Sousa <msousa@fe.up.pt>
parents:
567
diff
changeset
|
142 |
|
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
143 |
#define FIRST_(symbol1, symbol2) (((symbol1)->first_order < (symbol2)->first_order) ? (symbol1) : (symbol2)) |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
144 |
#define LAST_(symbol1, symbol2) (((symbol1)->last_order > (symbol2)->last_order) ? (symbol1) : (symbol2)) |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
145 |
|
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
146 |
#define STAGE3_ERROR(error_level, symbol1, symbol2, ...) { \ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
147 |
if (current_display_error_level >= error_level) { \ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
148 |
fprintf(stderr, "%s:%d-%d..%d-%d: error: ", \ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
149 |
FIRST_(symbol1,symbol2)->first_file, FIRST_(symbol1,symbol2)->first_line, FIRST_(symbol1,symbol2)->first_column,\ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
150 |
LAST_(symbol1,symbol2) ->last_line, LAST_(symbol1,symbol2) ->last_column);\ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
151 |
fprintf(stderr, __VA_ARGS__); \ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
152 |
fprintf(stderr, "\n"); \ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
153 |
error_count++; \ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
154 |
} \ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
155 |
} |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
156 |
|
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
157 |
|
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
158 |
#define STAGE3_WARNING(symbol1, symbol2, ...) { \ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
159 |
fprintf(stderr, "%s:%d-%d..%d-%d: warning: ", \ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
160 |
FIRST_(symbol1,symbol2)->first_file, FIRST_(symbol1,symbol2)->first_line, FIRST_(symbol1,symbol2)->first_column,\ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
161 |
LAST_(symbol1,symbol2) ->last_line, LAST_(symbol1,symbol2) ->last_column);\ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
162 |
fprintf(stderr, __VA_ARGS__); \ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
163 |
fprintf(stderr, "\n"); \ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
164 |
warning_found = true; \ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
165 |
} |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
166 |
|
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
167 |
|
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
168 |
|
567
e5deeb6d4d2f
create extract_real_value() in absyntax_utils. NOTE: overflows not yet handled!
Mario de Sousa <msousa@fe.up.pt>
parents:
566
diff
changeset
|
169 |
|
569
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
170 |
|
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
171 |
|
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
172 |
|
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
173 |
|
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
174 |
|
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
175 |
|
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
176 |
|
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
177 |
|
643
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
178 |
#define SET_CVALUE(dtype, symbol, new_value) {((symbol)->const_value._##dtype.value) = new_value; ((symbol)->const_value._##dtype.status) = symbol_c::cs_const_value;} |
612 | 179 |
#define GET_CVALUE(dtype, symbol) ((symbol)->const_value._##dtype.value) |
180 |
#define SET_OVFLOW(dtype, symbol) ((symbol)->const_value._##dtype.status) = symbol_c::cs_overflow |
|
181 |
#define SET_NONCONST(dtype, symbol) ((symbol)->const_value._##dtype.status) = symbol_c::cs_non_const |
|
182 |
||
183 |
#define VALID_CVALUE(dtype, symbol) (symbol_c::cs_const_value == (symbol)->const_value._##dtype.status) |
|
643
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
184 |
#define IS_OVFLOW(dtype, symbol) (symbol_c::cs_overflow == (symbol)->const_value._##dtype.status) |
648
5ca2aabb8bcb
More precise handling of const value status.
Mario de Sousa <msousa@fe.up.pt>
parents:
643
diff
changeset
|
185 |
#define IS_NONCONST(dtype, symbol) (symbol_c::cs_non_const == (symbol)->const_value._##dtype.status) |
569
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
186 |
#define ISZERO_CVALUE(dtype, symbol) ((VALID_CVALUE(dtype, symbol)) && (GET_CVALUE(dtype, symbol) == 0)) |
575 | 187 |
|
612 | 188 |
#define ISEQUAL_CVALUE(dtype, symbol1, symbol2) \ |
189 |
(VALID_CVALUE(dtype, symbol1) && VALID_CVALUE(dtype, symbol2) && (GET_CVALUE(dtype, symbol1) == GET_CVALUE(dtype, symbol2))) |
|
190 |
||
648
5ca2aabb8bcb
More precise handling of const value status.
Mario de Sousa <msousa@fe.up.pt>
parents:
643
diff
changeset
|
191 |
#define DO_BINARY_OPER(oper_type, operation, res_type, operand1, operand2) { \ |
5ca2aabb8bcb
More precise handling of const value status.
Mario de Sousa <msousa@fe.up.pt>
parents:
643
diff
changeset
|
192 |
if (VALID_CVALUE(oper_type, operand1) && VALID_CVALUE(oper_type, operand2)) \ |
5ca2aabb8bcb
More precise handling of const value status.
Mario de Sousa <msousa@fe.up.pt>
parents:
643
diff
changeset
|
193 |
{SET_CVALUE(res_type, symbol, GET_CVALUE(oper_type, operand1) operation GET_CVALUE(oper_type, operand2));}\ |
5ca2aabb8bcb
More precise handling of const value status.
Mario de Sousa <msousa@fe.up.pt>
parents:
643
diff
changeset
|
194 |
else if (IS_OVFLOW (oper_type, operand1) || IS_OVFLOW (oper_type, operand2)) \ |
5ca2aabb8bcb
More precise handling of const value status.
Mario de Sousa <msousa@fe.up.pt>
parents:
643
diff
changeset
|
195 |
{SET_OVFLOW(res_type, symbol);} /* does it really make sense to set OVFLOW when restype is boolean?? */ \ |
5ca2aabb8bcb
More precise handling of const value status.
Mario de Sousa <msousa@fe.up.pt>
parents:
643
diff
changeset
|
196 |
else if (IS_NONCONST (oper_type, operand1) || IS_NONCONST (oper_type, operand2)) \ |
5ca2aabb8bcb
More precise handling of const value status.
Mario de Sousa <msousa@fe.up.pt>
parents:
643
diff
changeset
|
197 |
{SET_NONCONST(res_type, symbol);} \ |
643
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
198 |
} |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
199 |
|
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
200 |
#define DO_UNARY_OPER(dtype, operation, operand) { \ |
648
5ca2aabb8bcb
More precise handling of const value status.
Mario de Sousa <msousa@fe.up.pt>
parents:
643
diff
changeset
|
201 |
if (VALID_CVALUE(dtype, operand)) \ |
5ca2aabb8bcb
More precise handling of const value status.
Mario de Sousa <msousa@fe.up.pt>
parents:
643
diff
changeset
|
202 |
{SET_CVALUE(dtype, symbol, operation GET_CVALUE(dtype, operand));} \ |
5ca2aabb8bcb
More precise handling of const value status.
Mario de Sousa <msousa@fe.up.pt>
parents:
643
diff
changeset
|
203 |
else if (IS_OVFLOW (dtype, operand)) \ |
5ca2aabb8bcb
More precise handling of const value status.
Mario de Sousa <msousa@fe.up.pt>
parents:
643
diff
changeset
|
204 |
{SET_OVFLOW(dtype, symbol);} \ |
5ca2aabb8bcb
More precise handling of const value status.
Mario de Sousa <msousa@fe.up.pt>
parents:
643
diff
changeset
|
205 |
else if (IS_NONCONST (dtype, operand)) \ |
5ca2aabb8bcb
More precise handling of const value status.
Mario de Sousa <msousa@fe.up.pt>
parents:
643
diff
changeset
|
206 |
{SET_NONCONST(dtype, symbol);} \ |
643
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
207 |
} |
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
208 |
|
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
209 |
|
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
210 |
|
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
211 |
|
572
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
212 |
|
596
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
213 |
/***********************************************************************/ |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
214 |
/***********************************************************************/ |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
215 |
/***********************************************************************/ |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
216 |
/*** convert string to numerical value ***/ |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
217 |
/***********************************************************************/ |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
218 |
/***********************************************************************/ |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
219 |
/***********************************************************************/ |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
220 |
|
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
221 |
|
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
222 |
|
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
223 |
/* To allow the compiler to be portable, we cannot assume that int64_t is mapped onto long long int, |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
224 |
* so we cannot call strtoll() and strtoull() in extract_int64() and extract_uint64(). |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
225 |
* |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
226 |
* So, we create our own strtouint64() and strtoint64() functions. |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
227 |
* (We actually call them matiec_strtoint64() so they will not clash with any function |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
228 |
* that may be added to the standard library in the future). |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
229 |
* We actually create several of each, and let the compiler choose which is the correct one, |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
230 |
* by having it resolve the call to the overloaded function. For the C++ compiler to be able |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
231 |
* to resolve this ambiguity, we need to add a dummy parameter to each function! |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
232 |
* |
640 | 233 |
* TODO: support platforms (where the compiler will run) in which int64_t is mapped onto int !! |
234 |
* Is this really needed? |
|
235 |
* Currently, when trying to compile matiec on sych a platform, the C++ compiler will not |
|
236 |
* find any apropriate matiec_strtoint64() to call, so matiec will not be able to be compiled. |
|
237 |
* If you need this, you are welcome to fix it yourself... |
|
596
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
238 |
*/ |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
239 |
static int64_t matiec_strtoint64 ( long int *dummy, const char *nptr, char **endptr, int base) {return strtol (nptr, endptr, base);} |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
240 |
static int64_t matiec_strtoint64 ( long long int *dummy, const char *nptr, char **endptr, int base) {return strtoll (nptr, endptr, base);} |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
241 |
|
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
242 |
static uint64_t matiec_strtouint64(unsigned long int *dummy, const char *nptr, char **endptr, int base) {return strtoul (nptr, endptr, base);} |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
243 |
static uint64_t matiec_strtouint64(unsigned long long int *dummy, const char *nptr, char **endptr, int base) {return strtoull(nptr, endptr, base);} |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
244 |
|
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
245 |
|
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
246 |
/* extract the value of an integer from an integer_c object !! */ |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
247 |
/* NOTE: it must ignore underscores! */ |
601
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
248 |
/* NOTE: To follow the basic structure used throughout the compiler's code, we should really be |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
249 |
* writing this as a visitor_c (and do away with the dynamic casts!), but since we only have 3 distinct |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
250 |
* symbol class types to handle, it is probably easier to read if we write it as a standard function... |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
251 |
*/ |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
252 |
int64_t extract_int64_value(symbol_c *sym, bool *overflow) { |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
253 |
int64_t ret; |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
254 |
std::string str = ""; |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
255 |
char *endptr; |
735
0304ff59fd7f
Fix some important clang++ warnings.
Manuele Conti <conti.ma@alice.it>
parents:
690
diff
changeset
|
256 |
const char *value = NULL; |
601
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
257 |
int base; |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
258 |
integer_c *integer; |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
259 |
hex_integer_c *hex_integer; |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
260 |
octal_integer_c *octal_integer; |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
261 |
binary_integer_c *binary_integer; |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
262 |
|
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
263 |
if ((integer = dynamic_cast<integer_c *>(sym)) != NULL) {value = integer ->value + 0; base = 10;} |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
264 |
else if ((hex_integer = dynamic_cast<hex_integer_c *>(sym)) != NULL) {value = hex_integer ->value + 3; base = 16;} |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
265 |
else if ((octal_integer = dynamic_cast<octal_integer_c *>(sym)) != NULL) {value = octal_integer ->value + 2; base = 8;} |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
266 |
else if ((binary_integer = dynamic_cast<binary_integer_c *>(sym)) != NULL) {value = binary_integer->value + 2; base = 2;} |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
267 |
else ERROR; |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
268 |
|
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
269 |
for(unsigned int i = 0; i < strlen(value); i++) |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
270 |
if (value[i] != '_') str += value[i]; |
596
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
271 |
|
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
272 |
errno = 0; // since strtoXX() may legally return 0, we must set errno to 0 to detect errors correctly! |
600
f5d4e9f91513
determine const value of hex, octal and bin literals correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
596
diff
changeset
|
273 |
ret = matiec_strtoint64((int64_t *)NULL, str.c_str(), &endptr, base); |
596
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
274 |
if (overflow != NULL) |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
275 |
*overflow = (errno == ERANGE); |
600
f5d4e9f91513
determine const value of hex, octal and bin literals correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
596
diff
changeset
|
276 |
if (((errno != 0) && (errno != ERANGE)) || (*endptr != '\0')) |
596
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
277 |
ERROR; |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
278 |
|
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
279 |
return ret; |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
280 |
} |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
281 |
|
601
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
282 |
|
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
283 |
|
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
284 |
uint64_t extract_uint64_value(symbol_c *sym, bool *overflow) { |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
285 |
uint64_t ret; |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
286 |
std::string str = ""; |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
287 |
char *endptr; |
735
0304ff59fd7f
Fix some important clang++ warnings.
Manuele Conti <conti.ma@alice.it>
parents:
690
diff
changeset
|
288 |
const char *value = NULL; |
601
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
289 |
int base; |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
290 |
integer_c *integer; |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
291 |
hex_integer_c *hex_integer; |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
292 |
octal_integer_c *octal_integer; |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
293 |
binary_integer_c *binary_integer; |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
294 |
|
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
295 |
if ((integer = dynamic_cast<integer_c *>(sym)) != NULL) {value = integer ->value + 0; base = 10;} |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
296 |
else if ((hex_integer = dynamic_cast<hex_integer_c *>(sym)) != NULL) {value = hex_integer ->value + 3; base = 16;} |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
297 |
else if ((octal_integer = dynamic_cast<octal_integer_c *>(sym)) != NULL) {value = octal_integer ->value + 2; base = 8;} |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
298 |
else if ((binary_integer = dynamic_cast<binary_integer_c *>(sym)) != NULL) {value = binary_integer->value + 2; base = 2;} |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
299 |
else ERROR; |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
300 |
|
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
301 |
for(unsigned int i = 0; i < strlen(value); i++) |
683ae5444237
fix parsing of non base 10 constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
600
diff
changeset
|
302 |
if (value[i] != '_') str += value[i]; |
596
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
303 |
|
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
304 |
errno = 0; // since strtoXX() may legally return 0, we must set errno to 0 to detect errors correctly! |
600
f5d4e9f91513
determine const value of hex, octal and bin literals correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
596
diff
changeset
|
305 |
ret = matiec_strtouint64((uint64_t *)NULL, str.c_str(), &endptr, base); |
596
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
306 |
if (overflow != NULL) |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
307 |
*overflow = (errno == ERANGE); |
600
f5d4e9f91513
determine const value of hex, octal and bin literals correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
596
diff
changeset
|
308 |
if (((errno != 0) && (errno != ERANGE)) || (*endptr != '\0')) |
596
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
309 |
ERROR; |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
310 |
|
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
311 |
return ret; |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
312 |
} |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
313 |
|
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
314 |
|
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
315 |
|
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
316 |
/* extract the value of a real from an real_c object !! */ |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
317 |
/* NOTE: it must ignore underscores! */ |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
318 |
/* From iec_bison.yy |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
319 |
* real: |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
320 |
* real_token {$$ = new real_c($1, locloc(@$));} |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
321 |
* | fixed_point_token {$$ = new real_c($1, locloc(@$));} |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
322 |
* |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
323 |
* From iec_flex.ll |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
324 |
* {real} {yylval.ID=strdup(yytext); return real_token;} |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
325 |
* {fixed_point} {yylval.ID=strdup(yytext); return fixed_point_token;} |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
326 |
* |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
327 |
* real {integer}\.{integer}{exponent} |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
328 |
* fixed_point {integer}\.{integer} |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
329 |
* exponent [Ee]([+-]?){integer} |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
330 |
* integer {digit}((_?{digit})*) |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
331 |
*/ |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
332 |
real64_t extract_real_value(symbol_c *sym, bool *overflow) { |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
333 |
std::string str = ""; |
600
f5d4e9f91513
determine const value of hex, octal and bin literals correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
596
diff
changeset
|
334 |
real_c *real_sym; |
633
73b56dc69e61
Fix bug with task interval using fixed_point value for duration items
Laurent Bessard
parents:
621
diff
changeset
|
335 |
fixed_point_c *fixed_point_sym; |
600
f5d4e9f91513
determine const value of hex, octal and bin literals correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
596
diff
changeset
|
336 |
char *endptr; |
596
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
337 |
real64_t ret; |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
338 |
|
633
73b56dc69e61
Fix bug with task interval using fixed_point value for duration items
Laurent Bessard
parents:
621
diff
changeset
|
339 |
if ((real_sym = dynamic_cast<real_c *>(sym)) != NULL) { |
73b56dc69e61
Fix bug with task interval using fixed_point value for duration items
Laurent Bessard
parents:
621
diff
changeset
|
340 |
for(unsigned int i = 0; i < strlen(real_sym->value); i++) |
73b56dc69e61
Fix bug with task interval using fixed_point value for duration items
Laurent Bessard
parents:
621
diff
changeset
|
341 |
if (real_sym->value[i] != '_') str += real_sym->value[i]; |
73b56dc69e61
Fix bug with task interval using fixed_point value for duration items
Laurent Bessard
parents:
621
diff
changeset
|
342 |
} |
73b56dc69e61
Fix bug with task interval using fixed_point value for duration items
Laurent Bessard
parents:
621
diff
changeset
|
343 |
else if ((fixed_point_sym = dynamic_cast<fixed_point_c *>(sym)) != NULL) { |
73b56dc69e61
Fix bug with task interval using fixed_point value for duration items
Laurent Bessard
parents:
621
diff
changeset
|
344 |
for(unsigned int i = 0; i < strlen(fixed_point_sym->value); i++) |
73b56dc69e61
Fix bug with task interval using fixed_point value for duration items
Laurent Bessard
parents:
621
diff
changeset
|
345 |
if (fixed_point_sym->value[i] != '_') str += fixed_point_sym->value[i]; |
73b56dc69e61
Fix bug with task interval using fixed_point value for duration items
Laurent Bessard
parents:
621
diff
changeset
|
346 |
} |
73b56dc69e61
Fix bug with task interval using fixed_point value for duration items
Laurent Bessard
parents:
621
diff
changeset
|
347 |
else ERROR; |
596
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
348 |
|
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
349 |
errno = 0; // since strtoXX() may legally return 0, we must set errno to 0 to detect errors correctly! |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
350 |
#if (real64_t == float) |
600
f5d4e9f91513
determine const value of hex, octal and bin literals correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
596
diff
changeset
|
351 |
ret = strtof(str.c_str(), &endptr); |
596
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
352 |
#elif (real64_t == double) |
600
f5d4e9f91513
determine const value of hex, octal and bin literals correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
596
diff
changeset
|
353 |
ret = strtod(str.c_str(), &endptr); |
596
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
354 |
#elif (real64_t == long_double) |
600
f5d4e9f91513
determine const value of hex, octal and bin literals correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
596
diff
changeset
|
355 |
ret = strtold(str.c_str(), &endptr); |
596
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
356 |
#else |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
357 |
#error Could not determine which data type is being used for real64_t (defined in absyntax.hh). Aborting! |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
358 |
#endif |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
359 |
if (overflow != NULL) |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
360 |
*overflow = (errno == ERANGE); |
600
f5d4e9f91513
determine const value of hex, octal and bin literals correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
596
diff
changeset
|
361 |
if (((errno != 0) && (errno != ERANGE)) || (*endptr != '\0')) |
596
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
362 |
ERROR; |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
363 |
|
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
364 |
return ret; |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
365 |
} |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
366 |
|
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
367 |
|
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
368 |
|
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
369 |
|
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
370 |
|
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
371 |
/***********************************************************************/ |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
372 |
/***********************************************************************/ |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
373 |
/***********************************************************************/ |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
374 |
/*** Functions to check for overflow situation ***/ |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
375 |
/***********************************************************************/ |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
376 |
/***********************************************************************/ |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
377 |
/***********************************************************************/ |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
378 |
|
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
379 |
|
574
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
380 |
/* NOTE: |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
381 |
* Most of the conditions to detect overflows on signed and unsigned integer operations were adapted from |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
382 |
* https://www.securecoding.cert.org/confluence/display/seccode/INT32-C.+Ensure+that+operations+on+signed+integers+do+not+result+in+overflow?showComments=false |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
383 |
* https://www.securecoding.cert.org/confluence/display/seccode/INT30-C.+Ensure+that+unsigned+integer+operations+do+not+wrap |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
384 |
*/ |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
385 |
|
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
386 |
/* NOTE: If at all possible, all overflow tests are done by pre-condition tests, i.e. tests that |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
387 |
* can be run _before_ the operation is executed, and therefore without accessing the result! |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
388 |
* |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
389 |
* The exception is for real/floating point values, that simply test if the result is NaN (not a number). |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
390 |
*/ |
572
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
391 |
|
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
392 |
/* res = a + b */ |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
393 |
static void CHECK_OVERFLOW_uint64_SUM(symbol_c *res, symbol_c *a, symbol_c *b) { |
574
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
394 |
if (!VALID_CVALUE(uint64, res)) |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
395 |
return; |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
396 |
/* Test by post-condition: If sum is smaller than either operand => overflow! */ |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
397 |
// if (GET_CVALUE(uint64, res) < GET_CVALUE(uint64, a)) |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
398 |
/* Test by pre-condition: If (UINT64_MAX - a) < b => overflow! */ |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
399 |
if ((UINT64_MAX - GET_CVALUE(uint64, a)) < GET_CVALUE(uint64, b)) |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
400 |
SET_OVFLOW(uint64, res); |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
401 |
} |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
402 |
|
572
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
403 |
|
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
404 |
/* res = a - b */ |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
405 |
static void CHECK_OVERFLOW_uint64_SUB(symbol_c *res, symbol_c *a, symbol_c *b) { |
574
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
406 |
if (!VALID_CVALUE(uint64, res)) |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
407 |
return; |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
408 |
/* Test by post-condition: If diference is larger than a => overflow! */ |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
409 |
// if (GET_CVALUE(uint64, res) > GET_CVALUE(uint64, a)) |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
410 |
/* Test by pre-condition: if b > a => overflow! */ |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
411 |
if (GET_CVALUE(uint64, b) > GET_CVALUE(uint64, a)) |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
412 |
SET_OVFLOW(uint64, res); |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
413 |
} |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
414 |
|
572
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
415 |
|
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
416 |
/* res = a * b */ |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
417 |
static void CHECK_OVERFLOW_uint64_MUL(symbol_c *res, symbol_c *a, symbol_c *b) { |
574
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
418 |
if (!VALID_CVALUE(uint64, res)) |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
419 |
return; |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
420 |
/* Test by pre-condition: If (UINT64_MAX / a) < b => overflow! */ |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
421 |
if ((UINT64_MAX / GET_CVALUE(uint64, a)) < GET_CVALUE(uint64, b)) |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
422 |
SET_OVFLOW(uint64, res); |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
423 |
} |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
424 |
|
572
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
425 |
|
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
426 |
/* res = a / b */ |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
427 |
static void CHECK_OVERFLOW_uint64_DIV(symbol_c *res, symbol_c *a, symbol_c *b) { |
574
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
428 |
if (!VALID_CVALUE(uint64, res)) |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
429 |
return; |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
430 |
if (GET_CVALUE(uint64, b) == 0) /* division by zero! */ |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
431 |
SET_OVFLOW(uint64, res); |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
432 |
} |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
433 |
|
572
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
434 |
|
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
435 |
/* res = a MOD b */ |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
436 |
static void CHECK_OVERFLOW_uint64_MOD(symbol_c *res, symbol_c *a, symbol_c *b) { |
574
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
437 |
if (!VALID_CVALUE(uint64, res)) |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
438 |
return; |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
439 |
/* no overflow condition exists, including division by zero, which IEC 61131-3 considers legal for MOD operation! */ |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
440 |
if (false) |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
441 |
SET_OVFLOW(uint64, res); |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
442 |
} |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
443 |
|
572
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
444 |
|
643
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
445 |
/* res = - a */ |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
446 |
static void CHECK_OVERFLOW_uint64_NEG(symbol_c *res, symbol_c *a) { |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
447 |
/* The only legal operation is res = -0, everything else is an overflow! */ |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
448 |
if (VALID_CVALUE(uint64, a) && (GET_CVALUE(uint64, a) != 0)) |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
449 |
SET_OVFLOW(uint64, res); |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
450 |
} |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
451 |
|
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
452 |
|
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
453 |
|
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
454 |
|
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
455 |
|
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
456 |
|
572
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
457 |
/* res = a + b */ |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
458 |
static void CHECK_OVERFLOW_int64_SUM(symbol_c *res, symbol_c *a_ptr, symbol_c *b_ptr) { |
574
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
459 |
if (!VALID_CVALUE(int64, res)) |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
460 |
return; |
572
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
461 |
int64_t a = GET_CVALUE(int64, a_ptr); |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
462 |
int64_t b = GET_CVALUE(int64, b_ptr); |
574
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
463 |
/* The following test is valid no matter what representation is being used (e.g. two's complement, etc...) */ |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
464 |
if (((b > 0) && (a > (INT64_MAX - b))) |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
465 |
|| ((b < 0) && (a < (INT64_MIN - b)))) |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
466 |
SET_OVFLOW(int64, res); |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
467 |
} |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
468 |
|
572
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
469 |
|
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
470 |
/* res = a - b */ |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
471 |
static void CHECK_OVERFLOW_int64_SUB(symbol_c *res, symbol_c *a_ptr, symbol_c *b_ptr) { |
574
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
472 |
if (!VALID_CVALUE(int64, res)) |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
473 |
return; |
572
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
474 |
int64_t a = GET_CVALUE(int64, a_ptr); |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
475 |
int64_t b = GET_CVALUE(int64, b_ptr); |
574
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
476 |
/* The following test is valid no matter what representation is being used (e.g. two's complement, etc...) */ |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
477 |
if (((b > 0) && (a < (INT64_MIN + b))) |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
478 |
|| ((b < 0) && (a > (INT64_MAX + b)))) |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
479 |
SET_OVFLOW(int64, res); |
572
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
480 |
} |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
481 |
|
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
482 |
|
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
483 |
/* res = a * b */ |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
484 |
static void CHECK_OVERFLOW_int64_MUL(symbol_c *res, symbol_c *a_ptr, symbol_c *b_ptr) { |
574
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
485 |
if (!VALID_CVALUE(int64, res)) |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
486 |
return; |
572
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
487 |
int64_t a = GET_CVALUE(int64, a_ptr); |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
488 |
int64_t b = GET_CVALUE(int64, b_ptr); |
574
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
489 |
if ( ( (a > 0) && (b > 0) && (a > (INT64_MAX / b))) |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
490 |
|| ( (a > 0) && !(b > 0) && (b < (INT64_MIN / a))) |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
491 |
|| (!(a > 0) && (b > 0) && (a < (INT64_MIN / b))) |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
492 |
|| (!(a > 0) && !(b > 0) && (a != 0) && (b < (INT64_MAX / a)))) |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
493 |
SET_OVFLOW(int64, res); |
572
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
494 |
} |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
495 |
|
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
496 |
|
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
497 |
/* res = a / b */ |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
498 |
static void CHECK_OVERFLOW_int64_DIV(symbol_c *res, symbol_c *a_ptr, symbol_c *b_ptr) { |
574
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
499 |
if (!VALID_CVALUE(int64, res)) |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
500 |
return; |
572
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
501 |
int64_t a = GET_CVALUE(int64, a_ptr); |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
502 |
int64_t b = GET_CVALUE(int64, b_ptr); |
574
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
503 |
if ((b == 0) || ((a == INT64_MIN) && (b == -1))) |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
504 |
SET_OVFLOW(int64, res); |
572
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
505 |
} |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
506 |
|
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
507 |
|
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
508 |
/* res = a MOD b */ |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
509 |
static void CHECK_OVERFLOW_int64_MOD(symbol_c *res, symbol_c *a_ptr, symbol_c *b_ptr) { |
574
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
510 |
if (!VALID_CVALUE(int64, res)) |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
511 |
return; |
572
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
512 |
int64_t a = GET_CVALUE(int64, a_ptr); |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
513 |
int64_t b = GET_CVALUE(int64, b_ptr); |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
514 |
/* IEC 61131-3 standard says IN1 MOD IN2 must be equivalent to |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
515 |
* IF (IN2 = 0) THEN OUT:=0 ; ELSE OUT:=IN1 - (IN1/IN2)*IN2 ; END_IF |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
516 |
* |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
517 |
* Note that, when IN1 = INT64_MIN, and IN2 = -1, an overflow occurs in the division, |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
518 |
* so although the MOD operation should be OK, acording to the above definition, we actually have an overflow!! |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
519 |
* |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
520 |
* On the other hand, division by 0 is OK!! |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
521 |
*/ |
574
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
522 |
if ((a == INT64_MIN) && (b == -1)) |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
523 |
SET_OVFLOW(int64, res); |
572
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
524 |
} |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
525 |
|
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
526 |
|
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
527 |
/* res = - a */ |
643
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
528 |
static void CHECK_OVERFLOW_int64_NEG(symbol_c *res, symbol_c *a) { |
574
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
529 |
if (!VALID_CVALUE(int64, res)) |
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
530 |
return; |
643
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
531 |
if (GET_CVALUE(int64, a) == INT64_MIN) |
574
d291a942899b
Fix remaining overflow checks.
Mario de Sousa <msousa@fe.up.pt>
parents:
573
diff
changeset
|
532 |
SET_OVFLOW(int64, res); |
572
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
533 |
} |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
534 |
|
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
535 |
|
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
536 |
|
643
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
537 |
|
579
983a3b743085
Fix 'overflow' detection for real64.
Mario de Sousa <msousa@fe.up.pt>
parents:
578
diff
changeset
|
538 |
static void CHECK_OVERFLOW_real64(symbol_c *res_ptr) { |
983a3b743085
Fix 'overflow' detection for real64.
Mario de Sousa <msousa@fe.up.pt>
parents:
578
diff
changeset
|
539 |
if (!VALID_CVALUE(real64, res_ptr)) |
983a3b743085
Fix 'overflow' detection for real64.
Mario de Sousa <msousa@fe.up.pt>
parents:
578
diff
changeset
|
540 |
return; |
983a3b743085
Fix 'overflow' detection for real64.
Mario de Sousa <msousa@fe.up.pt>
parents:
578
diff
changeset
|
541 |
real64_t res = GET_CVALUE(real64, res_ptr); |
983a3b743085
Fix 'overflow' detection for real64.
Mario de Sousa <msousa@fe.up.pt>
parents:
578
diff
changeset
|
542 |
/* NaN => underflow, overflow, number is a higher precision format, is a complex number (IEEE standard) */ |
983a3b743085
Fix 'overflow' detection for real64.
Mario de Sousa <msousa@fe.up.pt>
parents:
578
diff
changeset
|
543 |
/* The IEC 61131-3 clearly states in section '2.5.1.5.2 Numerical functions': |
983a3b743085
Fix 'overflow' detection for real64.
Mario de Sousa <msousa@fe.up.pt>
parents:
578
diff
changeset
|
544 |
* "It is an error if the result of evaluation of one of these [numerical] functions exceeds the range of values |
983a3b743085
Fix 'overflow' detection for real64.
Mario de Sousa <msousa@fe.up.pt>
parents:
578
diff
changeset
|
545 |
* specified for the data type of the function output, or if division by zero is attempted." |
983a3b743085
Fix 'overflow' detection for real64.
Mario de Sousa <msousa@fe.up.pt>
parents:
578
diff
changeset
|
546 |
* For this reason, any operation that has as a result a positive or negative inifinity, is also an error! |
983a3b743085
Fix 'overflow' detection for real64.
Mario de Sousa <msousa@fe.up.pt>
parents:
578
diff
changeset
|
547 |
*/ |
607
be9ba3531afb
cleaning up code. Changing HUGE_VAL to INFINITY.
Mario de Sousa <msousa@fe.up.pt>
parents:
604
diff
changeset
|
548 |
if ((isnan(res)) || (res == INFINITY) || (res == -INFINITY)) |
579
983a3b743085
Fix 'overflow' detection for real64.
Mario de Sousa <msousa@fe.up.pt>
parents:
578
diff
changeset
|
549 |
SET_OVFLOW(real64, res_ptr); |
572
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
550 |
} |
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
551 |
|
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
552 |
|
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
553 |
|
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
554 |
|
612 | 555 |
/***********************************************************************/ |
556 |
/***********************************************************************/ |
|
557 |
/***********************************************************************/ |
|
558 |
/*** Functions to execute operations on the const values ***/ |
|
559 |
/***********************************************************************/ |
|
560 |
/***********************************************************************/ |
|
561 |
/***********************************************************************/ |
|
562 |
||
563 |
/* static void *handle_cmp(symbol_c *symbol, symbol_c *oper1, symbol_c *oper2, OPERATION) */ |
|
564 |
#define handle_cmp(symbol, oper1, oper2, operation) { \ |
|
565 |
if ((NULL == oper1) || (NULL == oper2)) return NULL; \ |
|
643
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
566 |
DO_BINARY_OPER( bool, operation, bool, oper1, oper2); \ |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
567 |
DO_BINARY_OPER(uint64, operation, bool, oper1, oper2); \ |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
568 |
DO_BINARY_OPER( int64, operation, bool, oper1, oper2); \ |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
569 |
DO_BINARY_OPER(real64, operation, bool, oper1, oper2); \ |
612 | 570 |
return NULL; \ |
571 |
} |
|
572 |
||
573 |
||
574 |
/* NOTE: the MOVE standard function is equivalent to the ':=' in ST syntax */ |
|
575 |
static void *handle_move(symbol_c *to, symbol_c *from) { |
|
576 |
if (NULL == from) return NULL; |
|
577 |
to->const_value = from->const_value; |
|
578 |
return NULL; |
|
579 |
} |
|
580 |
||
581 |
||
582 |
/* unary negation (multiply by -1) */ |
|
583 |
static void *handle_neg(symbol_c *symbol, symbol_c *oper) { |
|
643
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
584 |
if (NULL == oper) return NULL; |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
585 |
/* NOTE: The oper may never be an integer/real literal, '-1' and '-2.2' are stored as an neg_integer_c/neg_real_c instead. |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
586 |
* Because of this, we MUST NOT handle the INT_MIN special situation that is handled in neg_integer_c visitor! |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
587 |
* |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
588 |
* VAR v1, v2, v3 : UINT; END_VAR; |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
589 |
* v1 = 9223372036854775808 ; (* |INT64_MIN| == -INT64_MIN *) <------ LEGAL |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
590 |
* v2 = -(-v1); <------ ILLEGAL (since it -v1 is overflow!) |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
591 |
* v2 = -(-9223372036854775808 ); <------ MUST also be ILLEGAL |
640 | 592 |
*/ |
643
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
593 |
DO_UNARY_OPER(uint64, -, oper); CHECK_OVERFLOW_uint64_NEG(symbol, oper); /* handle the uint_v := -0 situation! */ |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
594 |
DO_UNARY_OPER( int64, -, oper); CHECK_OVERFLOW_int64_NEG (symbol, oper); |
612 | 595 |
DO_UNARY_OPER(real64, -, oper); CHECK_OVERFLOW_real64(symbol); |
596 |
return NULL; |
|
597 |
} |
|
598 |
||
599 |
||
600 |
/* unary boolean negation (NOT) */ |
|
601 |
static void *handle_not(symbol_c *symbol, symbol_c *oper) { |
|
602 |
if (NULL == oper) return NULL; |
|
603 |
DO_UNARY_OPER( bool, !, oper); |
|
604 |
DO_UNARY_OPER(uint64, ~, oper); |
|
605 |
return NULL; |
|
606 |
} |
|
607 |
||
608 |
||
609 |
static void *handle_or (symbol_c *symbol, symbol_c *oper1, symbol_c *oper2) { |
|
610 |
if ((NULL == oper1) || (NULL == oper2)) return NULL; |
|
643
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
611 |
DO_BINARY_OPER( bool, ||, bool , oper1, oper2); |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
612 |
DO_BINARY_OPER(uint64, | , uint64, oper1, oper2); |
612 | 613 |
return NULL; |
614 |
} |
|
615 |
||
616 |
||
617 |
static void *handle_xor(symbol_c *symbol, symbol_c *oper1, symbol_c *oper2) { |
|
618 |
if ((NULL == oper1) || (NULL == oper2)) return NULL; |
|
643
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
619 |
DO_BINARY_OPER( bool, ^, bool , oper1, oper2); |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
620 |
DO_BINARY_OPER(uint64, ^, uint64, oper1, oper2); |
612 | 621 |
return NULL; |
622 |
} |
|
623 |
||
624 |
||
625 |
static void *handle_and(symbol_c *symbol, symbol_c *oper1, symbol_c *oper2) { |
|
626 |
if ((NULL == oper1) || (NULL == oper2)) return NULL; |
|
643
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
627 |
DO_BINARY_OPER( bool, &&, bool, oper1, oper2); |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
628 |
DO_BINARY_OPER(uint64, & , uint64, oper1, oper2); |
612 | 629 |
return NULL; |
630 |
} |
|
631 |
||
632 |
||
633 |
static void *handle_add(symbol_c *symbol, symbol_c *oper1, symbol_c *oper2) { |
|
634 |
if ((NULL == oper1) || (NULL == oper2)) return NULL; |
|
643
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
635 |
DO_BINARY_OPER(uint64, +, uint64, oper1, oper2); CHECK_OVERFLOW_uint64_SUM(symbol, oper1, oper2); |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
636 |
DO_BINARY_OPER( int64, +, int64, oper1, oper2); CHECK_OVERFLOW_int64_SUM (symbol, oper1, oper2); |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
637 |
DO_BINARY_OPER(real64, +, real64, oper1, oper2); CHECK_OVERFLOW_real64 (symbol); |
612 | 638 |
return NULL; |
639 |
} |
|
640 |
||
641 |
||
642 |
static void *handle_sub(symbol_c *symbol, symbol_c *oper1, symbol_c *oper2) { |
|
643 |
if ((NULL == oper1) || (NULL == oper2)) return NULL; |
|
643
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
644 |
DO_BINARY_OPER(uint64, -, uint64, oper1, oper2); CHECK_OVERFLOW_uint64_SUB(symbol, oper1, oper2); |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
645 |
DO_BINARY_OPER( int64, -, int64, oper1, oper2); CHECK_OVERFLOW_int64_SUB (symbol, oper1, oper2); |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
646 |
DO_BINARY_OPER(real64, -, real64, oper1, oper2); CHECK_OVERFLOW_real64 (symbol); |
612 | 647 |
return NULL; |
648 |
} |
|
649 |
||
650 |
||
651 |
static void *handle_mul(symbol_c *symbol, symbol_c *oper1, symbol_c *oper2) { |
|
652 |
if ((NULL == oper1) || (NULL == oper2)) return NULL; |
|
643
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
653 |
DO_BINARY_OPER(uint64, *, uint64, oper1, oper2); CHECK_OVERFLOW_uint64_MUL(symbol, oper1, oper2); |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
654 |
DO_BINARY_OPER( int64, *, int64, oper1, oper2); CHECK_OVERFLOW_int64_MUL (symbol, oper1, oper2); |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
655 |
DO_BINARY_OPER(real64, *, real64, oper1, oper2); CHECK_OVERFLOW_real64 (symbol); |
612 | 656 |
return NULL; |
657 |
} |
|
658 |
||
659 |
||
660 |
static void *handle_div(symbol_c *symbol, symbol_c *oper1, symbol_c *oper2) { |
|
661 |
if ((NULL == oper1) || (NULL == oper2)) return NULL; |
|
643
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
662 |
if (ISZERO_CVALUE(uint64, oper2)) {SET_OVFLOW(uint64, symbol);} else {DO_BINARY_OPER(uint64, /, uint64, oper1, oper2); CHECK_OVERFLOW_uint64_DIV(symbol, oper1, oper2);}; |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
663 |
if (ISZERO_CVALUE( int64, oper2)) {SET_OVFLOW( int64, symbol);} else {DO_BINARY_OPER( int64, /, int64, oper1, oper2); CHECK_OVERFLOW_int64_DIV (symbol, oper1, oper2);}; |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
664 |
if (ISZERO_CVALUE(real64, oper2)) {SET_OVFLOW(real64, symbol);} else {DO_BINARY_OPER(real64, /, real64, oper1, oper2); CHECK_OVERFLOW_real64(symbol);}; |
612 | 665 |
return NULL; |
666 |
} |
|
667 |
||
668 |
||
669 |
static void *handle_mod(symbol_c *symbol, symbol_c *oper1, symbol_c *oper2) { |
|
670 |
if ((NULL == oper1) || (NULL == oper2)) return NULL; |
|
671 |
/* IEC 61131-3 standard says IN1 MOD IN2 must be equivalent to |
|
672 |
* IF (IN2 = 0) THEN OUT:=0 ; ELSE OUT:=IN1 - (IN1/IN2)*IN2 ; END_IF |
|
673 |
* |
|
674 |
* Note that, when IN1 = INT64_MIN, and IN2 = -1, an overflow occurs in the division, |
|
675 |
* so although the MOD operation should be OK, acording to the above definition, we actually have an overflow!! |
|
676 |
*/ |
|
643
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
677 |
if (ISZERO_CVALUE(uint64, oper2)) {SET_CVALUE(uint64, symbol, 0);} else {DO_BINARY_OPER(uint64, %, uint64, oper1, oper2); CHECK_OVERFLOW_uint64_MOD(symbol, oper1, oper2);}; |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
678 |
if (ISZERO_CVALUE( int64, oper2)) {SET_CVALUE( int64, symbol, 0);} else {DO_BINARY_OPER( int64, %, int64, oper1, oper2); CHECK_OVERFLOW_int64_MOD (symbol, oper1, oper2);}; |
612 | 679 |
return NULL; |
680 |
} |
|
681 |
||
682 |
||
683 |
static void *handle_pow(symbol_c *symbol, symbol_c *oper1, symbol_c *oper2) { |
|
684 |
/* NOTE: If the const_value in symbol->r_exp is within the limits of both int64 and uint64, then we do both operations. |
|
685 |
* That is OK, as the result should be identicial (we do create an unnecessary CVALUE variable, but who cares?). |
|
686 |
* If only one is valid, then that is the oper we will do! |
|
687 |
*/ |
|
688 |
if (VALID_CVALUE(real64, oper1) && VALID_CVALUE( int64, oper2)) |
|
689 |
SET_CVALUE(real64, symbol, pow(GET_CVALUE(real64, oper1), GET_CVALUE( int64, oper2))); |
|
690 |
if (VALID_CVALUE(real64, oper1) && VALID_CVALUE(uint64, oper2)) |
|
691 |
SET_CVALUE(real64, symbol, pow(GET_CVALUE(real64, oper1), GET_CVALUE(uint64, oper2))); |
|
692 |
CHECK_OVERFLOW_real64(symbol); |
|
693 |
return NULL; |
|
694 |
} |
|
695 |
||
696 |
/***********************************************************************/ |
|
697 |
/***********************************************************************/ |
|
698 |
/***********************************************************************/ |
|
699 |
/*** Helper functions for handling IL instruction lists. ***/ |
|
700 |
/***********************************************************************/ |
|
701 |
/***********************************************************************/ |
|
702 |
/***********************************************************************/ |
|
703 |
||
704 |
||
705 |
/* If the cvalues of all the prev_il_intructions have the same VALID value, then set the local cvalue to that value, otherwise, set it to NONCONST! */ |
|
706 |
#define intersect_prev_CVALUE_(dtype, symbol) { \ |
|
707 |
symbol->const_value._##dtype = symbol->prev_il_instruction[0]->const_value._##dtype; \ |
|
708 |
for (unsigned int i = 1; i < symbol->prev_il_instruction.size(); i++) { \ |
|
709 |
if (!ISEQUAL_CVALUE(dtype, symbol, symbol->prev_il_instruction[i])) \ |
|
710 |
{SET_NONCONST(dtype, symbol); break;} \ |
|
711 |
} \ |
|
712 |
} |
|
713 |
||
714 |
static void intersect_prev_cvalues(il_instruction_c *symbol) { |
|
715 |
if (symbol->prev_il_instruction.empty()) |
|
716 |
return; |
|
717 |
intersect_prev_CVALUE_(real64, symbol); |
|
718 |
intersect_prev_CVALUE_(uint64, symbol); |
|
719 |
intersect_prev_CVALUE_( int64, symbol); |
|
720 |
intersect_prev_CVALUE_( bool, symbol); |
|
721 |
} |
|
572
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
722 |
|
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
723 |
|
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
724 |
|
596
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
725 |
/***********************************************************************/ |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
726 |
/***********************************************************************/ |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
727 |
/***********************************************************************/ |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
728 |
/*** The constant_folding_c ***/ |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
729 |
/***********************************************************************/ |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
730 |
/***********************************************************************/ |
4efb11e44065
Add ERROR_MSG macro && move extract_XXX() functions to constant_folding.cc
Mario de Sousa <msousa@fe.up.pt>
parents:
592
diff
changeset
|
731 |
/***********************************************************************/ |
572
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
732 |
|
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
733 |
|
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
734 |
|
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
735 |
|
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
736 |
|
c353bc67bf91
Correctly implement MOD operation and overflow checks (still missing uint * / MOD).
Mario de Sousa <msousa@fe.up.pt>
parents:
570
diff
changeset
|
737 |
|
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
738 |
constant_folding_c::constant_folding_c(symbol_c *symbol) { |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
739 |
error_count = 0; |
568
5f79478142d7
make the compiler platform independent (i.e. no longer assume sizeof(double)==8).
Mario de Sousa <msousa@fe.up.pt>
parents:
567
diff
changeset
|
740 |
warning_found = false; |
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
741 |
current_display_error_level = 0; |
661
f537c3315f83
Minor changes needed to build with pedantic flag.
Manuele Conti <conti.ma@alice.it>
parents:
648
diff
changeset
|
742 |
il_operand = NULL; |
f537c3315f83
Minor changes needed to build with pedantic flag.
Manuele Conti <conti.ma@alice.it>
parents:
648
diff
changeset
|
743 |
search_varfb_instance_type = NULL; |
f537c3315f83
Minor changes needed to build with pedantic flag.
Manuele Conti <conti.ma@alice.it>
parents:
648
diff
changeset
|
744 |
prev_il_instruction = NULL; |
568
5f79478142d7
make the compiler platform independent (i.e. no longer assume sizeof(double)==8).
Mario de Sousa <msousa@fe.up.pt>
parents:
567
diff
changeset
|
745 |
|
5f79478142d7
make the compiler platform independent (i.e. no longer assume sizeof(double)==8).
Mario de Sousa <msousa@fe.up.pt>
parents:
567
diff
changeset
|
746 |
/* check whether the platform on which the compiler is being run implements IEC 559 floating point data types. */ |
5f79478142d7
make the compiler platform independent (i.e. no longer assume sizeof(double)==8).
Mario de Sousa <msousa@fe.up.pt>
parents:
567
diff
changeset
|
747 |
symbol_c null_symbol; |
5f79478142d7
make the compiler platform independent (i.e. no longer assume sizeof(double)==8).
Mario de Sousa <msousa@fe.up.pt>
parents:
567
diff
changeset
|
748 |
if (! (std::numeric_limits<real64_t>::is_iec559) ) |
579
983a3b743085
Fix 'overflow' detection for real64.
Mario de Sousa <msousa@fe.up.pt>
parents:
578
diff
changeset
|
749 |
STAGE3_WARNING(&null_symbol, &null_symbol, "The platform running the compiler does not implement IEC 60559 floating point numbers. " |
568
5f79478142d7
make the compiler platform independent (i.e. no longer assume sizeof(double)==8).
Mario de Sousa <msousa@fe.up.pt>
parents:
567
diff
changeset
|
750 |
"Any error and/or warning messages related to overflow/underflow of the result of operations on REAL/LREAL literals " |
579
983a3b743085
Fix 'overflow' detection for real64.
Mario de Sousa <msousa@fe.up.pt>
parents:
578
diff
changeset
|
751 |
"(i.e. constant folding) may themselves be erroneous, although are most probably correct." |
983a3b743085
Fix 'overflow' detection for real64.
Mario de Sousa <msousa@fe.up.pt>
parents:
578
diff
changeset
|
752 |
"However, more likely is the possible existance of overflow/underflow errors that are not detected."); |
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
753 |
} |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
754 |
|
567
e5deeb6d4d2f
create extract_real_value() in absyntax_utils. NOTE: overflows not yet handled!
Mario de Sousa <msousa@fe.up.pt>
parents:
566
diff
changeset
|
755 |
|
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
756 |
constant_folding_c::~constant_folding_c(void) { |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
757 |
} |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
758 |
|
567
e5deeb6d4d2f
create extract_real_value() in absyntax_utils. NOTE: overflows not yet handled!
Mario de Sousa <msousa@fe.up.pt>
parents:
566
diff
changeset
|
759 |
|
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
760 |
int constant_folding_c::get_error_count() { |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
761 |
return error_count; |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
762 |
} |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
763 |
|
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
764 |
|
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
765 |
/*********************/ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
766 |
/* B 1.2 - Constants */ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
767 |
/*********************/ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
768 |
/******************************/ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
769 |
/* B 1.2.1 - Numeric Literals */ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
770 |
/******************************/ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
771 |
void *constant_folding_c::visit(real_c *symbol) { |
576
8368ec909825
Fix extract_real (thanks Manuele), and add check for overflow.
Mario de Sousa <msousa@fe.up.pt>
parents:
575
diff
changeset
|
772 |
bool overflow; |
612 | 773 |
SET_CVALUE(real64, symbol, extract_real_value(symbol, &overflow)); |
576
8368ec909825
Fix extract_real (thanks Manuele), and add check for overflow.
Mario de Sousa <msousa@fe.up.pt>
parents:
575
diff
changeset
|
774 |
if (overflow) SET_OVFLOW(real64, symbol); |
567
e5deeb6d4d2f
create extract_real_value() in absyntax_utils. NOTE: overflows not yet handled!
Mario de Sousa <msousa@fe.up.pt>
parents:
566
diff
changeset
|
775 |
return NULL; |
e5deeb6d4d2f
create extract_real_value() in absyntax_utils. NOTE: overflows not yet handled!
Mario de Sousa <msousa@fe.up.pt>
parents:
566
diff
changeset
|
776 |
} |
e5deeb6d4d2f
create extract_real_value() in absyntax_utils. NOTE: overflows not yet handled!
Mario de Sousa <msousa@fe.up.pt>
parents:
566
diff
changeset
|
777 |
|
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
778 |
|
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
779 |
void *constant_folding_c::visit(integer_c *symbol) { |
587
1ecf916cc397
Fix extract_integer_value.
Manuele Conti <conti.ma@alice.it>
parents:
579
diff
changeset
|
780 |
bool overflow; |
612 | 781 |
SET_CVALUE( int64, symbol, extract_int64_value (symbol, &overflow)); |
588
3d72d09bd40f
Add missing set overflow flag.
Manuele Conti <conti.ma@alice.it>
parents:
587
diff
changeset
|
782 |
if (overflow) SET_OVFLOW(int64, symbol); |
612 | 783 |
SET_CVALUE(uint64, symbol, extract_uint64_value(symbol, &overflow)); |
588
3d72d09bd40f
Add missing set overflow flag.
Manuele Conti <conti.ma@alice.it>
parents:
587
diff
changeset
|
784 |
if (overflow) SET_OVFLOW(uint64, symbol); |
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
785 |
return NULL; |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
786 |
} |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
787 |
|
567
e5deeb6d4d2f
create extract_real_value() in absyntax_utils. NOTE: overflows not yet handled!
Mario de Sousa <msousa@fe.up.pt>
parents:
566
diff
changeset
|
788 |
|
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
789 |
void *constant_folding_c::visit(neg_real_c *symbol) { |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
790 |
symbol->exp->accept(*this); |
643
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
791 |
DO_UNARY_OPER(real64, -, symbol->exp); CHECK_OVERFLOW_real64(symbol); |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
792 |
if (IS_OVFLOW(real64, symbol->exp)) SET_OVFLOW(real64, symbol); |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
793 |
return NULL; |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
794 |
} |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
795 |
|
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
796 |
|
569
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
797 |
|
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
798 |
/* | '-' integer {$$ = new neg_integer_c($2, locloc(@$));} */ |
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
799 |
void *constant_folding_c::visit(neg_integer_c *symbol) { |
569
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
800 |
symbol->exp->accept(*this); |
643
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
801 |
/* Note that due to syntax restrictions, the value of symbol->exp will always be positive. |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
802 |
* However, the following code does not depend on that restriction. |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
803 |
*/ |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
804 |
/* The remainder of the code (for example, data type checking) considers the neg_integer_c as a leaf of the |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
805 |
* abstract syntax tree, and therefore simply ignores the values of neg_integer_c->exp. |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
806 |
* For this reason only, and in only this situation, we must guarantee that any 'overflow' situation in |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
807 |
* the cvalue of neg_integer_c->exp is also reflected back to this neg_integer_c symbol. |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
808 |
* For the rest of the code we do NOT do this, as it would gurantee that a single overflow deep inside |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
809 |
* an expression would imply that the expression itself would also be set to 'overflow' condition. |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
810 |
* This in turn would then have the compiler produce a whole load of error messages where they are not wanted! |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
811 |
*/ |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
812 |
DO_UNARY_OPER(uint64, -, symbol->exp); CHECK_OVERFLOW_uint64_NEG(symbol, symbol->exp); /* handle the uintv := -0 situation */ |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
813 |
if (IS_OVFLOW(uint64, symbol->exp)) SET_OVFLOW(uint64, symbol); |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
814 |
DO_UNARY_OPER( int64, -, symbol->exp); CHECK_OVERFLOW_int64_NEG (symbol, symbol->exp); |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
815 |
if (IS_OVFLOW( int64, symbol->exp)) SET_OVFLOW( int64, symbol); |
590
649667749171
Add support for -INT64_MIN values in literals.
Mario de Sousa <msousa@fe.up.pt>
parents:
588
diff
changeset
|
816 |
/* NOTE 1: INT64_MIN = -(INT64_MAX + 1) ---> assuming two's complement representation!!! |
649667749171
Add support for -INT64_MIN values in literals.
Mario de Sousa <msousa@fe.up.pt>
parents:
588
diff
changeset
|
817 |
* NOTE 2: if the user happens to want INT_MIN, that value will first be parsed as a positive integer, before being negated here. |
649667749171
Add support for -INT64_MIN values in literals.
Mario de Sousa <msousa@fe.up.pt>
parents:
588
diff
changeset
|
818 |
* However, the positive value cannot be stored inside an int64! So, in this case, we will get the value from the uint64 cvalue. |
643
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
819 |
* |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
820 |
* This same situation is usually considered an overflow (check handle_neg() function). However, here we have a special |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
821 |
* situation. If we do not allow this, then the user would never the able to use the following code: |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
822 |
* VAR v : LINT; END_VAR |
1cc0e1ca2aad
Fix constant folding: now handles INT_MIN and neg_integer_c correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
640
diff
changeset
|
823 |
* v := -9223372036854775809 ; (* - |INT64_MIN| == INT64_MIN *) |
590
649667749171
Add support for -INT64_MIN values in literals.
Mario de Sousa <msousa@fe.up.pt>
parents:
588
diff
changeset
|
824 |
*/ |
649667749171
Add support for -INT64_MIN values in literals.
Mario de Sousa <msousa@fe.up.pt>
parents:
588
diff
changeset
|
825 |
// if (INT64_MIN == -INT64_MAX - 1) // We do not really need to check that the platform uses two's complement |
621
e3616f6b6959
Remove remaining signed/unsigned comparison error messages when compiling.
Mario de Sousa <msousa@fe.up.pt>
parents:
612
diff
changeset
|
826 |
if (VALID_CVALUE(uint64, symbol->exp) && (GET_CVALUE(uint64, symbol->exp) == (uint64_t)INT64_MAX+1)) { |
590
649667749171
Add support for -INT64_MIN values in literals.
Mario de Sousa <msousa@fe.up.pt>
parents:
588
diff
changeset
|
827 |
SET_CVALUE(int64, symbol, INT64_MIN); |
649667749171
Add support for -INT64_MIN values in literals.
Mario de Sousa <msousa@fe.up.pt>
parents:
588
diff
changeset
|
828 |
} |
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
829 |
return NULL; |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
830 |
} |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
831 |
|
567
e5deeb6d4d2f
create extract_real_value() in absyntax_utils. NOTE: overflows not yet handled!
Mario de Sousa <msousa@fe.up.pt>
parents:
566
diff
changeset
|
832 |
|
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
833 |
void *constant_folding_c::visit(binary_integer_c *symbol) { |
600
f5d4e9f91513
determine const value of hex, octal and bin literals correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
596
diff
changeset
|
834 |
bool overflow; |
612 | 835 |
SET_CVALUE( int64, symbol, extract_int64_value (symbol, &overflow)); |
600
f5d4e9f91513
determine const value of hex, octal and bin literals correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
596
diff
changeset
|
836 |
if (overflow) SET_OVFLOW(int64, symbol); |
612 | 837 |
SET_CVALUE(uint64, symbol, extract_uint64_value(symbol, &overflow)); |
600
f5d4e9f91513
determine const value of hex, octal and bin literals correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
596
diff
changeset
|
838 |
if (overflow) SET_OVFLOW(uint64, symbol); |
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
839 |
return NULL; |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
840 |
} |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
841 |
|
567
e5deeb6d4d2f
create extract_real_value() in absyntax_utils. NOTE: overflows not yet handled!
Mario de Sousa <msousa@fe.up.pt>
parents:
566
diff
changeset
|
842 |
|
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
843 |
void *constant_folding_c::visit(octal_integer_c *symbol) { |
600
f5d4e9f91513
determine const value of hex, octal and bin literals correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
596
diff
changeset
|
844 |
bool overflow; |
612 | 845 |
SET_CVALUE( int64, symbol, extract_int64_value (symbol, &overflow)); |
600
f5d4e9f91513
determine const value of hex, octal and bin literals correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
596
diff
changeset
|
846 |
if (overflow) SET_OVFLOW(int64, symbol); |
612 | 847 |
SET_CVALUE(uint64, symbol, extract_uint64_value(symbol, &overflow)); |
600
f5d4e9f91513
determine const value of hex, octal and bin literals correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
596
diff
changeset
|
848 |
if (overflow) SET_OVFLOW(uint64, symbol); |
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
849 |
return NULL; |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
850 |
} |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
851 |
|
567
e5deeb6d4d2f
create extract_real_value() in absyntax_utils. NOTE: overflows not yet handled!
Mario de Sousa <msousa@fe.up.pt>
parents:
566
diff
changeset
|
852 |
|
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
853 |
void *constant_folding_c::visit(hex_integer_c *symbol) { |
600
f5d4e9f91513
determine const value of hex, octal and bin literals correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
596
diff
changeset
|
854 |
bool overflow; |
612 | 855 |
SET_CVALUE( int64, symbol, extract_int64_value (symbol, &overflow)); |
600
f5d4e9f91513
determine const value of hex, octal and bin literals correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
596
diff
changeset
|
856 |
if (overflow) SET_OVFLOW(int64, symbol); |
612 | 857 |
SET_CVALUE(uint64, symbol, extract_uint64_value(symbol, &overflow)); |
600
f5d4e9f91513
determine const value of hex, octal and bin literals correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
596
diff
changeset
|
858 |
if (overflow) SET_OVFLOW(uint64, symbol); |
569
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
859 |
return NULL; |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
860 |
} |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
861 |
|
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
862 |
|
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
863 |
/* |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
864 |
integer_literal: |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
865 |
integer_type_name '#' signed_integer {$$ = new integer_literal_c($1, $3, locloc(@$));} |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
866 |
| integer_type_name '#' binary_integer {$$ = new integer_literal_c($1, $3, locloc(@$));} |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
867 |
| integer_type_name '#' octal_integer {$$ = new integer_literal_c($1, $3, locloc(@$));} |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
868 |
| integer_type_name '#' hex_integer {$$ = new integer_literal_c($1, $3, locloc(@$));} |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
869 |
*/ |
0d1ab9e78574
Add data structure for storing overflow of constant values.
Mario de Sousa <msousa@fe.up.pt>
parents:
568
diff
changeset
|
870 |
// SYM_REF2(integer_literal_c, type, value) |
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
871 |
void *constant_folding_c::visit(integer_literal_c *symbol) { |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
872 |
symbol->value->accept(*this); |
575 | 873 |
DO_UNARY_OPER( int64, /* none */, symbol->value); |
874 |
DO_UNARY_OPER(uint64, /* none */, symbol->value); |
|
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
875 |
return NULL; |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
876 |
} |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
877 |
|
567
e5deeb6d4d2f
create extract_real_value() in absyntax_utils. NOTE: overflows not yet handled!
Mario de Sousa <msousa@fe.up.pt>
parents:
566
diff
changeset
|
878 |
|
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
879 |
void *constant_folding_c::visit(real_literal_c *symbol) { |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
880 |
symbol->value->accept(*this); |
575 | 881 |
DO_UNARY_OPER(real64, /* none */, symbol->value); |
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
882 |
return NULL; |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
883 |
} |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
884 |
|
567
e5deeb6d4d2f
create extract_real_value() in absyntax_utils. NOTE: overflows not yet handled!
Mario de Sousa <msousa@fe.up.pt>
parents:
566
diff
changeset
|
885 |
|
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
886 |
void *constant_folding_c::visit(bit_string_literal_c *symbol) { |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
887 |
return NULL; |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
888 |
} |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
889 |
|
567
e5deeb6d4d2f
create extract_real_value() in absyntax_utils. NOTE: overflows not yet handled!
Mario de Sousa <msousa@fe.up.pt>
parents:
566
diff
changeset
|
890 |
|
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
891 |
void *constant_folding_c::visit(boolean_literal_c *symbol) { |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
892 |
symbol->value->accept(*this); |
575 | 893 |
DO_UNARY_OPER(bool, /* none */, symbol->value); |
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
894 |
return NULL; |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
895 |
} |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
896 |
|
567
e5deeb6d4d2f
create extract_real_value() in absyntax_utils. NOTE: overflows not yet handled!
Mario de Sousa <msousa@fe.up.pt>
parents:
566
diff
changeset
|
897 |
|
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
898 |
void *constant_folding_c::visit(boolean_true_c *symbol) { |
612 | 899 |
SET_CVALUE(bool, symbol, true); |
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
900 |
return NULL; |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
901 |
} |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
902 |
|
567
e5deeb6d4d2f
create extract_real_value() in absyntax_utils. NOTE: overflows not yet handled!
Mario de Sousa <msousa@fe.up.pt>
parents:
566
diff
changeset
|
903 |
|
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
904 |
void *constant_folding_c::visit(boolean_false_c *symbol) { |
612 | 905 |
SET_CVALUE(bool, symbol, false); |
906 |
return NULL; |
|
907 |
} |
|
908 |
||
633
73b56dc69e61
Fix bug with task interval using fixed_point value for duration items
Laurent Bessard
parents:
621
diff
changeset
|
909 |
/************************/ |
73b56dc69e61
Fix bug with task interval using fixed_point value for duration items
Laurent Bessard
parents:
621
diff
changeset
|
910 |
/* B 1.2.3.1 - Duration */ |
73b56dc69e61
Fix bug with task interval using fixed_point value for duration items
Laurent Bessard
parents:
621
diff
changeset
|
911 |
/********* **************/ |
73b56dc69e61
Fix bug with task interval using fixed_point value for duration items
Laurent Bessard
parents:
621
diff
changeset
|
912 |
void *constant_folding_c::visit(fixed_point_c *symbol) { |
73b56dc69e61
Fix bug with task interval using fixed_point value for duration items
Laurent Bessard
parents:
621
diff
changeset
|
913 |
bool overflow; |
73b56dc69e61
Fix bug with task interval using fixed_point value for duration items
Laurent Bessard
parents:
621
diff
changeset
|
914 |
SET_CVALUE(real64, symbol, extract_real_value(symbol, &overflow)); |
73b56dc69e61
Fix bug with task interval using fixed_point value for duration items
Laurent Bessard
parents:
621
diff
changeset
|
915 |
if (overflow) SET_OVFLOW(real64, symbol); |
73b56dc69e61
Fix bug with task interval using fixed_point value for duration items
Laurent Bessard
parents:
621
diff
changeset
|
916 |
return NULL; |
73b56dc69e61
Fix bug with task interval using fixed_point value for duration items
Laurent Bessard
parents:
621
diff
changeset
|
917 |
} |
612 | 918 |
|
919 |
||
920 |
||
921 |
/****************************************/ |
|
922 |
/* B.2 - Language IL (Instruction List) */ |
|
923 |
/****************************************/ |
|
924 |
/***********************************/ |
|
925 |
/* B 2.1 Instructions and Operands */ |
|
926 |
/***********************************/ |
|
927 |
/* Not needed, since we inherit from iterator_visitor_c */ |
|
928 |
/*| instruction_list il_instruction */ |
|
929 |
// SYM_LIST(instruction_list_c) |
|
930 |
// void *constant_folding_c::visit(instruction_list_c *symbol) {} |
|
931 |
||
932 |
/* | label ':' [il_incomplete_instruction] eol_list */ |
|
933 |
// SYM_REF2(il_instruction_c, label, il_instruction) |
|
934 |
// void *visit(instruction_list_c *symbol); |
|
935 |
void *constant_folding_c::visit(il_instruction_c *symbol) { |
|
936 |
if (NULL == symbol->il_instruction) { |
|
937 |
/* This empty/null il_instruction does not change the value of the current/default IL variable. |
|
938 |
* So it inherits the candidate_datatypes from it's previous IL instructions! |
|
939 |
*/ |
|
940 |
intersect_prev_cvalues(symbol); |
|
941 |
} else { |
|
942 |
il_instruction_c fake_prev_il_instruction = *symbol; |
|
943 |
intersect_prev_cvalues(&fake_prev_il_instruction); |
|
944 |
||
945 |
if (symbol->prev_il_instruction.size() == 0) prev_il_instruction = NULL; |
|
946 |
else prev_il_instruction = &fake_prev_il_instruction; |
|
947 |
symbol->il_instruction->accept(*this); |
|
948 |
prev_il_instruction = NULL; |
|
949 |
||
950 |
/* This object has (inherits) the same cvalues as the il_instruction */ |
|
951 |
symbol->const_value = symbol->il_instruction->const_value; |
|
952 |
} |
|
953 |
||
954 |
return NULL; |
|
955 |
} |
|
956 |
||
957 |
||
958 |
void *constant_folding_c::visit(il_simple_operation_c *symbol) { |
|
959 |
/* determine the cvalue of the operand */ |
|
960 |
if (NULL != symbol->il_operand) { |
|
961 |
symbol->il_operand->accept(*this); |
|
962 |
} |
|
963 |
/* determine the cvalue resulting from executing the il_operator... */ |
|
964 |
il_operand = symbol->il_operand; |
|
965 |
symbol->il_simple_operator->accept(*this); |
|
966 |
il_operand = NULL; |
|
967 |
/* This object has (inherits) the same cvalues as the il_instruction */ |
|
968 |
symbol->const_value = symbol->il_simple_operator->const_value; |
|
969 |
return NULL; |
|
970 |
} |
|
971 |
||
972 |
||
973 |
/* TODO: handle function invocations... */ |
|
974 |
/* | function_name [il_operand_list] */ |
|
975 |
/* NOTE: The parameters 'called_function_declaration' and 'extensible_param_count' are used to pass data between the stage 3 and stage 4. */ |
|
976 |
// SYM_REF2(il_function_call_c, function_name, il_operand_list, symbol_c *called_function_declaration; int extensible_param_count;) |
|
977 |
// void *constant_folding_c::visit(il_function_call_c *symbol) {} |
|
978 |
||
979 |
||
980 |
/* | il_expr_operator '(' [il_operand] eol_list [simple_instr_list] ')' */ |
|
981 |
// SYM_REF3(il_expression_c, il_expr_operator, il_operand, simple_instr_list); |
|
982 |
void *constant_folding_c::visit(il_expression_c *symbol) { |
|
983 |
symbol_c *prev_il_instruction_backup = prev_il_instruction; |
|
984 |
||
690
6156ee2b4e32
Correctly generate C code for IL expressions, i.e. IL instructions inside parenthesis.
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset
|
985 |
/* Stage2 will insert an artificial (and equivalent) LD <il_operand> to the simple_instr_list if necessary. We can therefore ignore the 'il_operand' entry! */ |
6156ee2b4e32
Correctly generate C code for IL expressions, i.e. IL instructions inside parenthesis.
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset
|
986 |
// if (NULL != symbol->il_operand) |
6156ee2b4e32
Correctly generate C code for IL expressions, i.e. IL instructions inside parenthesis.
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset
|
987 |
// symbol->il_operand->accept(*this); |
612 | 988 |
|
989 |
if(symbol->simple_instr_list != NULL) |
|
990 |
symbol->simple_instr_list->accept(*this); |
|
991 |
||
992 |
/* Now do the operation, */ |
|
993 |
il_operand = symbol->simple_instr_list; |
|
994 |
prev_il_instruction = prev_il_instruction_backup; |
|
995 |
symbol->il_expr_operator->accept(*this); |
|
996 |
il_operand = NULL; |
|
997 |
||
998 |
/* This object has (inherits) the same cvalues as the il_instruction */ |
|
999 |
symbol->const_value = symbol->il_expr_operator->const_value; |
|
690
6156ee2b4e32
Correctly generate C code for IL expressions, i.e. IL instructions inside parenthesis.
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset
|
1000 |
|
6156ee2b4e32
Correctly generate C code for IL expressions, i.e. IL instructions inside parenthesis.
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset
|
1001 |
/* Since stage2 will insert an artificial (and equivalent) LD <il_operand> to the simple_instr_list when an 'il_operand' exists, we know |
6156ee2b4e32
Correctly generate C code for IL expressions, i.e. IL instructions inside parenthesis.
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset
|
1002 |
* that if (symbol->il_operand != NULL), then the first IL instruction in the simple_instr_list will be the equivalent and artificial |
6156ee2b4e32
Correctly generate C code for IL expressions, i.e. IL instructions inside parenthesis.
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset
|
1003 |
* 'LD <il_operand>' IL instruction. |
6156ee2b4e32
Correctly generate C code for IL expressions, i.e. IL instructions inside parenthesis.
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset
|
1004 |
* Just to be cosistent, we will copy the constant info back into the il_operand, even though this should not be necessary! |
6156ee2b4e32
Correctly generate C code for IL expressions, i.e. IL instructions inside parenthesis.
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset
|
1005 |
*/ |
6156ee2b4e32
Correctly generate C code for IL expressions, i.e. IL instructions inside parenthesis.
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset
|
1006 |
if ((NULL != symbol->il_operand) && ((NULL == symbol->simple_instr_list) || (0 == ((list_c *)symbol->simple_instr_list)->n))) ERROR; // stage2 is not behaving as we expect it to! |
6156ee2b4e32
Correctly generate C code for IL expressions, i.e. IL instructions inside parenthesis.
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset
|
1007 |
if (NULL != symbol->il_operand) |
6156ee2b4e32
Correctly generate C code for IL expressions, i.e. IL instructions inside parenthesis.
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset
|
1008 |
symbol->il_operand->const_value = ((list_c *)symbol->simple_instr_list)->elements[0]->const_value; |
6156ee2b4e32
Correctly generate C code for IL expressions, i.e. IL instructions inside parenthesis.
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset
|
1009 |
|
612 | 1010 |
return NULL; |
1011 |
} |
|
1012 |
||
1013 |
||
1014 |
||
1015 |
void *constant_folding_c::visit(il_jump_operation_c *symbol) { |
|
1016 |
/* recursive call to fill const values... */ |
|
1017 |
il_operand = NULL; |
|
1018 |
symbol->il_jump_operator->accept(*this); |
|
1019 |
il_operand = NULL; |
|
1020 |
/* This object has (inherits) the same cvalues as the il_jump_operator */ |
|
1021 |
symbol->const_value = symbol->il_jump_operator->const_value; |
|
1022 |
return NULL; |
|
1023 |
} |
|
1024 |
||
1025 |
||
1026 |
||
1027 |
/* FB calls leave the value in the accumulator unchanged */ |
|
1028 |
/* il_call_operator prev_declared_fb_name |
|
1029 |
* | il_call_operator prev_declared_fb_name '(' ')' |
|
1030 |
* | il_call_operator prev_declared_fb_name '(' eol_list ')' |
|
1031 |
* | il_call_operator prev_declared_fb_name '(' il_operand_list ')' |
|
1032 |
* | il_call_operator prev_declared_fb_name '(' eol_list il_param_list ')' |
|
1033 |
*/ |
|
1034 |
/* NOTE: The parameter 'called_fb_declaration'is used to pass data between stage 3 and stage4 (although currently it is not used in stage 4 */ |
|
1035 |
// SYM_REF4(il_fb_call_c, il_call_operator, fb_name, il_operand_list, il_param_list, symbol_c *called_fb_declaration) |
|
1036 |
void *constant_folding_c::visit(il_fb_call_c *symbol) {return handle_move(symbol, prev_il_instruction);} |
|
1037 |
||
1038 |
||
1039 |
/* TODO: handle function invocations... */ |
|
1040 |
/* | function_name '(' eol_list [il_param_list] ')' */ |
|
1041 |
/* NOTE: The parameter 'called_function_declaration' is used to pass data between the stage 3 and stage 4. */ |
|
1042 |
// SYM_REF2(il_formal_funct_call_c, function_name, il_param_list, symbol_c *called_function_declaration; int extensible_param_count;) |
|
1043 |
// void *constant_folding_c::visit(il_formal_funct_call_c *symbol) {return NULL;} |
|
1044 |
||
1045 |
||
1046 |
||
1047 |
/* Not needed, since we inherit from iterator_visitor_c */ |
|
1048 |
// void *constant_folding_c::visit(il_operand_list_c *symbol); |
|
1049 |
||
1050 |
||
1051 |
||
1052 |
/* | simple_instr_list il_simple_instruction */ |
|
1053 |
/* This object is referenced by il_expression_c objects */ |
|
1054 |
void *constant_folding_c::visit(simple_instr_list_c *symbol) { |
|
1055 |
if (symbol->n <= 0) |
|
1056 |
return NULL; /* List is empty! Nothing to do. */ |
|
1057 |
||
1058 |
for(int i = 0; i < symbol->n; i++) |
|
1059 |
symbol->elements[i]->accept(*this); |
|
1060 |
||
1061 |
/* This object has (inherits) the same cvalues as the il_jump_operator */ |
|
1062 |
symbol->const_value = symbol->elements[symbol->n-1]->const_value; |
|
1063 |
return NULL; |
|
1064 |
} |
|
1065 |
||
1066 |
||
1067 |
||
1068 |
// SYM_REF1(il_simple_instruction_c, il_simple_instruction, symbol_c *prev_il_instruction;) |
|
1069 |
void *constant_folding_c::visit(il_simple_instruction_c *symbol) { |
|
1070 |
if (symbol->prev_il_instruction.size() > 1) ERROR; /* There should be no labeled insructions inside an IL expression! */ |
|
1071 |
if (symbol->prev_il_instruction.size() == 0) prev_il_instruction = NULL; |
|
1072 |
else prev_il_instruction = symbol->prev_il_instruction[0]; |
|
1073 |
symbol->il_simple_instruction->accept(*this); |
|
1074 |
prev_il_instruction = NULL; |
|
1075 |
||
1076 |
/* This object has (inherits) the same cvalues as the il_jump_operator */ |
|
1077 |
symbol->const_value = symbol->il_simple_instruction->const_value; |
|
1078 |
return NULL; |
|
1079 |
} |
|
1080 |
||
1081 |
||
1082 |
/* |
|
1083 |
void *visit(il_param_list_c *symbol); |
|
1084 |
void *visit(il_param_assignment_c *symbol); |
|
1085 |
void *visit(il_param_out_assignment_c *symbol); |
|
1086 |
*/ |
|
1087 |
||
1088 |
||
1089 |
/*******************/ |
|
1090 |
/* B 2.2 Operators */ |
|
1091 |
/*******************/ |
|
1092 |
void *constant_folding_c::visit( LD_operator_c *symbol) {return handle_move(symbol, il_operand);} |
|
1093 |
void *constant_folding_c::visit( LDN_operator_c *symbol) {return handle_not (symbol, il_operand);} |
|
1094 |
||
1095 |
/* NOTE: we are implementing a constant folding algorithm, not a constant propagation algorithm. |
|
1096 |
* For the constant propagation algorithm, the correct implementation of ST(N)_operator_c would be... |
|
1097 |
*/ |
|
1098 |
//void *constant_folding_c::visit( ST_operator_c *symbol) {return handle_move(il_operand, symbol);} |
|
1099 |
//void *constant_folding_c::visit( STN_operator_c *symbol) {return handle_not (il_operand, symbol);} |
|
1100 |
void *constant_folding_c::visit( ST_operator_c *symbol) {return handle_move(symbol, prev_il_instruction);} |
|
1101 |
void *constant_folding_c::visit( STN_operator_c *symbol) {return handle_move(symbol, prev_il_instruction);} |
|
1102 |
||
1103 |
/* NOTE: the standard allows syntax in which the NOT operator is followed by an optional <il_operand> |
|
1104 |
* NOT [<il_operand>] |
|
1105 |
* However, it does not define the semantic of the NOT operation when the <il_operand> is specified. |
|
1106 |
* We therefore consider it an error if an il_operand is specified! This error will be caught elsewhere! |
|
1107 |
*/ |
|
1108 |
void *constant_folding_c::visit( NOT_operator_c *symbol) {return handle_not(symbol, prev_il_instruction);} |
|
1109 |
||
1110 |
/* NOTE: Since we are only implementing a constant folding algorithm, and not a constant propagation algorithm, |
|
1111 |
* the following IL instructions do not change/set the value of the il_operand! |
|
1112 |
*/ |
|
1113 |
void *constant_folding_c::visit( S_operator_c *symbol) {return handle_move(symbol, prev_il_instruction);} |
|
1114 |
void *constant_folding_c::visit( R_operator_c *symbol) {return handle_move(symbol, prev_il_instruction);} |
|
1115 |
||
1116 |
/* FB calls leave the value in the accumulator unchanged */ |
|
1117 |
void *constant_folding_c::visit( S1_operator_c *symbol) {return handle_move(symbol, prev_il_instruction);} |
|
1118 |
void *constant_folding_c::visit( R1_operator_c *symbol) {return handle_move(symbol, prev_il_instruction);} |
|
1119 |
void *constant_folding_c::visit( CLK_operator_c *symbol) {return handle_move(symbol, prev_il_instruction);} |
|
1120 |
void *constant_folding_c::visit( CU_operator_c *symbol) {return handle_move(symbol, prev_il_instruction);} |
|
1121 |
void *constant_folding_c::visit( CD_operator_c *symbol) {return handle_move(symbol, prev_il_instruction);} |
|
1122 |
void *constant_folding_c::visit( PV_operator_c *symbol) {return handle_move(symbol, prev_il_instruction);} |
|
1123 |
void *constant_folding_c::visit( IN_operator_c *symbol) {return handle_move(symbol, prev_il_instruction);} |
|
1124 |
void *constant_folding_c::visit( PT_operator_c *symbol) {return handle_move(symbol, prev_il_instruction);} |
|
1125 |
||
1126 |
void *constant_folding_c::visit( AND_operator_c *symbol) {return handle_and (symbol, prev_il_instruction, il_operand);} |
|
1127 |
void *constant_folding_c::visit( OR_operator_c *symbol) {return handle_or (symbol, prev_il_instruction, il_operand);} |
|
1128 |
void *constant_folding_c::visit( XOR_operator_c *symbol) {return handle_xor (symbol, prev_il_instruction, il_operand);} |
|
1129 |
void *constant_folding_c::visit( ANDN_operator_c *symbol) { handle_and (symbol, prev_il_instruction, il_operand); return handle_not(symbol, symbol);} |
|
1130 |
void *constant_folding_c::visit( ORN_operator_c *symbol) { handle_or (symbol, prev_il_instruction, il_operand); return handle_not(symbol, symbol);} |
|
1131 |
void *constant_folding_c::visit( XORN_operator_c *symbol) { handle_xor (symbol, prev_il_instruction, il_operand); return handle_not(symbol, symbol);} |
|
1132 |
||
1133 |
void *constant_folding_c::visit( ADD_operator_c *symbol) {return handle_add (symbol, prev_il_instruction, il_operand);} |
|
1134 |
void *constant_folding_c::visit( SUB_operator_c *symbol) {return handle_sub (symbol, prev_il_instruction, il_operand);} |
|
1135 |
void *constant_folding_c::visit( MUL_operator_c *symbol) {return handle_mul (symbol, prev_il_instruction, il_operand);} |
|
1136 |
void *constant_folding_c::visit( DIV_operator_c *symbol) {return handle_div (symbol, prev_il_instruction, il_operand);} |
|
1137 |
void *constant_folding_c::visit( MOD_operator_c *symbol) {return handle_mod (symbol, prev_il_instruction, il_operand);} |
|
1138 |
||
1139 |
void *constant_folding_c::visit( GT_operator_c *symbol) { handle_cmp (symbol, prev_il_instruction, il_operand, > );} |
|
1140 |
void *constant_folding_c::visit( GE_operator_c *symbol) { handle_cmp (symbol, prev_il_instruction, il_operand, >=);} |
|
1141 |
void *constant_folding_c::visit( EQ_operator_c *symbol) { handle_cmp (symbol, prev_il_instruction, il_operand, ==);} |
|
1142 |
void *constant_folding_c::visit( LT_operator_c *symbol) { handle_cmp (symbol, prev_il_instruction, il_operand, < );} |
|
1143 |
void *constant_folding_c::visit( LE_operator_c *symbol) { handle_cmp (symbol, prev_il_instruction, il_operand, <=);} |
|
1144 |
void *constant_folding_c::visit( NE_operator_c *symbol) { handle_cmp (symbol, prev_il_instruction, il_operand, !=);} |
|
1145 |
||
1146 |
void *constant_folding_c::visit( CAL_operator_c *symbol) {return handle_move(symbol, prev_il_instruction);} |
|
1147 |
void *constant_folding_c::visit( RET_operator_c *symbol) {return handle_move(symbol, prev_il_instruction);} |
|
1148 |
void *constant_folding_c::visit( JMP_operator_c *symbol) {return handle_move(symbol, prev_il_instruction);} |
|
1149 |
void *constant_folding_c::visit( CALC_operator_c *symbol) {return handle_move(symbol, prev_il_instruction);} |
|
1150 |
void *constant_folding_c::visit(CALCN_operator_c *symbol) {return handle_move(symbol, prev_il_instruction);} |
|
1151 |
void *constant_folding_c::visit( RETC_operator_c *symbol) {return handle_move(symbol, prev_il_instruction);} |
|
1152 |
void *constant_folding_c::visit(RETCN_operator_c *symbol) {return handle_move(symbol, prev_il_instruction);} |
|
1153 |
void *constant_folding_c::visit( JMPC_operator_c *symbol) {return handle_move(symbol, prev_il_instruction);} |
|
1154 |
void *constant_folding_c::visit(JMPCN_operator_c *symbol) {return handle_move(symbol, prev_il_instruction);} |
|
1155 |
||
1156 |
||
567
e5deeb6d4d2f
create extract_real_value() in absyntax_utils. NOTE: overflows not yet handled!
Mario de Sousa <msousa@fe.up.pt>
parents:
566
diff
changeset
|
1157 |
|
e5deeb6d4d2f
create extract_real_value() in absyntax_utils. NOTE: overflows not yet handled!
Mario de Sousa <msousa@fe.up.pt>
parents:
566
diff
changeset
|
1158 |
|
564
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
1159 |
/***************************************/ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
1160 |
/* B.3 - Language ST (Structured Text) */ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
1161 |
/***************************************/ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
1162 |
/***********************/ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
1163 |
/* B 3.1 - Expressions */ |
dabffc3086dc
Start constant_folding class.
Manuele Conti <conti.ma@alice.it>
parents:
diff
changeset
|
1164 |
/***********************/ |
612 | 1165 |
void *constant_folding_c::visit( or_expression_c *symbol) {symbol->l_exp->accept(*this); symbol->r_exp->accept(*this); return handle_or (symbol, symbol->l_exp, symbol->r_exp);} |
1166 |
void *constant_folding_c::visit( xor_expression_c *symbol) {symbol->l_exp->accept(*this); symbol->r_exp->accept(*this); return handle_xor(symbol, symbol->l_exp, symbol->r_exp);} |
|
1167 |
void *constant_folding_c::visit( and_expression_c *symbol) {symbol->l_exp->accept(*this); symbol->r_exp->accept(*this); return handle_and(symbol, symbol->l_exp, symbol->r_exp);} |
|
1168 |
||
1169 |
void *constant_folding_c::visit( equ_expression_c *symbol) {symbol->l_exp->accept(*this); symbol->r_exp->accept(*this); handle_cmp (symbol, symbol->l_exp, symbol->r_exp, ==);} |
|
1170 |
void *constant_folding_c::visit(notequ_expression_c *symbol) {symbol->l_exp->accept(*this); symbol->r_exp->accept(*this); handle_cmp (symbol, symbol->l_exp, symbol->r_exp, !=);} |
|
1171 |
void *constant_folding_c::visit( lt_expression_c *symbol) {symbol->l_exp->accept(*this); symbol->r_exp->accept(*this); handle_cmp (symbol, symbol->l_exp, symbol->r_exp, < );} |
|
1172 |
void *constant_folding_c::visit( gt_expression_c *symbol) {symbol->l_exp->accept(*this); symbol->r_exp->accept(*this); handle_cmp (symbol, symbol->l_exp, symbol->r_exp, > );} |
|
1173 |
void *constant_folding_c::visit( le_expression_c *symbol) {symbol->l_exp->accept(*this); symbol->r_exp->accept(*this); handle_cmp (symbol, symbol->l_exp, symbol->r_exp, <=);} |
|
1174 |
void *constant_folding_c::visit( ge_expression_c *symbol) {symbol->l_exp->accept(*this); symbol->r_exp->accept(*this); handle_cmp (symbol, symbol->l_exp, symbol->r_exp, >=);} |
|
1175 |
||
1176 |
void *constant_folding_c::visit( add_expression_c *symbol) {symbol->l_exp->accept(*this); symbol->r_exp->accept(*this); return handle_add(symbol, symbol->l_exp, symbol->r_exp);} |
|
1177 |
void *constant_folding_c::visit( sub_expression_c *symbol) {symbol->l_exp->accept(*this); symbol->r_exp->accept(*this); return handle_sub(symbol, symbol->l_exp, symbol->r_exp);} |
|
1178 |
void *constant_folding_c::visit( mul_expression_c *symbol) {symbol->l_exp->accept(*this); symbol->r_exp->accept(*this); return handle_mul(symbol, symbol->l_exp, symbol->r_exp);} |
|
1179 |
void *constant_folding_c::visit( div_expression_c *symbol) {symbol->l_exp->accept(*this); symbol->r_exp->accept(*this); return handle_div(symbol, symbol->l_exp, symbol->r_exp);} |
|
1180 |
void *constant_folding_c::visit( mod_expression_c *symbol) {symbol->l_exp->accept(*this); symbol->r_exp->accept(*this); return handle_mod(symbol, symbol->l_exp, symbol->r_exp);} |
|
1181 |
void *constant_folding_c::visit( power_expression_c *symbol) {symbol->l_exp->accept(*this); symbol->r_exp->accept(*this); return handle_pow(symbol, symbol->l_exp, symbol->r_exp);} |
|
1182 |
||
1183 |
void *constant_folding_c::visit( neg_expression_c *symbol) {symbol-> exp->accept(*this); return handle_neg(symbol, symbol->exp);} |
|
1184 |
void *constant_folding_c::visit( not_expression_c *symbol) {symbol-> exp->accept(*this); return handle_not(symbol, symbol->exp);} |
|
1185 |
||
1186 |
/* TODO: handle function invocations... */ |
|
633
73b56dc69e61
Fix bug with task interval using fixed_point value for duration items
Laurent Bessard
parents:
621
diff
changeset
|
1187 |
// void *fill_candidate_datatypes_c::visit(function_invocation_c *symbol) {} |