34

/* Do constant folding...

    35

 *

    36

 * I.e., Determine the value of all expressions in which only constant values (i.e. literals) are used.

    37

 * The (constant) result of each operation is stored (annotated) in the respective operation symbol 

    38

 * (e.g.: add_expression_c) in the abstract syntax tree,

    41

 *       2 + 3         -> the constant value '5'    is stored in the add_expression_c symbol.

    42

 *       22.2 - 5.0    -> the constant value '17.2' is stored in the add_expression_c symbol.

    44

 *

    45

 *

    46

 * NOTE 1 that some operations and constants can have multiple data types. For example,

    47

 *        1 AND 0

    48

 *      may be either a BOOL, BYTE, WORD or LWORD.

    49

 *

    50

 *      The same happens with 

    51

 *        1 + 2

    52

 *      which may be signed (e.g. INT) or unsigned (UINT)

    53

 *

    54

 *      For the above reason, instead of storing a single constant value, we actually store 4:

    55

 *        - bool

    56

 *        - uint64

    57

 *        -  int64

    58

 *        - real64

    59

 *

    60

 *      Additionally, since the result of an operation may result in an overflow, we actually

    61

 *      store the result inside a struct (defined in absyntax.hh)

    62

 *

    63

 *             ** During stage 3 (semantic analysis/checking) we will be doing constant folding.

    64

 *              * That algorithm will anotate the abstract syntax tree with the result of operations

    65

 *              * on literals (i.e. 44 + 55 will store the result 99).

    66

 *              * Since the same source code (e.g. 1 + 0) may actually be a BOOL or an ANY_INT,

    67

 *              * or an ANY_BIT, we need to handle all possibilities, and determine the result of the

    68

 *              * operation assuming each type.

    69

 *              * For this reason, we have one entry for each possible type, with some expressions

    70

 *              * having more than one entry filled in!

    71

 *              **

    72

 *             typedef enum { cs_undefined,   // not defined --> const_value is not valid!

    73

 *                            cs_const_value, // const value is valid

    74

 *                            cs_overflow     // result produced overflow or underflow --> const_value is not valid!

    75

 *                          } const_status_t;

    76

 *    

    77

 *             typedef struct {

    78

 *                 const_status_t status;

    79

 *                 real64_t       value; 

    80

 *             } const_value_real64_t;

    81

 *             const_value_real64_t *const_value_real64; // when NULL --> UNDEFINED

    82

 *             

    83

 *             typedef struct {

    84

 *                 const_status_t status;

    85

 *                 int64_t        value; 

    86

 *             } const_value_int64_t;

    87

 *             const_value_int64_t *const_value_int64; // when NULL --> UNDEFINED

    88

 *             

    89

 *             typedef struct {

    90

 *                 const_status_t status;

    91

 *                 uint64_t       value; 

    92

 *             } const_value_uint64_t;

    93

 *             const_value_uint64_t *const_value_uint64; // when NULL --> UNDEFINED

    94

 *             

    95

 *             typedef struct {

    96

 *                 const_status_t status;

    97

 *                 bool           value; 

    98

 *             } const_value_bool_t;

    99

 *             const_value_bool_t *const_value_bool; // when NULL --> UNDEFINED

   100

 *

   101

 *

   102

 *

   103

 * NOTE 2 

   104

 *    This file does not print out any error messages!

   105

 *    We cannot really print out error messages when we find an overflow. Since each operation

   106

 *    (symbol in the absract syntax tree for that operation) will have up to 4 constant results,

   107

 *    it may happen that some of them overflow, while other do not.

   108

 *    We must wait for data type checking to determine the exact data type of each expression

   109

 *    before we can decide whether or not we should print out an overflow error message.

   110

 *

   111

 *    For this reason, this visitor merely annotates the abstract syntax tree, and leaves the

   112

 `    actuall printing of errors for the print_datatype_errors_c class!

   151

   152

   153

   154

   155

   156

   157

   158

   159

#define NEW_CVALUE(dtype, symbol) \

   160

 (symbol->const_value_##dtype) = new(symbol_c::const_value_##dtype##_t); \

   161

 if ((symbol->const_value_##dtype) == NULL) ERROR; \

   162

 (symbol->const_value_##dtype)->status = symbol_c::cs_undefined;

   163

   164

#define SET_CVALUE(dtype, symbol, new_value)  ((symbol)->const_value_##dtype->value) = new_value; ((symbol)->const_value_##dtype->status) = symbol_c::cs_const_value;  

   165

#define GET_CVALUE(dtype, symbol)             ((symbol)->const_value_##dtype->value) 

   166

#define SET_OVFLOW(dtype, symbol)             ((symbol)->const_value_##dtype->status) = symbol_c::cs_overflow

   167

    /* The following test is correct in the presence of a NULL pointer, as the logical evaluation will be suspended as soon as the first condition is false! */

   168

#define VALID_CVALUE(dtype, symbol)           ((NULL != (symbol)->const_value_##dtype) && (symbol_c::cs_const_value == (symbol)->const_value_##dtype->status))

   169

