1

/*

     2

 *  matiec - a compiler for the programming languages defined in IEC 61131-3

     3

 *

     4

 *  Copyright (C) 2003-2011  Mario de Sousa (msousa@fe.up.pt)

     5

 *  Copyright (C) 2012       Manuele Conti (conti.ma@alice.it)

     6

 *

     7

 *  This program is free software: you can redistribute it and/or modify

     8

 *  it under the terms of the GNU General Public License as published by

     9

 *  the Free Software Foundation, either version 3 of the License, or

    10

 *  (at your option) any later version.

    11

 *

    12

 *  This program is distributed in the hope that it will be useful,

    13

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    14

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    15

 *  GNU General Public License for more details.

    16

 *

    17

 *  You should have received a copy of the GNU General Public License

    18

 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.

    19

 *

    20

 *

    21

 * This code is made available on the understanding that it will not be

    22

 * used in safety-critical situations without a full and competent review.

    23

 */

    24

    25

/*

    26

 * An IEC 61131-3 compiler.

    27

 *

    28

 * Based on the

    29

 * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)

    30

 *

    31

 */

    32

    33

    41

/* Do constant folding...

    42

 *

    43

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

    44

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

    45

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

    46

 *

    47

 * For example:

    48

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

    49

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

    50

 *       etc...

    51

 *

    52

 *

    55

 *        1 AND 0

    56

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

    57

 *

    58

 *      The same happens with 

    59

 *        1 + 2

    60

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

    61

 *

    62

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

    63

 *        - bool

    64

 *        - uint64

    65

 *        -  int64

    66

 *        - real64

    67

 *

    68

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

    69

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

    70

 *

    71

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

    72

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

    73

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

    74

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

    75

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

    76

 *              * operation assuming each type.

    77

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

    78

 *              * having more than one entry filled in!

    79

 *              **

    80

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

    81

 *                            cs_const_value, // const value is valid

    82

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

    83

 *                          } const_status_t;

    84

 *    

    85

 *             typedef struct {

    86

 *                 const_status_t status;

    87

 *                 real64_t       value; 

    88

 *             } const_value_real64_t;

    89

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

    90

 *             

    91

 *             typedef struct {

    92

 *                 const_status_t status;

    93

 *                 int64_t        value; 

    94

 *             } const_value_int64_t;

    95

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

    96

 *             

    97

 *             typedef struct {

    98

 *                 const_status_t status;

    99

 *                 uint64_t       value; 

   100

 *             } const_value_uint64_t;

   101

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

   102

 *             

   103

 *             typedef struct {

   104

 *                 const_status_t status;

   105

 *                 bool           value; 

   106

 *             } const_value_bool_t;

   107

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

   108

 *

   109

 *

   110

 *

   111

 * NOTE 2 

   112

 *    This file does not print out any error messages!

   113

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

   114

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

   115

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

   116

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

   117

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

   118

 *

   119

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

   121

 */

   122

   123

#include "constant_folding.hh"

   124

#include <limits>

   126

#include <math.h> /* required for pow function */

   127

#include <stdlib.h> /* required for malloc() */

   128

   137

   138

   139

#define FIRST_(symbol1, symbol2) (((symbol1)->first_order < (symbol2)->first_order)   ? (symbol1) : (symbol2))

   140

#define  LAST_(symbol1, symbol2) (((symbol1)->last_order  > (symbol2)->last_order)    ? (symbol1) : (symbol2))

   141

   142

#define STAGE3_ERROR(error_level, symbol1, symbol2, ...) {                                                                  \

   143

  if (current_display_error_level >= error_level) {                                                                         \

   144

    fprintf(stderr, "%s:%d-%d..%d-%d: error: ",                                                                             \

   145

            FIRST_(symbol1,symbol2)->first_file, FIRST_(symbol1,symbol2)->first_line, FIRST_(symbol1,symbol2)->first_column,\

   146

                                                 LAST_(symbol1,symbol2) ->last_line,  LAST_(symbol1,symbol2) ->last_column);\

   147

    fprintf(stderr, __VA_ARGS__);                                                                                           \

   148

    fprintf(stderr, "\n");                                                                                                  \

   149

    error_count++;                                                                                                     \

   150

  }                                                                                                                         \

   151

}

   152

   153

   154

#define STAGE3_WARNING(symbol1, symbol2, ...) {                                                                             \

   155

    fprintf(stderr, "%s:%d-%d..%d-%d: warning: ",                                                                           \

   156

            FIRST_(symbol1,symbol2)->first_file, FIRST_(symbol1,symbol2)->first_line, FIRST_(symbol1,symbol2)->first_column,\

   157

                                                 LAST_(symbol1,symbol2) ->last_line,  LAST_(symbol1,symbol2) ->last_column);\

   158

    fprintf(stderr, __VA_ARGS__);                                                                                           \

   159

    fprintf(stderr, "\n");                                                                                                  \

   160

    warning_found = true;                                                                                                   \

   161

}

   162

   163

   164

   165

   166

   167

   168

   169

   170

   171

   172

   173

   174

