Context Navigation

source: src/Common/Eval.cc @ 1988572

ADTast-experimentalpthread-emulationqualifiedEnum

Last change on this file since 1988572 was 120867e, checked in by Peter A. Buhr <pabuhr@…>, 2 years ago
update EvalNew? to handle more compile-time constant-expression evaluation
Property mode set to `100644`
File size: 8.5 KB

Rev	Line
[5cbacf1]	1	//
	2	// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
	3	//
	4	// The contents of this file are covered under the licence agreement in the
	5	// file "LICENCE" distributed with Cforall.
	6	//
	7	// utility.h --
	8	//
	9	// Author : Richard C. Bilson
	10	// Created On : Mon May 18 07:44:20 2015
	11	// Last Modified By : Peter A. Buhr
[120867e]	12	// Last Modified On : Fri Jul 1 08:41:03 2022
	13	// Update Count : 117
[5cbacf1]	14	//
	15
	16	#include <utility> // for pair
	17
	18	#include "Common/PassVisitor.h"
[120867e]	19	#include "CodeGen/OperatorTable.h" // access: OperatorInfo
[d7aa12c]	20	#include "AST/Pass.hpp"
[5cbacf1]	21	#include "InitTweak/InitTweak.h"
	22	#include "SynTree/Expression.h"
	23
[d7aa12c]	24	//-------------------------------------------------------------
	25	// Old AST
	26	struct EvalOld : public WithShortCircuiting {
[120867e]	27	long long int value = 0; // compose the result of the constant expression
	28	bool valid = true; // true => constant expression and value is the result
	29	// false => not constant expression, e.g., ++i
	30	bool cfavalid = true; // true => constant expression and value computable
	31	// false => constant expression but value not computable, e.g., sizeof(int)
[5cbacf1]	32
[77d2432]	33	void previsit( const BaseSyntaxNode * ) { visit_children = false; }
	34	void postvisit( const BaseSyntaxNode * ) { valid = false; }
[5cbacf1]	35
[77d2432]	36	void postvisit( const SizeofExpr * ) {
	37	}
	38
	39	void postvisit( const ConstantExpr * expr ) {
[5cbacf1]	40	value = expr->intValue();
	41	}
	42
[77d2432]	43	void postvisit( const CastExpr * expr ) {
[5cbacf1]	44	auto arg = eval(expr->arg);
	45	valid = arg.second;
	46	value = arg.first;
	47	// TODO: perform type conversion on value if valid
	48	}
	49
[77d2432]	50	void postvisit( const VariableExpr * const expr ) {
[5cbacf1]	51	if ( EnumInstType * inst = dynamic_cast<EnumInstType *>(expr->result) ) {
	52	if ( EnumDecl * decl = inst->baseEnum ) {
	53	if ( decl->valueOf( expr->var, value ) ) { // value filled by valueOf
	54	return;
	55	}
	56	}
	57	}
	58	valid = false;
	59	}
	60
[77d2432]	61	void postvisit( const ApplicationExpr * expr ) {
	62	DeclarationWithType * function = InitTweak::getFunction(const_cast<ApplicationExpr *>(expr));
[5cbacf1]	63	if ( ! function \|\| function->linkage != LinkageSpec::Intrinsic ) { valid = false; return; }
	64	const std::string & fname = function->name;
	65	assertf( expr->args.size() == 1 \|\| expr->args.size() == 2, "Intrinsic function with %zd arguments: %s", expr->args.size(), fname.c_str() );
	66	std::pair<long long int, bool> arg1, arg2;
	67	arg1 = eval(expr->args.front());
	68	valid = valid && arg1.second;
	69	if ( ! valid ) return;
	70	if ( expr->args.size() == 2 ) {
	71	arg2 = eval(expr->args.back());
	72	valid = valid && arg2.second;
	73	if ( ! valid ) return;
	74	}
	75	if (fname == "?+?") {
	76	value = arg1.first + arg2.first;
	77	} else if (fname == "?-?") {
	78	value = arg1.first - arg2.first;
	79	} else if (fname == "?*?") {
	80	value = arg1.first * arg2.first;
	81	} else if (fname == "?/?") {
	82	value = arg1.first / arg2.first;
	83	} else if (fname == "?%?") {
	84	value = arg1.first % arg2.first;
	85	} else {
	86	valid = false;
	87	}
	88	// TODO: implement other intrinsic functions
	89	}
	90	};
	91