#define ISZERO_CVALUE(dtype, symbol)          ((VALID_CVALUE(dtype, symbol)) && (GET_CVALUE(dtype, symbol) == 0))

   170

#define DO_BIN_OPER(dtype, oper)\

   171

	if (VALID_CVALUE(dtype, symbol->r_exp) && VALID_CVALUE(dtype, symbol->l_exp)) {                                \

   172

		NEW_CVALUE(dtype, symbol);                                                                             \

   173

		SET_CVALUE(dtype, symbol, GET_CVALUE(dtype, symbol->l_exp) oper GET_CVALUE(dtype, symbol->r_exp));     \

   174

	}

   175

   190

                                                   " (i.e. constant folding) may themselves be erroneous, although are most probably correct.");

   210

	NEW_CVALUE(real64, symbol);

   211

	SET_CVALUE(real64, symbol, extract_real_value(symbol));

   217

	NEW_CVALUE( int64, symbol);

   218

	SET_CVALUE( int64, symbol, extract_integer_value(symbol));

   219

	NEW_CVALUE(uint64, symbol);

   220

	SET_CVALUE(uint64, symbol, extract_integer_value(symbol));

   227

	if (!VALID_CVALUE(real64, symbol->exp))

   228

		return NULL;

   229

	NEW_CVALUE(real64, symbol);

   230

	SET_CVALUE(real64, symbol, - GET_CVALUE( real64, symbol->exp));

   231

	return NULL;

   232

}

   233

   234

/* | '-' integer	{$$ = new neg_integer_c($2, locloc(@$));} */

   236

	symbol->exp->accept(*this);

   237

	if (VALID_CVALUE(int64, symbol->exp)) {

   238

		NEW_CVALUE( int64, symbol);

   239

		SET_CVALUE( int64, symbol, - GET_CVALUE( int64, symbol->exp));

   240

	}

   256

	NEW_CVALUE( int64, symbol);

   257

	SET_CVALUE( int64, symbol, extract_hex_value(symbol));

   258

	NEW_CVALUE(uint64, symbol);

   259

	SET_CVALUE(uint64, symbol, extract_hex_value(symbol));

   260

	return NULL;

   261

}

   262

   263

   264

/*

   265

integer_literal:

   266

  integer_type_name '#' signed_integer	{$$ = new integer_literal_c($1, $3, locloc(@$));}

   267

| integer_type_name '#' binary_integer	{$$ = new integer_literal_c($1, $3, locloc(@$));}

   268

| integer_type_name '#' octal_integer	{$$ = new integer_literal_c($1, $3, locloc(@$));}

   269

| integer_type_name '#' hex_integer	{$$ = new integer_literal_c($1, $3, locloc(@$));}

   270

*/

   271

// SYM_REF2(integer_literal_c, type, value)

   274

	if (VALID_CVALUE( int64, symbol->value)) {

   275

		NEW_CVALUE( int64, symbol);

   276

		SET_CVALUE( int64, symbol, GET_CVALUE( int64, symbol->value));

   277

	}

   278

	if (VALID_CVALUE(uint64, symbol->value)) {

   279

		NEW_CVALUE(uint64, symbol);

   280

		SET_CVALUE(uint64, symbol, GET_CVALUE(uint64, symbol->value));

   281

	}

   288

	if (VALID_CVALUE(real64, symbol->value)) {

   289

		NEW_CVALUE(real64, symbol);

   290

		SET_CVALUE(real64, symbol,  GET_CVALUE(real64, symbol->value));

   291

	}

   303

	if (VALID_CVALUE(bool, symbol->value)) {

   304

		NEW_CVALUE(bool, symbol);

   305

		SET_CVALUE(bool, symbol,  GET_CVALUE(  bool, symbol->value));

   306

	}

   312

	NEW_CVALUE(bool, symbol);

   313

	SET_CVALUE(bool, symbol, true);

   319

	NEW_CVALUE(bool, symbol);

   320

	SET_CVALUE(bool, symbol, false);

   321

	return NULL;

   322

}

   334

	DO_BIN_OPER(bool,   ||);

   335

	DO_BIN_OPER(uint64, | );

   343

	DO_BIN_OPER(bool,   ^);

   344

	DO_BIN_OPER(uint64, ^);

   352

	DO_BIN_OPER(bool,   &&);

   353

	DO_BIN_OPER(uint64, & );

   361

	DO_BIN_OPER(bool,   ==);

   362

	DO_BIN_OPER(uint64, ==);

   363

	DO_BIN_OPER( int64, ==);

   364

	DO_BIN_OPER(real64, ==);

   372

	DO_BIN_OPER(bool,   !=);

   373

	DO_BIN_OPER(uint64, !=);

   374

	DO_BIN_OPER( int64, !=);

   375

	DO_BIN_OPER(real64, !=);

   383

	DO_BIN_OPER(bool,   <);

   384

	DO_BIN_OPER(uint64, <);

   385

	DO_BIN_OPER( int64, <);

   386

	DO_BIN_OPER(real64, <);

   394

	DO_BIN_OPER(bool,   >);

   395

	DO_BIN_OPER(uint64, >);

   396

	DO_BIN_OPER( int64, >);

   397

	DO_BIN_OPER(real64, >);

   405

	DO_BIN_OPER(bool,   <=);

   406

	DO_BIN_OPER(uint64, <=);

   407

	DO_BIN_OPER( int64, <=);

   408

	DO_BIN_OPER(real64, <=);

   416

	DO_BIN_OPER(bool,   >=);

   417

	DO_BIN_OPER(uint64, >=);

   418

	DO_BIN_OPER( int64, >=);

   419

	DO_BIN_OPER(real64, >=);

   420

	return NULL;

   421

}

   422

   423

   424

