Changeset 4702a2c


Ignore:
Timestamp:
Nov 25, 2020, 3:14:30 AM (10 months ago)
Author:
Fangren Yu <f37yu@…>
Branches:
arm-eh, jacob/cs343-translation, master, new-ast-unique-expr
Children:
0292aa4, 1389810
Parents:
e5c3811 (diff), bb87dd0 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:
10 added
6 edited
9 moved

Legend:

Unmodified
Added
Removed
  • libcfa/src/concurrency/kernel.cfa

    re5c3811 r4702a2c  
    379379
    380380        ready_schedule_lock();
    381                 push( thrd->curr_cluster, thrd );
    382                 __wake_one(thrd->curr_cluster);
     381                // Dereference the thread now because once we push it, there is not guaranteed it's still valid.
     382                struct cluster * cl = thrd->curr_cluster;
     383
     384                // push the thread to the cluster ready-queue
     385                push( cl, thrd );
     386
     387                // variable thrd is no longer safe to use
     388
     389                // wake the cluster using the save variable.
     390                __wake_one( cl );
    383391        ready_schedule_unlock();
    384392
  • src/AST/Expr.hpp

    re5c3811 r4702a2c  
    299299};
    300300
    301 /// Whether a cast existed in the program source or not
     301/// Inidicates whether the cast is introduced by the CFA type system.
     302/// GeneratedCast for casts that the resolver introduces to force a return type
     303/// ExplicitCast for casts from user code
     304/// ExplicitCast for casts from desugaring advanced CFA features into simpler CFA
     305/// example
     306///   int * p;     // declaration
     307///   (float *) p; // use, with subject cast
     308/// subject cast being GeneratedCast means we are considering an interpretation with a type mismatch
     309/// subject cast being ExplicitCast means someone in charge wants it that way
    302310enum GeneratedFlag { ExplicitCast, GeneratedCast };
    303311
  • src/InitTweak/FixInit.h

    re5c3811 r4702a2c  
    2121class Declaration;
    2222namespace ast {
    23         class TranslationUnit;
     23        struct TranslationUnit;
    2424}
    2525
  • src/Parser/ParseNode.h

    re5c3811 r4702a2c  
    3737class Attribute;
    3838class Declaration;
    39 class DeclarationNode;
     39struct DeclarationNode;
    4040class DeclarationWithType;
    4141class ExpressionNode;
    4242class Initializer;
    43 class StatementNode;
     43struct StatementNode;
    4444
    4545//##############################################################################
  • src/ResolvExpr/CandidateFinder.cpp

    re5c3811 r4702a2c  
    11011101                                // unification run for side-effects
    11021102                                unify( toType, cand->expr->result, cand->env, need, have, open, symtab );
    1103                                 Cost thisCost = castCost( cand->expr->result, toType, cand->expr->get_lvalue(),
    1104                                                 symtab, cand->env );
     1103                                Cost thisCost =
     1104                                        (castExpr->isGenerated == ast::GeneratedFlag::GeneratedCast)
     1105                            ? conversionCost( cand->expr->result, toType, cand->expr->get_lvalue(), symtab, cand->env )
     1106                            : castCost( cand->expr->result, toType, cand->expr->get_lvalue(), symtab, cand->env );
     1107
    11051108                                PRINT(
    11061109                                        std::cerr << "working on cast with result: " << toType << std::endl;
     
    15911594
    15921595                                        // unification run for side-effects
    1593                                         unify( toType, cand->expr->result, env, need, have, open, symtab );
     1596                                        bool canUnify = unify( toType, cand->expr->result, env, need, have, open, symtab );
     1597                    (void) canUnify;
    15941598                                        Cost thisCost = computeConversionCost( cand->expr->result, toType, cand->expr->get_lvalue(),
     1599                                                symtab, env );
     1600                                        PRINT(
     1601                                                Cost legacyCost = castCost( cand->expr->result, toType, cand->expr->get_lvalue(),
    15951602                                                        symtab, env );
    1596 
     1603                                                std::cerr << "Considering initialization:";
     1604                                                std::cerr << std::endl << "  FROM: " << cand->expr->result << std::endl;
     1605                                                std::cerr << std::endl << "  TO: "   << toType             << std::endl;
     1606                                                std::cerr << std::endl << "  Unification " << (canUnify ? "succeeded" : "failed");
     1607                                                std::cerr << std::endl << "  Legacy cost " << legacyCost;
     1608                                                std::cerr << std::endl << "  New cost " << thisCost;
     1609                                                std::cerr << std::endl;
     1610                                        )
    15971611                                        if ( thisCost != Cost::infinity ) {
    15981612                                                // count one safe conversion for each value that is thrown away
  • src/ResolvExpr/Resolver.h

    re5c3811 r4702a2c  
    3535        class StmtExpr;
    3636        class SymbolTable;
    37         class TranslationUnit;
     37        struct TranslationUnit;
    3838        class Type;
    3939        class TypeEnvironment;
     
    6363        ast::ptr< ast::Expr > resolveInVoidContext(
    6464                const ast::Expr * expr, const ast::SymbolTable & symtab, ast::TypeEnvironment & env );
    65         /// Resolve `untyped` to the single expression whose candidate is the best match for the 
     65        /// Resolve `untyped` to the single expression whose candidate is the best match for the
    6666        /// given type.
    6767        ast::ptr< ast::Expr > findSingleExpression(
Note: See TracChangeset for help on using the changeset viewer.