#define NEW_CVALUE(dtype, symbol) \

   175

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

   176

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

   177

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

   178

   179

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

   180

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

   181

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

   182

    /* 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! */

   183

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

   184

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

   185

#define DO_BIN_OPER(dtype, oper)\

   186

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

   187

		NEW_CVALUE(dtype, symbol);                                                                             \

   188

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

   189

	}

   190

   191

   192

   193

   194

   332

constant_folding_c::constant_folding_c(symbol_c *symbol) {

   333

    error_count = 0;

   334

    warning_found = false;

   335

    current_display_error_level = 0;

   336

   337

    /* check whether the platform on which the compiler is being run implements IEC 559 floating point data types. */

   338

    symbol_c null_symbol;

   339

    if (! (std::numeric_limits<real64_t>::is_iec559) )

   340

        STAGE3_WARNING(&null_symbol, &null_symbol, "The platform running the compiler does not implement IEC 559 floating point numbers. "

   341

                                                   "Any error and/or warning messages related to overflow/underflow of the result of operations on REAL/LREAL literals "

   342

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

   343

}

   344

   345

   346

constant_folding_c::~constant_folding_c(void) {

   347

}

   348

   349

   350

int constant_folding_c::get_error_count() {

   351

	return error_count;

   352

}

   353

   354

   355

/*********************/

   356

/* B 1.2 - Constants */

   357

/*********************/

   358

/******************************/

   359

/* B 1.2.1 - Numeric Literals */

   360

/******************************/

   361

void *constant_folding_c::visit(real_c *symbol) {

   362

	NEW_CVALUE(real64, symbol);

   363

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

   364

	return NULL;

   365

}

   366

   367

   368

void *constant_folding_c::visit(integer_c *symbol) {

   369

	NEW_CVALUE( int64, symbol);

   370

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

   371

	NEW_CVALUE(uint64, symbol);

   372

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

   373

	return NULL;

   374

}

   375

   376

   377

void *constant_folding_c::visit(neg_real_c *symbol) {

   378

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

   379

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

   380

		return NULL;

   381

	NEW_CVALUE(real64, symbol);

   382

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

   384

	return NULL;

   385

}

   386

   387

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

   388

void *constant_folding_c::visit(neg_integer_c *symbol) {

   389

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

   390

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

   391

		NEW_CVALUE( int64, symbol);

   392

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

   393

	}

   395

	return NULL;

   396

}

   397

   398

   399

void *constant_folding_c::visit(binary_integer_c *symbol) {

   400

	return NULL;

   401

}

   402

   403

   404

void *constant_folding_c::visit(octal_integer_c *symbol) {

   405

	return NULL;

   406

}

   407

   408

   409

void *constant_folding_c::visit(hex_integer_c *symbol) {

   410

	NEW_CVALUE( int64, symbol);

   411

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

   412

	NEW_CVALUE(uint64, symbol);

   413

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

   414

	return NULL;

   415

}

   416

   417

   418

/*

   419

integer_literal:

   420

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

   421

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

   422

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

   423

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

   424

*/

   425

// SYM_REF2(integer_literal_c, type, value)

   426

void *constant_folding_c::visit(integer_literal_c *symbol) {

   427

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

   428

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

   429

		NEW_CVALUE( int64, symbol);

   430

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

   431

	}

   432

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

   433

		NEW_CVALUE(uint64, symbol);

   434

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

   435

	}

   436

	return NULL;

   437

}

   438

   439

   440

void *constant_folding_c::visit(real_literal_c *symbol) {

   441

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

   442

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

   443

		NEW_CVALUE(real64, symbol);

   444

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

   445

	}

   446

	return NULL;

   447

}

   448

   449

   450

void *constant_folding_c::visit(bit_string_literal_c *symbol) {

   451

	return NULL;

   452

}

   453

   454

   455

void *constant_folding_c::visit(boolean_literal_c *symbol) {

   456

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

   457

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

   458

		NEW_CVALUE(bool, symbol);

   459

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

   460

	}

   461

	return NULL;

   462

}

   463

   464

   465

void *constant_folding_c::visit(boolean_true_c *symbol) {

   466

	NEW_CVALUE(bool, symbol);

   467

	SET_CVALUE(bool, symbol, true);

   468

	return NULL;

   469

}

   470

   471

   472

void *constant_folding_c::visit(boolean_false_c *symbol) {

   473

	NEW_CVALUE(bool, symbol);

   474

	SET_CVALUE(bool, symbol, false);

   475

	return NULL;

   476

}

   477

   478

   479

/***************************************/

   480

/* B.3 - Language ST (Structured Text) */

   481

/***************************************/

   482

/***********************/

   483

/* B 3.1 - Expressions */

   484

/***********************/

   485

void *constant_folding_c::visit(or_expression_c *symbol) {

   486

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

   487

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

   488

	DO_BIN_OPER(bool,   ||);

   489

	DO_BIN_OPER(uint64, | );

   490

	return NULL;

   491

}

   492

   493

   494

void *constant_folding_c::visit(xor_expression_c *symbol) {

   495

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

   496

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

   497

	DO_BIN_OPER(bool,   ^);

   498

	DO_BIN_OPER(uint64, ^);

   499

	return NULL;

   500

}

   501