[d7aa12c]	92	//-------------------------------------------------------------
	93	// New AST
	94	struct EvalNew : public ast::WithShortCircuiting {
[120867e]	95	long long int value = 0; // compose the result of the constant expression
	96	bool valid = true; // true => constant expression and value is the result
	97	// false => not constant expression, e.g., ++i
	98	bool cfavalid = true; // true => constant expression and value computable
	99	// false => constant expression but value not computable, e.g., sizeof(int)
[d7aa12c]	100
	101	void previsit( const ast::Node * ) { visit_children = false; }
[120867e]	102	void postvisit( const ast::Node * ) { cfavalid = valid = false; }
[d7aa12c]	103
[120867e]	104	void postvisit( const ast::UntypedExpr * ) {
	105	assertf( false, "UntypedExpr in constant expression evaluation" ); // FIX ME, resolve variable
	106	}
	107
	108	void postvisit( const ast::ConstantExpr * expr ) { // only handle int constants
[d7aa12c]	109	value = expr->intValue();
	110	}
	111
[120867e]	112	void postvisit( const ast::SizeofExpr * ) {
	113	// do not change valid or value => let C figure it out
	114	cfavalid = false;
	115	}
	116
	117	void postvisit( const ast::AlignofExpr * ) {
	118	// do not change valid or value => let C figure it out
	119	cfavalid = false;
	120	}
	121
	122	void postvisit( const ast::OffsetofExpr * ) {
	123	// do not change valid or value => let C figure it out
	124	cfavalid = false;
[77d2432]	125	}
	126
[120867e]	127	void postvisit( const ast::LogicalExpr * expr ) {
	128	std::pair<long long int, bool> arg1, arg2;
	129	arg1 = eval( expr->arg1 );
	130	valid &= arg1.second;
	131	if ( ! valid ) return;
	132	arg2 = eval( expr->arg2 );
	133	valid &= arg2.second;
	134	if ( ! valid ) return;
	135
	136	if ( expr->isAnd ) {
	137	value = arg1.first && arg2.first;
	138	} else {
	139	value = arg1.first \|\| arg2.first;
	140	} // if
	141	}
	142
	143	void postvisit( const ast::ConditionalExpr * expr ) {
	144	std::pair<long long int, bool> arg1, arg2, arg3;
	145	arg1 = eval( expr->arg1 );
	146	valid &= arg1.second;
	147	if ( ! valid ) return;
	148	arg2 = eval( expr->arg2 );
	149	valid &= arg2.second;
	150	if ( ! valid ) return;
	151	arg3 = eval( expr->arg3 );
	152	valid &= arg3.second;
	153	if ( ! valid ) return;
	154
	155	value = arg1.first ? arg2.first : arg3.first;
	156	}
	157
	158	void postvisit( const ast::CastExpr * expr ) {
	159	// cfa-cc generates a cast before every constant and many other places, e.g., (int)3, so the cast argument must
	160	// be evaluated to get the constant value.
[d7aa12c]	161	auto arg = eval(expr->arg);
	162	valid = arg.second;
	163	value = arg.first;
[120867e]	164	cfavalid = false;
[d7aa12c]	165	}
	166
[120867e]	167	void postvisit( const ast::VariableExpr * expr ) {
[d7aa12c]	168	if ( const ast::EnumInstType * inst = dynamic_cast<const ast::EnumInstType *>(expr->result.get()) ) {
	169	if ( const ast::EnumDecl * decl = inst->base ) {
	170	if ( decl->valueOf( expr->var, value ) ) { // value filled by valueOf
	171	return;
	172	}
	173	}
	174	}
	175	valid = false;
	176	}
	177
	178	void postvisit( const ast::ApplicationExpr * expr ) {
	179	const ast::DeclWithType * function = InitTweak::getFunction(expr);
	180	if ( ! function \|\| function->linkage != ast::Linkage::Intrinsic ) { valid = false; return; }
	181	const std::string & fname = function->name;
	182	assertf( expr->args.size() == 1 \|\| expr->args.size() == 2, "Intrinsic function with %zd arguments: %s", expr->args.size(), fname.c_str() );
[120867e]	183
	184	if ( expr->args.size() == 1 ) {
	185	// pre/postfix operators ++ and -- => assignment, which is not constant
	186	std::pair<long long int, bool> arg1;
	187	arg1 = eval(expr->args.front());
	188	valid &= arg1.second;
	189	if ( ! valid ) return;
	190
	191	if (fname == "+?") {
	192	value = arg1.first;
	193	} else if (fname == "-?") {
	194	value = -arg1.first;
	195	} else if (fname == "~?") {
	196	value = ~arg1.first;
	197	} else if (fname == "!?") {
	198	value = ! arg1.first;
	199	} else {
	200	valid = false;
	201	} // if
	202	} else { // => expr->args.size() == 2
	203	// infix assignment operators => assignment, which is not constant
	204	std::pair<long long int, bool> arg1, arg2;
	205	arg1 = eval(expr->args.front());
	206	valid &= arg1.second;
	207	if ( ! valid ) return;
[d7aa12c]	208	arg2 = eval(expr->args.back());
[120867e]	209	valid &= arg2.second;
[d7aa12c]	210	if ( ! valid ) return;
[120867e]	211
	212	if (fname == "?+?") {
	213	value = arg1.first + arg2.first;
	214	} else if (fname == "?-?") {
	215	value = arg1.first - arg2.first;
	216	} else if (fname == "?*?") {
	217	value = arg1.first * arg2.first;
	218	} else if (fname == "?/?") {
	219	value = arg1.first / arg2.first;
	220	} else if (fname == "?%?") {
	221	value = arg1.first % arg2.first;
	222	} else if (fname == "?<<?") {
	223	value = arg1.first << arg2.first;
	224	} else if (fname == "?>>?") {
	225	value = arg1.first >> arg2.first;
	226	} else if (fname == "?<?") {
	227	value = arg1.first < arg2.first;
	228	} else if (fname == "?>?") {
	229	value = arg1.first > arg2.first;
	230	} else if (fname == "?<=?") {
	231	value = arg1.first <= arg2.first;
	232	} else if (fname == "?>=?") {
	233	value = arg1.first >= arg2.first;
	234	} else if (fname == "?==?") {
	235	value = arg1.first == arg2.first;
	236	} else if (fname == "?!=?") {
	237	value = arg1.first != arg2.first;
	238	} else if (fname == "?&?") {
	239	value = arg1.first & arg2.first;
	240	} else if (fname == "?^?") {
	241	value = arg1.first ^ arg2.first;
	242	} else if (fname == "?\|?") {
	243	value = arg1.first \| arg2.first;
	244	} else {
	245	valid = false;
	246	}
	247	} // if
[d7aa12c]	248	// TODO: implement other intrinsic functions
	249	}
	250	};
	251
[120867e]	252	std::pair<long long int, bool> eval( const Expression * expr ) {
[d7aa12c]	253	PassVisitor<EvalOld> ev;
[120867e]	254	if ( expr ) {
	255	expr->accept( ev );
	256	return std::make_pair( ev.pass.value, ev.pass.valid );
[5cbacf1]	257	} else {
[120867e]	258	return std::make_pair( 0, false );
[5cbacf1]	259	}
	260	}
	261
[120867e]	262	std::pair<long long int, bool> eval( const ast::Expr * expr ) {
[d7aa12c]	263	ast::Pass<EvalNew> ev;
[120867e]	264	if ( expr ) {
	265	expr->accept( ev );
	266	return std::make_pair( ev.core.value, ev.core.valid );
[d7aa12c]	267	} else {
[120867e]	268	return std::make_pair( 0, false );
[d7aa12c]	269	}
[0588d8c]	270	}
	271
[5cbacf1]	272	// Local Variables: //
	273	// tab-width: 4 //
	274	// mode: c++ //
	275	// compile-command: "make install" //
	276	// End: //

Note: See TracBrowser for help on using the repository browser.

Download in other formats: