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

    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,

    39

 *

    40

 * For example:

    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.

    43

 *       etc...

    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!

   113

 */

   114

   115

#include "constant_folding.hh"

   116

#include <typeinfo>

   117

#include <limits>

   118

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

   119

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

   120

   121

   122

   123

   124

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

   125

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

   126

   127

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

   128

  if (current_display_error_level >= error_level) {                                                                         \

   129

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

   130

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

   131

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

   132

    fprintf(stderr, __VA_ARGS__);                                                                                           \

   133

    fprintf(stderr, "\n");                                                                                                  \

   134

    error_count++;                                                                                                     \

   135

  }                                                                                                                         \

   136

}

   137

   138

   139

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

   140

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

   141

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

   142

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

   143

    fprintf(stderr, __VA_ARGS__);                                                                                           \

   144

    fprintf(stderr, "\n");                                                                                                  \

   145

    warning_found = true;                                                                                                   \

   146

}

   147

   148

   149

   150

   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

   176

   177

   178

   179

   180

constant_folding_c::constant_folding_c(symbol_c *symbol) {

   181

    error_count = 0;

   182

    warning_found = false;

   183

    current_display_error_level = 0;

   184

   185

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

   186

    symbol_c null_symbol;

   187

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

   188

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

   189

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

   190

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

   191

}

   192

   193

   194

constant_folding_c::~constant_folding_c(void) {

   195

}

   196

   197

   198

int constant_folding_c::get_error_count() {

   199

	return error_count;

   200

}

   201

   202

   203

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

   204

/* B 1.2 - Constants */

   205

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

   206

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

   207

/* B 1.2.1 - Numeric Literals */

   208

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

   209

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

   210

	NEW_CVALUE(real64, symbol);

   211

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

   212

	return NULL;

   213

}

   214

   215

   216

void *constant_folding_c::visit(integer_c *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));

   221

	return NULL;

   222

}

   223

   224

   225

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

   226

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

   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(@$));} */

   235

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

   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

	}

   242

	return NULL;

   243

}

   244

   245

   246

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

   247

	return NULL;

   248

}

   249

   250

   251

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

   252

	return NULL;

   253

}

   254

   255

   256

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

   257

	NEW_CVALUE( int64, symbol);

   258

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

   259

	NEW_CVALUE(uint64, symbol);

   260

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

   261

	return NULL;

   262

}

   263

   264

   265

/*

   266

integer_literal:

   267

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

   268

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

   269

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

   270

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

   271

*/

   272

// SYM_REF2(integer_literal_c, type, value)

   273

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

   274

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

   275

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

   276

		NEW_CVALUE( int64, symbol);

   277

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

   278

	}

   279

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

   280

		NEW_CVALUE(uint64, symbol);

   281

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

   282

	}

   283

	return NULL;

   284

}

   285

   286

   287

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

   288

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

   289

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

   290

		NEW_CVALUE(real64, symbol);

   291

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

   292

	}

   293

	return NULL;

   294

}

   295

   296

   297

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

   298

	return NULL;

   299

}

   300

   301

   302

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

   303

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

   304

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

   305

		NEW_CVALUE(bool, symbol);

   306

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

   307

	}

   308

	return NULL;

   309

}

   310

   311

   312

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

   313

	NEW_CVALUE(bool, symbol);

   314

	SET_CVALUE(bool, symbol, true);

   315

	return NULL;

   316

}

   317

   318

   319

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

   320

	NEW_CVALUE(bool, symbol);

   321

	SET_CVALUE(bool, symbol, false);

   322

	return NULL;

   323

}

   324

   325

   326

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

   327

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

   328

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

   329

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

   330

/* B 3.1 - Expressions */

   331

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

   332

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

   333

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

   334

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

   335

	DO_BIN_OPER(bool,   ||);

   336

	DO_BIN_OPER(uint64, | );

   337

	return NULL;

   338

}

   339

   340

   341

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

   342

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

   343

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

   344

	DO_BIN_OPER(bool,   ^);

   345

	DO_BIN_OPER(uint64, ^);

   346

	return NULL;

   347

}

   348

   349

   350

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

   351

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

   352

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

   353

	DO_BIN_OPER(bool,   &&);

   354

	DO_BIN_OPER(uint64, & );

   355

	return NULL;

   356

}

   357

   358

   359

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

   360

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

   361

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

   362

	DO_BIN_OPER(bool,   ==);

   363

	DO_BIN_OPER(uint64, ==);

   364

	DO_BIN_OPER( int64, ==);

   365

	DO_BIN_OPER(real64, ==);

   366

	return NULL;

   367

}

   368

   369

   370

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

   371

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

   372

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

   373

	DO_BIN_OPER(bool,   !=);

   374

	DO_BIN_OPER(uint64, !=);

   375

	DO_BIN_OPER( int64, !=);

   376

	DO_BIN_OPER(real64, !=);

   377

	return NULL;

   378

}

   379

   380

   381

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

   382

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

   383

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

   384

	DO_BIN_OPER(bool,   <);

   385

	DO_BIN_OPER(uint64, <);

   386

	DO_BIN_OPER( int64, <);

   387

	DO_BIN_OPER(real64, <);

   388

	return NULL;

   389

}

   390

   391

   392

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

   393

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

   394

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

   395

	DO_BIN_OPER(bool,   >);

   396

	DO_BIN_OPER(uint64, >);

   397

	DO_BIN_OPER( int64, >);

   398

	DO_BIN_OPER(real64, >);

   399

	return NULL;

   400

}

   401

   402

   403

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

   404

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

   405

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

   406

	DO_BIN_OPER(bool,   <=);

   407

	DO_BIN_OPER(uint64, <=);

   408

	DO_BIN_OPER( int64, <=);

   409

	DO_BIN_OPER(real64, <=);

   410

	return NULL;

   411

}

   412

   413

   414

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

   415

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

   416

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

   417

	DO_BIN_OPER(bool,   >=);

   418

	DO_BIN_OPER(uint64, >=);

   419

	DO_BIN_OPER( int64, >=);

   420

	DO_BIN_OPER(real64, >=);

   421

	return NULL;

   422

}

   423

   424

   425

#define CHECK_OVERFLOW_SUM(dtype)\

   426

	if (VALID_CVALUE(dtype, symbol))                                                                                                             \

   427

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

   428

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

   429

			SET_OVFLOW(dtype, symbol);

   430

#define CHECK_OVERFLOW_real64  \

   431

	if (VALID_CVALUE(real64, symbol))                                                                                                            \

   432

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

   433

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

   434

			SET_OVFLOW(real64, symbol);

   435

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

   436

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

   437

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

   441

	return NULL;

   442

}

   443

   444

   445

#define CHECK_OVERFLOW_SUB(dtype)\

   446

	if (VALID_CVALUE(dtype, symbol))                                                                                                             \

   447

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

   448

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

   449

			SET_OVFLOW(dtype, symbol);

   450

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

   451

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

   452

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

   456

	return NULL;

   457

}

   458

   459

   460

/* TODO!!! */

   461

#define CHECK_OVERFLOW_MUL(dtype)\

   462

	if (VALID_CVALUE(dtype, symbol))                                                                                                             \

   463

		if (false)                                                                                                                                   \

   464

			SET_OVFLOW(dtype, symbol);

   465

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

   466

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

   467

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

   471

	return NULL;

   472

}

   473

   474

   475

   476

/* TODO!!! */

   477

#define CHECK_OVERFLOW_DIV(dtype)\

   478

	if (VALID_CVALUE(dtype, symbol))                                                                                                             \

   479

		if (false)                                                                                                                                   \

   480

			SET_OVFLOW(dtype, symbol);

   481

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

   482

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

   483

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

   484

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

   485

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

   486

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

   487

	return NULL;

   488

}

   489

   490

   491

/* TODO!!! */

   492

#define CHECK_OVERFLOW_MOD(dtype)\

   493

	if (VALID_CVALUE(dtype, symbol))                                                                                                             \

   494

		if (false)                                                                                                                                   \

   495

			SET_OVFLOW(dtype, symbol);

   496

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

   497

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

   498

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

   499

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

   500

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

   501

	return NULL;

   502

}

   503