Changes in / [54aba8d:b3048d4]
- Location:
- src
- Files:
-
- 13 added
- 13 deleted
- 24 edited
Legend:
- Unmodified
- Added
- Removed
-
TabularUnified src/CodeTools/TrackLoc.cc ¶
r54aba8d rb3048d4 64 64 } 65 65 else { 66 assertf( false, "Top level node has no CodeLocation %s", name.c_str() );66 assertf( false, "Top level node has no CodeLocation %s", toString( node ).c_str() ); 67 67 } 68 68 } -
TabularUnified src/InitTweak/FixInit.cc ¶
r54aba8d rb3048d4 5 5 // file "LICENCE" distributed with Cforall. 6 6 // 7 // FixInit. h--7 // FixInit.cc -- 8 8 // 9 9 // Author : Rob Schluntz … … 365 365 // arrays are not copy constructed, so this should always be an ExprStmt 366 366 ImplicitCtorDtorStmt * stmt = genCtorDtor( fname, var, cpArg ); 367 ExprStmt * exprStmt = strict_dynamic_cast< ExprStmt * >( stmt->get_callStmt() ); 367 assertf( stmt, "ResolveCopyCtors: genCtorDtor returned nullptr: %s / %s / %s", fname.c_str(), toString( var ).c_str(), toString( cpArg ).c_str() ); 368 ExprStmt * exprStmt = strict_dynamic_cast< ExprStmt * >( stmt->callStmt ); 368 369 Expression * resolved = exprStmt->expr; 369 370 exprStmt->expr = nullptr; // take ownership of expr … … 382 383 } // if 383 384 delete stmt; 385 if ( TupleAssignExpr * assign = dynamic_cast< TupleAssignExpr * >( resolved ) ) { 386 // fix newly generated StmtExpr 387 postvisit( assign->stmtExpr ); 388 } 384 389 return resolved; 385 390 } … … 475 480 static UniqueName retNamer("_tmp_stmtexpr_ret"); 476 481 477 // create variable that will hold the result of the stmt expr478 482 result = result->clone(); 479 483 env->apply( result ); 484 if ( ! InitTweak::isConstructable( result ) ) { 485 delete result; 486 return; 487 } 488 489 // create variable that will hold the result of the stmt expr 480 490 ObjectDecl * ret = ObjectDecl::newObject( retNamer.newName(), result, nullptr ); 481 ret-> get_type()->set_const( false );482 stmtExpr-> get_returnDecls().push_front( ret );491 ret->type->set_const( false ); 492 stmtExpr->returnDecls.push_front( ret ); 483 493 484 494 // must have a non-empty body, otherwise it wouldn't have a result 485 CompoundStmt * body = stmtExpr-> get_statements();495 CompoundStmt * body = stmtExpr->statements; 486 496 assert( ! body->get_kids().empty() ); 487 497 // must be an ExprStmt, otherwise it wouldn't have a result 488 498 ExprStmt * last = strict_dynamic_cast< ExprStmt * >( body->get_kids().back() ); 489 last-> set_expr( makeCtorDtor( "?{}", ret, last->get_expr()) );490 491 stmtExpr-> get_dtors().push_front( makeCtorDtor( "^?{}", ret ) );499 last->expr = makeCtorDtor( "?{}", ret, last->get_expr() ); 500 501 stmtExpr->dtors.push_front( makeCtorDtor( "^?{}", ret ) ); 492 502 } // if 493 503 } … … 590 600 // to the outer context, rather than inside of the statement expression. 591 601 visit_children = false; 592 std::list< Statement * > & stmts = stmtExpr-> get_statements()->get_kids();602 std::list< Statement * > & stmts = stmtExpr->statements->get_kids(); 593 603 for ( Statement *& stmt : stmts ) { 594 604 stmt = stmt->acceptMutator( *visitor ); 595 605 } // for 596 assert( stmtExpr-> get_result());597 Type * result = stmtExpr-> get_result();606 assert( stmtExpr->result ); 607 Type * result = stmtExpr->result; 598 608 if ( ! result->isVoid() ) { 599 for ( ObjectDecl * obj : stmtExpr-> get_returnDecls()) {609 for ( ObjectDecl * obj : stmtExpr->returnDecls ) { 600 610 stmtsToAddBefore.push_back( new DeclStmt( obj ) ); 601 611 } // for 602 612 // add destructors after current statement 603 for ( Expression * dtor : stmtExpr-> get_dtors()) {613 for ( Expression * dtor : stmtExpr->dtors ) { 604 614 stmtsToAddAfter.push_back( new ExprStmt( dtor ) ); 605 615 } // for 606 616 // must have a non-empty body, otherwise it wouldn't have a result 607 617 assert( ! stmts.empty() ); 608 assert( ! stmtExpr->get_returnDecls().empty() ); 609 stmts.push_back( new ExprStmt( new VariableExpr( stmtExpr->get_returnDecls().front() ) ) ); 610 stmtExpr->get_returnDecls().clear(); 611 stmtExpr->get_dtors().clear(); 612 } 613 assert( stmtExpr->get_returnDecls().empty() ); 614 assert( stmtExpr->get_dtors().empty() ); 618 assertf( ! stmtExpr->returnDecls.empty() || stmtExpr->dtors.empty(), "StmtExpr returns non-void, but no return decls: %s", toString( stmtExpr ).c_str() ); 619 // if there is a return decl, add a use as the last statement; will not have return decl on non-constructable returns 620 if ( ! stmtExpr->returnDecls.empty() ) { 621 stmts.push_back( new ExprStmt( new VariableExpr( stmtExpr->returnDecls.front() ) ) ); 622 } 623 stmtExpr->returnDecls.clear(); 624 stmtExpr->dtors.clear(); 625 } 626 assert( stmtExpr->returnDecls.empty() ); 627 assert( stmtExpr->dtors.empty() ); 615 628 } 616 629 -
TabularUnified src/InitTweak/GenInit.cc ¶
r54aba8d rb3048d4 30 30 #include "InitTweak.h" // for isConstExpr, InitExpander, checkIn... 31 31 #include "Parser/LinkageSpec.h" // for isOverridable, C 32 #include "ResolvExpr/Resolver.h" 32 33 #include "SymTab/Autogen.h" // for genImplicitCall, SizeType 33 34 #include "SymTab/Mangler.h" // for Mangler … … 89 90 }; 90 91 91 struct HoistArrayDimension final : public WithDeclsToAdd, public WithShortCircuiting, public WithGuards {92 struct HoistArrayDimension final : public WithDeclsToAdd, public WithShortCircuiting, public WithGuards, public WithIndexer { 92 93 /// hoist dimension from array types in object declaration so that it uses a single 93 94 /// const variable of type size_t, so that side effecting array dimensions are only … … 104 105 void premutate( FunctionType * ) { visit_children = false; } 105 106 107 // need this so that enumerators are added to the indexer, due to premutate(AggregateDecl *) 108 void premutate( EnumDecl * ) {} 109 106 110 void hoist( Type * type ); 107 111 … … 135 139 if ( varExpr->var == retVal ) return; 136 140 } 137 stmtsToAddBefore.push_back( genCtorDtor( "?{}", retVal, returnStmt->get_expr() ) ); 141 Statement * stmt = genCtorDtor( "?{}", retVal, returnStmt->expr ); 142 assertf( stmt, "ReturnFixer: genCtorDtor returned nullptr: %s / %s", toString( retVal ).c_str(), toString( returnStmt->expr ).c_str() ); 143 stmtsToAddBefore.push_back( stmt ); 138 144 139 145 // return the retVal object … … 178 184 if ( ! arrayType->get_dimension() ) return; // xxx - recursive call to hoist? 179 185 186 // need to resolve array dimensions in order to accurately determine if constexpr 187 ResolvExpr::findSingleExpression( arrayType->dimension, SymTab::SizeType->clone(), indexer ); 180 188 // don't need to hoist dimension if it's a constexpr - only need to if there's potential for side effects. 181 189 if ( isConstExpr( arrayType->get_dimension() ) ) return; … … 194 202 void HoistArrayDimension::premutate( FunctionDecl * ) { 195 203 GuardValue( inFunction ); 204 inFunction = true; 196 205 } 197 206 -
TabularUnified src/InitTweak/InitTweak.cc ¶
r54aba8d rb3048d4 564 564 void previsit( ConstantExpr * ) {} 565 565 566 void previsit( VariableExpr * varExpr ) { 567 visit_children = false; 568 569 if ( EnumInstType * inst = dynamic_cast< EnumInstType * >( varExpr->result ) ) { 570 long long int value; 571 if ( inst->baseEnum->valueOf( varExpr->var, value ) ) { 572 // enumerators are const expr 573 return; 574 } 575 } 576 isConstExpr = false; 577 } 578 566 579 bool isConstExpr = true; 567 580 }; -
TabularUnified src/Parser/DeclarationNode.cc ¶
r54aba8d rb3048d4 343 343 DeclarationNode * newnode = new DeclarationNode; 344 344 newnode->type = new TypeData( kind == OperKinds::PointTo ? TypeData::Pointer : TypeData::Reference ); 345 if ( kind == OperKinds::And ) { 346 // T && is parsed as 'And' operator rather than two references => add a second reference type 347 TypeData * td = new TypeData( TypeData::Reference ); 348 td->base = newnode->type; 349 newnode->type = td; 350 } 345 351 if ( qualifiers ) { 346 352 return newnode->addQualifiers( qualifiers ); -
TabularUnified src/ResolvExpr/CommonType.cc ¶
r54aba8d rb3048d4 91 91 // special case where one type has a reference depth of 1 larger than the other 92 92 if ( diff > 0 || diff < 0 ) { 93 // std::cerr << "reference depth diff: " << diff << std::endl; 93 94 Type * result = nullptr; 94 if ( ReferenceType * ref1 = dynamic_cast< ReferenceType * >( type1 ) ) { 95 ReferenceType * ref1 = dynamic_cast< ReferenceType * >( type1 ); 96 ReferenceType * ref2 = dynamic_cast< ReferenceType * >( type2 ); 97 if ( diff > 0 ) { 98 // deeper on the left 99 assert( ref1 ); 100 result = handleReference( ref1->base, type2, widenFirst, widenSecond, indexer, env, openVars ); 101 } else { 102 // deeper on the right 103 assert( ref2 ); 104 result = handleReference( type1, ref2->base, widenFirst, widenSecond, indexer, env, openVars ); 105 } 106 if ( result && ref1 ) { 95 107 // formal is reference, so result should be reference 96 result = handleReference( ref1->base, type2, widenFirst, widenSecond, indexer, env, openVars ); 97 if ( result ) result = new ReferenceType( ref1->get_qualifiers(), result ); 98 } else { 99 // formal is value, so result should be value 100 ReferenceType * ref2 = strict_dynamic_cast< ReferenceType * > ( type2 ); 101 result = handleReference( type1, ref2->base, widenFirst, widenSecond, indexer, env, openVars ); 108 // std::cerr << "formal is reference; result should be reference" << std::endl; 109 result = new ReferenceType( ref1->get_qualifiers(), result ); 102 110 } 103 111 // std::cerr << "common type of reference [" << type1 << "] and [" << type2 << "] is [" << result << "]" << std::endl; … … 180 188 } 181 189 182 void CommonType::visit( __attribute((unused)) VoidType *voidType) {}190 void CommonType::visit( VoidType * ) {} 183 191 184 192 void CommonType::visit( BasicType *basicType ) { … … 246 254 } 247 255 248 void CommonType::visit( __attribute((unused)) ArrayType *arrayType) {}256 void CommonType::visit( ArrayType * ) {} 249 257 250 258 void CommonType::visit( ReferenceType *refType ) { … … 283 291 } 284 292 285 void CommonType::visit( __attribute((unused)) FunctionType *functionType) {}286 void CommonType::visit( __attribute((unused)) StructInstType *aggregateUseType) {}287 void CommonType::visit( __attribute((unused)) UnionInstType *aggregateUseType) {}293 void CommonType::visit( FunctionType * ) {} 294 void CommonType::visit( StructInstType * ) {} 295 void CommonType::visit( UnionInstType * ) {} 288 296 289 297 void CommonType::visit( EnumInstType *enumInstType ) { … … 296 304 } 297 305 298 void CommonType::visit( __attribute((unused)) TraitInstType *aggregateUseType) {306 void CommonType::visit( TraitInstType * ) { 299 307 } 300 308 … … 321 329 } 322 330 323 void CommonType::visit( __attribute((unused)) TupleType *tupleType) {}324 void CommonType::visit( __attribute((unused)) VarArgsType *varArgsType) {}331 void CommonType::visit( TupleType * ) {} 332 void CommonType::visit( VarArgsType * ) {} 325 333 326 334 void CommonType::visit( ZeroType *zeroType ) { -
TabularUnified src/ResolvExpr/ConversionCost.cc ¶
r54aba8d rb3048d4 92 92 93 93 Cost convertToReferenceCost( Type * src, Type * dest, int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ) { 94 PRINT( std::cerr << "convert to reference cost... diff " << diff << std::endl; )94 PRINT( std::cerr << "convert to reference cost... diff " << diff << " " << src << " / " << dest << std::endl; ) 95 95 if ( diff > 0 ) { 96 96 // TODO: document this … … 108 108 if ( srcAsRef && destAsRef ) { // pointer-like conversions between references 109 109 PRINT( std::cerr << "converting between references" << std::endl; ) 110 if ( srcAsRef->get_base()->get_qualifiers() <= destAsRef->get_base()->get_qualifiers() && typesCompatibleIgnoreQualifiers( srcAsRef->get_base(), destAsRef->get_base(), indexer, env ) ) { 111 return Cost::safe; 110 Type::Qualifiers tq1 = srcAsRef->get_base()->get_qualifiers(); 111 Type::Qualifiers tq2 = destAsRef->get_base()->get_qualifiers(); 112 if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( srcAsRef->get_base(), destAsRef->get_base(), indexer, env ) ) { 113 PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; ) 114 if ( tq1 == tq2 ) { 115 // types are the same 116 return Cost::zero; 117 } else { 118 // types are the same, except otherPointer has more qualifiers 119 return Cost::safe; 120 } 112 121 } else { // xxx - this discards reference qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right? 113 122 int assignResult = func( srcAsRef->get_base(), destAsRef->get_base(), env, indexer ); … … 248 257 }; 249 258 250 void ConversionCost::visit( __attribute((unused)) VoidType *voidType) {259 void ConversionCost::visit( VoidType * ) { 251 260 cost = Cost::infinity; 252 261 } … … 271 280 void ConversionCost::visit( PointerType * pointerType ) { 272 281 if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) { 273 PRINT( std::cerr << pointerType << " ===> " << destAsPtr ; )282 PRINT( std::cerr << pointerType << " ===> " << destAsPtr << std::endl; ) 274 283 Type::Qualifiers tq1 = pointerType->get_base()->get_qualifiers(); 275 284 Type::Qualifiers tq2 = destAsPtr->get_base()->get_qualifiers(); 276 285 if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) { 286 PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; ) 277 287 if ( tq1 == tq2 ) { 278 288 // types are the same … … 280 290 } else { 281 291 // types are the same, except otherPointer has more qualifiers 282 PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )283 292 cost = Cost::safe; 284 293 } 285 } else { // xxx - this discards qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?294 } else { 286 295 int assignResult = ptrsAssignable( pointerType->base, destAsPtr->base, env ); 287 296 PRINT( std::cerr << " :: " << assignResult << std::endl; ) 288 if ( assignResult > 0 && pointerType->get_base()->get_qualifiers() <= destAsPtr->get_qualifiers() ) { 289 cost = Cost::safe; 297 if ( assignResult > 0 && tq1 <= tq2 ) { 298 // xxx - want the case where qualifiers are added to be more expensive than the case where qualifiers are the same. Is 1 safe vs. 2 safe correct? 299 if ( tq1 == tq2 ) { 300 cost = Cost::safe; 301 } else if ( tq1 < tq2 ) { 302 cost = Cost::safe+Cost::safe; 303 } 290 304 } else if ( assignResult < 0 ) { 291 305 cost = Cost::unsafe; -
TabularUnified src/ResolvExpr/CurrentObject.cc ¶
r54aba8d rb3048d4 38 38 39 39 namespace ResolvExpr { 40 long long int getConstValue( ConstantExpr * constExpr ) {41 if ( BasicType * basicType = dynamic_cast< BasicType * >( constExpr->get_result() ) ) {42 if ( basicType->isInteger() ) {43 return constExpr->get_constant()->get_ival();44 } else {45 assertf( false, "Non-integer constant expression in getConstValue %s", toString( constExpr ).c_str() ); // xxx - might be semantic error46 }47 } else if ( dynamic_cast< OneType * >( constExpr->get_result() ) ) {48 return 1;49 } else if ( dynamic_cast< ZeroType * >( constExpr->get_result() ) ) {50 return 0;51 } else {52 assertf( false, "unhandled type on getConstValue %s", toString( constExpr->get_result() ).c_str() ); // xxx - might be semantic error53 }54 }55 56 40 template< typename AggrInst > 57 41 TypeSubstitution makeGenericSubstitution( AggrInst * inst ) { … … 151 135 void setSize( Expression * expr ) { 152 136 if ( ConstantExpr * constExpr = dynamic_cast< ConstantExpr * >( expr ) ) { 153 size = getConstValue( constExpr ); 137 size = constExpr->intValue(); 138 isVLA = false; 154 139 PRINT( std::cerr << "array type with size: " << size << std::endl; ) 155 140 } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) { 156 141 setSize( castExpr->get_arg() ); // xxx - need to perform the conversion specified by the cast 142 } else if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( expr ) ) { 143 if ( EnumInstType * inst = dynamic_cast< EnumInstType * > ( varExpr->result ) ) { 144 long long int value; 145 if ( inst->baseEnum->valueOf( varExpr->var, value ) ) { 146 size = value; 147 isVLA = false; 148 } 149 } 157 150 } else { 158 151 assertf( false, "unhandled expression in setSize: %s", toString( expr ).c_str() ); // xxx - if not a constant expression, it's not simple to determine how long the array actually is, which is necessary for initialization to be done correctly -- fix this … … 164 157 // need to permit integer-constant-expressions, including: integer constants, enumeration constants, character constants, sizeof expressions, _Alignof expressions, cast expressions 165 158 if ( ConstantExpr * constExpr = dynamic_cast< ConstantExpr * >( expr ) ) { 166 index = getConstValue( constExpr);159 index = constExpr->intValue(); 167 160 } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) { 168 161 setPosition( castExpr->get_arg() ); 169 162 } else if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( expr ) ) { 170 assertf( dynamic_cast<EnumInstType *> ( varExpr->get_result() ), "ArrayIterator given variable that isn't an enum constant : %s", toString( expr ).c_str() ); 171 index = 0; // xxx - get actual value of enum constant 163 EnumInstType * inst = dynamic_cast<EnumInstType *>( varExpr->get_result() ); 164 assertf( inst, "ArrayIterator given variable that isn't an enum constant : %s", toString( expr ).c_str() ); 165 long long int value; 166 if ( inst->baseEnum->valueOf( varExpr->var, value ) ) { 167 index = value; 168 } 172 169 } else if ( dynamic_cast< SizeofExpr * >( expr ) || dynamic_cast< AlignofExpr * >( expr ) ) { 173 170 index = 0; // xxx - get actual sizeof/alignof value? … … 189 186 } 190 187 191 virtual operator bool() const { return index < size; }188 virtual operator bool() const { return ! isVLA && index < size; } 192 189 193 190 virtual MemberIterator & bigStep() { … … 195 192 ++index; 196 193 delete memberIter; 197 if ( index < size ) memberIter = createMemberIterator( base );194 if ( ! isVLA && index < size ) memberIter = createMemberIterator( base ); 198 195 else memberIter = nullptr; 199 196 return *this; … … 242 239 size_t index = 0; 243 240 size_t size = 0; 241 bool isVLA = true; 244 242 MemberIterator * memberIter = nullptr; 245 243 }; -
TabularUnified src/ResolvExpr/FindOpenVars.cc ¶
r54aba8d rb3048d4 19 19 #include <map> // for map<>::mapped_type 20 20 21 #include "Common/PassVisitor.h" 21 22 #include "SynTree/Declaration.h" // for TypeDecl, DeclarationWithType (ptr ... 22 23 #include "SynTree/Type.h" // for Type, Type::ForallList, ArrayType 23 #include "SynTree/Visitor.h" // for Visitor24 24 25 25 namespace ResolvExpr { 26 class FindOpenVars : public Visitor { 27 public: 26 struct FindOpenVars : public WithGuards { 28 27 FindOpenVars( OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen ); 29 28 30 private: 31 virtual void visit(PointerType *pointerType); 32 virtual void visit(ArrayType *arrayType); 33 virtual void visit(FunctionType *functionType); 34 virtual void visit(TupleType *tupleType); 29 void previsit( PointerType * pointerType ); 30 void previsit( ArrayType * arrayType ); 31 void previsit( FunctionType * functionType ); 32 void previsit( TupleType * tupleType ); 35 33 36 34 void common_action( Type *type ); … … 42 40 43 41 void findOpenVars( Type *type, OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen ) { 44 FindOpenVarsfinder( openVars, closedVars, needAssertions, haveAssertions, firstIsOpen );42 PassVisitor<FindOpenVars> finder( openVars, closedVars, needAssertions, haveAssertions, firstIsOpen ); 45 43 type->accept( finder ); 46 44 } … … 70 68 } // for 71 69 } // if 72 /// std::c out<< "type is ";73 /// type->print( std::c out);74 /// std::c out<< std::endl << "need is" << std::endl;75 /// printAssertionSet( needAssertions, std::c out);76 /// std::c out<< std::endl << "have is" << std::endl;77 /// printAssertionSet( haveAssertions, std::c out);70 /// std::cerr << "type is "; 71 /// type->print( std::cerr ); 72 /// std::cerr << std::endl << "need is" << std::endl; 73 /// printAssertionSet( needAssertions, std::cerr ); 74 /// std::cerr << std::endl << "have is" << std::endl; 75 /// printAssertionSet( haveAssertions, std::cerr ); 78 76 } 79 77 80 void FindOpenVars:: visit(PointerType *pointerType) {78 void FindOpenVars::previsit(PointerType *pointerType) { 81 79 common_action( pointerType ); 82 Visitor::visit( pointerType );83 80 } 84 81 85 void FindOpenVars:: visit(ArrayType *arrayType) {82 void FindOpenVars::previsit(ArrayType *arrayType) { 86 83 common_action( arrayType ); 87 Visitor::visit( arrayType );88 84 } 89 85 90 void FindOpenVars:: visit(FunctionType *functionType) {86 void FindOpenVars::previsit(FunctionType *functionType) { 91 87 common_action( functionType ); 92 88 nextIsOpen = ! nextIsOpen; 93 Visitor::visit( functionType ); 94 nextIsOpen = ! nextIsOpen; 89 GuardAction( [this](){ nextIsOpen = ! nextIsOpen; } ); 95 90 } 96 91 97 void FindOpenVars:: visit(TupleType *tupleType) {92 void FindOpenVars::previsit(TupleType *tupleType) { 98 93 common_action( tupleType ); 99 Visitor::visit( tupleType );100 94 } 101 95 } // namespace ResolvExpr -
TabularUnified src/ResolvExpr/Occurs.cc ¶
r54aba8d rb3048d4 5 5 // file "LICENCE" distributed with Cforall. 6 6 // 7 // Occurs.cc -- 7 // Occurs.cc -- 8 8 // 9 9 // Author : Richard C. Bilson … … 17 17 #include <string> // for string 18 18 19 #include "Common/PassVisitor.h" 19 20 #include "SynTree/Type.h" // for TypeInstType, Type 20 #include "SynTree/Visitor.h" // for Visitor21 21 #include "TypeEnvironment.h" // for EqvClass, TypeEnvironment 22 22 23 23 namespace ResolvExpr { 24 class Occurs : public Visitor { 25 public: 24 struct Occurs : public WithVisitorRef<Occurs> { 26 25 Occurs( std::string varName, const TypeEnvironment &env ); 27 bool get_result() const { return result; } 28 virtual void visit( TypeInstType *typeInst ); 29 private: 26 void previsit( TypeInstType * typeInst ); 27 30 28 bool result; 31 29 std::set< std::string > eqvVars; 32 const TypeEnvironment & env;30 const TypeEnvironment &tenv; 33 31 }; 34 32 35 33 bool occurs( Type *type, std::string varName, const TypeEnvironment &env ) { 36 Occursoccur( varName, env );34 PassVisitor<Occurs> occur( varName, env ); 37 35 type->accept( occur ); 38 return occur. get_result();36 return occur.pass.result; 39 37 } 40 38 41 Occurs::Occurs( std::string varName, const TypeEnvironment & env ) : result( false ),env( env ) {39 Occurs::Occurs( std::string varName, const TypeEnvironment & env ) : result( false ), tenv( env ) { 42 40 EqvClass eqvClass; 43 if ( env.lookup( varName, eqvClass ) ) {41 if ( tenv.lookup( varName, eqvClass ) ) { 44 42 eqvVars = eqvClass.vars; 45 43 } else { … … 48 46 } 49 47 50 void Occurs:: visit( TypeInstType *typeInst ) {48 void Occurs::previsit( TypeInstType * typeInst ) { 51 49 EqvClass eqvClass; 52 /// std::c out<< "searching for vars: ";53 /// std::copy( eqvVars.begin(), eqvVars.end(), std::ostream_iterator< std::string >( std::c out, " " ) );54 /// std::c out<< std::endl;50 /// std::cerr << "searching for vars: "; 51 /// std::copy( eqvVars.begin(), eqvVars.end(), std::ostream_iterator< std::string >( std::cerr, " " ) ); 52 /// std::cerr << std::endl; 55 53 if ( eqvVars.find( typeInst->get_name() ) != eqvVars.end() ) { 56 54 result = true; 57 } else if ( env.lookup( typeInst->get_name(), eqvClass ) ) {55 } else if ( tenv.lookup( typeInst->get_name(), eqvClass ) ) { 58 56 if ( eqvClass.type ) { 59 /// std::c out<< typeInst->get_name() << " is bound to";60 /// eqvClass.type->print( std::c out);61 /// std::c out<< std::endl;62 eqvClass.type->accept( * this);57 /// std::cerr << typeInst->get_name() << " is bound to"; 58 /// eqvClass.type->print( std::cerr ); 59 /// std::cerr << std::endl; 60 eqvClass.type->accept( *visitor ); 63 61 } // if 64 62 } // if -
TabularUnified src/ResolvExpr/PolyCost.cc ¶
r54aba8d rb3048d4 14 14 // 15 15 16 #include "Common/PassVisitor.h" 16 17 #include "SymTab/Indexer.h" // for Indexer 17 18 #include "SynTree/Type.h" // for TypeInstType, Type 18 #include "SynTree/Visitor.h" // for Visitor19 19 #include "TypeEnvironment.h" // for EqvClass, TypeEnvironment 20 20 21 21 namespace ResolvExpr { 22 class PolyCost : public Visitor { 23 public: 22 struct PolyCost { 24 23 PolyCost( const TypeEnvironment &env, const SymTab::Indexer &indexer ); 25 int get_result() const { return result; } 26 private: 27 virtual void visit(TypeInstType *aggregateUseType); 24 25 void previsit( TypeInstType * aggregateUseType ); 28 26 int result; 29 const TypeEnvironment & env;27 const TypeEnvironment &tenv; 30 28 const SymTab::Indexer &indexer; 31 29 }; 32 30 33 31 int polyCost( Type *type, const TypeEnvironment & env, const SymTab::Indexer &indexer ) { 34 P olyCostcoster( env, indexer );32 PassVisitor<PolyCost> coster( env, indexer ); 35 33 type->accept( coster ); 36 return coster. get_result();34 return coster.pass.result; 37 35 } 38 36 39 PolyCost::PolyCost( const TypeEnvironment & env, const SymTab::Indexer & indexer ) : result( 0 ), env( env ), indexer( indexer ) {37 PolyCost::PolyCost( const TypeEnvironment & env, const SymTab::Indexer & indexer ) : result( 0 ), tenv( env ), indexer( indexer ) { 40 38 } 41 39 42 void PolyCost:: visit(TypeInstType * typeInst) {40 void PolyCost::previsit(TypeInstType * typeInst) { 43 41 EqvClass eqvClass; 44 if ( env.lookup( typeInst->name, eqvClass ) ) {42 if ( tenv.lookup( typeInst->name, eqvClass ) ) { 45 43 if ( eqvClass.type ) { 46 44 if ( TypeInstType * otherTypeInst = dynamic_cast< TypeInstType* >( eqvClass.type ) ) { -
TabularUnified src/ResolvExpr/PtrsAssignable.cc ¶
r54aba8d rb3048d4 67 67 PtrsAssignable::PtrsAssignable( Type *dest, const TypeEnvironment &env ) : dest( dest ), result( 0 ), env( env ) {} 68 68 69 void PtrsAssignable::visit( __attribute((unused)) VoidType *voidType) {69 void PtrsAssignable::visit( VoidType * ) { 70 70 // T * = void * is disallowed - this is a change from C, where any 71 71 // void * can be assigned or passed to a non-void pointer without a cast. -
TabularUnified src/ResolvExpr/Resolver.h ¶
r54aba8d rb3048d4 33 33 void findVoidExpression( Expression *& untyped, const SymTab::Indexer &indexer ); 34 34 void findSingleExpression( Expression *& untyped, const SymTab::Indexer &indexer ); 35 void findSingleExpression( Expression *& untyped, Type * type, const SymTab::Indexer &indexer ); 35 36 void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer ); 36 37 void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer ); -
TabularUnified src/SymTab/Indexer.cc ¶
r54aba8d rb3048d4 572 572 } 573 573 574 void Indexer::addMembers( AggregateDecl * aggr, Expression * expr ) { 575 for ( Declaration * decl : aggr->members ) { 576 if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) { 577 addId( dwt, expr ); 578 if ( dwt->name == "" ) { 579 Type * t = dwt->get_type()->stripReferences(); 580 if ( dynamic_cast< StructInstType * >( t ) || dynamic_cast< UnionInstType * >( t ) ) { 581 Expression * base = expr->clone(); 582 ResolvExpr::referenceToRvalueConversion( base ); 583 addMembers( t->getAggr(), new MemberExpr( dwt, base ) ); 584 } 585 } 586 } 587 } 588 } 589 574 590 void Indexer::addWith( WithStmt * stmt ) { 575 591 for ( Expression * expr : stmt->exprs ) { … … 578 594 assertf( aggr, "WithStmt expr has non-aggregate type: %s", toString( expr->result ).c_str() ); 579 595 580 for ( Declaration * decl : aggr->members ) { 581 if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) { 582 addId( dwt, expr ); 583 } 584 } 596 addMembers( aggr, expr ); 585 597 } 586 598 } -
TabularUnified src/SymTab/Indexer.h ¶
r54aba8d rb3048d4 86 86 void addWith( WithStmt * ); 87 87 88 /// adds all of the members of the Aggregate (addWith helper) 89 void addMembers( AggregateDecl * aggr, Expression * expr ); 90 88 91 /// convenience function for adding a list of Ids to the indexer 89 92 void addIds( const std::list< DeclarationWithType * > & decls ); -
TabularUnified src/SymTab/Validate.cc ¶
r54aba8d rb3048d4 94 94 template< typename AggDecl > void handleAggregate( AggDecl *aggregateDecl ); 95 95 96 bool inStruct = false;96 AggregateDecl * parentAggr = nullptr; 97 97 }; 98 98 … … 303 303 template< typename AggDecl > 304 304 void HoistStruct::handleAggregate( AggDecl *aggregateDecl ) { 305 if ( inStruct) {305 if ( parentAggr ) { 306 306 // Add elements in stack order corresponding to nesting structure. 307 307 declsToAddBefore.push_front( aggregateDecl ); 308 308 } else { 309 GuardValue( inStruct);310 inStruct = true;309 GuardValue( parentAggr ); 310 parentAggr = aggregateDecl; 311 311 } // if 312 312 // Always remove the hoisted aggregate from the inner structure. -
TabularUnified src/SynTree/AggregateDecl.cc ¶
r54aba8d rb3048d4 86 86 std::string TraitDecl::typeString() const { return "trait"; } 87 87 88 namespace { 89 long long int getConstValue( Expression * expr ) { 90 if ( CastExpr * castExpr = dynamic_cast< CastExpr * > ( expr ) ) { 91 return getConstValue( castExpr->arg ); 92 } else if ( ConstantExpr * constExpr = dynamic_cast< ConstantExpr * >( expr ) ) { 93 return constExpr->intValue(); 94 } else { 95 assertf( false, "Unhandled expression type in getConstValue for enumerators: %s", toString( expr ).c_str() ); 96 } 97 } 98 } 99 100 bool EnumDecl::valueOf( Declaration * enumerator, long long int & value ) { 101 if ( enumValues.empty() ) { 102 long long int currentValue = 0; 103 for ( Declaration * member : members ) { 104 ObjectDecl * field = strict_dynamic_cast< ObjectDecl * >( member ); 105 if ( field->init ) { 106 SingleInit * init = strict_dynamic_cast< SingleInit * >( field->init ); 107 currentValue = getConstValue( init->value ); 108 } 109 assertf( enumValues.count( field->name ) == 0, "Enum %s has multiple members with the name %s", name.c_str(), field->name.c_str() ); 110 enumValues[ field->name ] = currentValue; 111 ++currentValue; 112 } 113 } 114 if ( enumValues.count( enumerator->name ) ) { 115 value = enumValues[ enumerator->name ]; 116 return true; 117 } 118 return false; 119 } 120 88 121 // Local Variables: // 89 122 // tab-width: 4 // -
TabularUnified src/SynTree/Declaration.h ¶
r54aba8d rb3048d4 319 319 EnumDecl( const EnumDecl &other ) : Parent( other ) {} 320 320 321 bool valueOf( Declaration * enumerator, long long int & value ); 322 321 323 virtual EnumDecl *clone() const override { return new EnumDecl( *this ); } 322 324 virtual void accept( Visitor &v ) override { v.visit( this ); } 323 325 virtual Declaration *acceptMutator( Mutator &m ) override { return m.mutate( this ); } 324 326 private: 327 std::map< std::string, long long int > enumValues; 325 328 virtual std::string typeString() const override; 326 329 }; -
TabularUnified src/SynTree/Expression.cc ¶
r54aba8d rb3048d4 83 83 } 84 84 85 long long int ConstantExpr::intValue() const { 86 if ( BasicType * basicType = dynamic_cast< BasicType * >( result ) ) { 87 if ( basicType->isInteger() ) { 88 return get_constant()->get_ival(); 89 } 90 } else if ( dynamic_cast< OneType * >( result ) ) { 91 return 1; 92 } else if ( dynamic_cast< ZeroType * >( result ) ) { 93 return 0; 94 } 95 throw SemanticError( "Constant expression of non-integral type ", this ); 96 } 97 85 98 VariableExpr::VariableExpr( DeclarationWithType *_var ) : Expression(), var( _var ) { 86 99 assert( var ); … … 589 602 if ( ! body.empty() ) { 590 603 if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( body.back() ) ) { 591 set_result( maybeClone( exprStmt->get_expr()->get_result() ));604 result = maybeClone( exprStmt->expr->result ); 592 605 } 593 606 } 594 607 // ensure that StmtExpr has a result type 595 608 if ( ! result ) { 596 set_result( new VoidType( Type::Qualifiers()) );609 result = new VoidType( Type::Qualifiers() ); 597 610 } 598 611 } -
TabularUnified src/SynTree/Expression.h ¶
r54aba8d rb3048d4 295 295 296 296 Constant * get_constant() { return & constant; } 297 const Constant * get_constant() const { return & constant; } 297 298 void set_constant( const Constant & newValue ) { constant = newValue; } 299 300 long long int intValue() const; 298 301 299 302 virtual ConstantExpr * clone() const { return new ConstantExpr( * this ); } -
TabularUnified src/SynTree/Type.h ¶
r54aba8d rb3048d4 356 356 bool isTtype() const; 357 357 358 bool isUnprototyped() const { return isVarArgs && parameters.size() == 0; } 359 358 360 virtual FunctionType *clone() const override { return new FunctionType( *this ); } 359 361 virtual void accept( Visitor & v ) override { v.visit( this ); } -
TabularUnified src/Tuples/TupleAssignment.cc ¶
r54aba8d rb3048d4 272 272 // args.push_back( new AddressExpr( new VariableExpr( left ) ) ); 273 273 if ( right ) args.push_back( new VariableExpr( right ) ); 274 return new UntypedExpr( new NameExpr( fname ), args ); 274 if ( left->type->referenceDepth() > 1 && CodeGen::isConstructor( fname ) ) { 275 args.front() = new AddressExpr( args.front() ); 276 if ( right ) args.back() = new AddressExpr( args.back() ); 277 return new UntypedExpr( new NameExpr( "?=?" ), args ); 278 } else { 279 return new UntypedExpr( new NameExpr( fname ), args ); 280 } 275 281 } 276 282 … … 291 297 if ( ! dynamic_cast< ReferenceType * >( expr->get_result() ) ) { 292 298 ConstructorInit * ctorInit = InitTweak::genCtorInit( ret ); 293 ret-> set_init( ctorInit );299 ret->init = ctorInit; 294 300 ResolvExpr::resolveCtorInit( ctorInit, spotter.currentFinder.get_indexer() ); // resolve ctor/dtors for the new object 295 301 PassVisitor<EnvRemover> rm; // remove environments from subexpressions of StmtExprs -
TabularUnified src/Tuples/TupleExpansion.cc ¶
r54aba8d rb3048d4 202 202 // generate struct type to replace tuple type based on the number of components in the tuple 203 203 StructDecl * decl = new StructDecl( toString( "_tuple", tupleSize, "_" ) ); 204 decl->location = tupleType->location; 204 205 decl->set_body( true ); 205 206 for ( size_t i = 0; i < tupleSize; ++i ) { -
TabularUnified src/libcfa/concurrency/monitor.c ¶
r54aba8d rb3048d4 534 534 __lock_size_t actual_count = aggregate( mon_storage, mask ); 535 535 536 __cfaabi_dbg_print_buffer_decl( "Kernel : waitfor % d (s: %d, m: %d)\n", actual_count, mask.size, (__lock_size_t)max);536 __cfaabi_dbg_print_buffer_decl( "Kernel : waitfor %"PRIdFAST16" (s: %"PRIdFAST16", m: %"PRIdFAST16")\n", actual_count, mask.size, (__lock_size_t)max); 537 537 538 538 if(actual_count == 0) return; … … 575 575 monitor_save; 576 576 577 __cfaabi_dbg_print_buffer_local( "Kernel : baton of % dmonitors : ", count );577 __cfaabi_dbg_print_buffer_local( "Kernel : baton of %"PRIdFAST16" monitors : ", count ); 578 578 #ifdef __CFA_DEBUG_PRINT__ 579 579 for( int i = 0; i < count; i++) {
Note: See TracChangeset
for help on using the changeset viewer.