#define CHECK_OVERFLOW_SUM(dtype)\

   425

	if (VALID_CVALUE(dtype, symbol))                                                                                                             \

   426

		if ((((std::numeric_limits< dtype##_t >::max() - GET_CVALUE(dtype, symbol->l_exp)) < (GET_CVALUE(dtype, symbol->r_exp))) ? 1 : 0) || \

   427

		    (((std::numeric_limits< dtype##_t >::min() + GET_CVALUE(dtype, symbol->l_exp)) > (GET_CVALUE(dtype, symbol->r_exp))) ? 1 : 0))   \

   428

			SET_OVFLOW(dtype, symbol);

   429

#define CHECK_OVERFLOW_real64  \

   430

	if (VALID_CVALUE(real64, symbol))                                                                                                            \

   431

        	/* NaN => underflow, overflow, number is a higher precision format, is a complex number (IEEE standard) */                           \

   432

		 if (isnan(GET_CVALUE(real64, symbol)))                                                                                              \

   433

			SET_OVFLOW(real64, symbol);

   437

	DO_BIN_OPER(uint64, +);

   438

	DO_BIN_OPER( int64, +);

   439

	DO_BIN_OPER(real64, +);

   440

	CHECK_OVERFLOW_SUM(uint64);

   441

	CHECK_OVERFLOW_SUM( int64);

   442

	CHECK_OVERFLOW_real64;

   443

	return NULL;

   444

}

   445

   446

   447

#define CHECK_OVERFLOW_SUB(dtype)\

   448

	if (VALID_CVALUE(dtype, symbol))                                                                                                             \

   449

		if ((((std::numeric_limits< dtype##_t >::max() - GET_CVALUE(dtype, symbol->l_exp)) < (-GET_CVALUE(dtype, symbol->r_exp))) ? 1 : 0) || \

   450

		    (((std::numeric_limits< dtype##_t >::min() + GET_CVALUE(dtype, symbol->l_exp)) > (-GET_CVALUE(dtype, symbol->r_exp))) ? 1 : 0))   \

   451

			SET_OVFLOW(dtype, symbol);

   455

	DO_BIN_OPER(uint64, -);

   456

	DO_BIN_OPER( int64, -);

   457

	DO_BIN_OPER(real64, -);

   458

	CHECK_OVERFLOW_SUB(uint64);

   459

	CHECK_OVERFLOW_SUB( int64);

   460

	CHECK_OVERFLOW_real64;

   461

	return NULL;

   462

}

   463

   464

   465

/* TODO!!! */

   466

#define CHECK_OVERFLOW_MUL(dtype)\

   467

	if (VALID_CVALUE(dtype, symbol))                                                                                                             \

   468

		if (false)                                                                                                                                   \

   469

			SET_OVFLOW(dtype, symbol);

   473

	DO_BIN_OPER(uint64, *);

   474

	DO_BIN_OPER( int64, *);

   475

	DO_BIN_OPER(real64, *);

   476

	CHECK_OVERFLOW_MUL(uint64);

   477

	CHECK_OVERFLOW_MUL( int64);

   478

	CHECK_OVERFLOW_real64;

   479

	return NULL;

   480

}

   481

   482

   483

   484

/* TODO!!! */

   485

#define CHECK_OVERFLOW_DIV(dtype)\

   486

	if (VALID_CVALUE(dtype, symbol))                                                                                                             \

   487

		if (false)                                                                                                                                   \

   488

			SET_OVFLOW(dtype, symbol);

   492

	if (ISZERO_CVALUE(uint64, symbol->r_exp))  {NEW_CVALUE(uint64, symbol); SET_OVFLOW(uint64, symbol);} else {DO_BIN_OPER(uint64, /); CHECK_OVERFLOW_DIV(uint64)};

   493

	if (ISZERO_CVALUE( int64, symbol->r_exp))  {NEW_CVALUE( int64, symbol); SET_OVFLOW( int64, symbol);} else {DO_BIN_OPER( int64, /); CHECK_OVERFLOW_DIV( int64)};

   494

	if (ISZERO_CVALUE(real64, symbol->r_exp))  {NEW_CVALUE(real64, symbol); SET_OVFLOW(real64, symbol);} else {DO_BIN_OPER(real64, /); CHECK_OVERFLOW_real64;};

   495

	return NULL;

   496

}

   497

   498

   499

/* TODO!!! */

   500

#define CHECK_OVERFLOW_MOD(dtype)\

   501

	if (VALID_CVALUE(dtype, symbol))                                                                                                             \

   502

		if (false)                                                                                                                                   \

   503

			SET_OVFLOW(dtype, symbol);