Changeset 4a60488 for src/SymTab

Timestamp:

Sep 27, 2019, 3:35:46 PM (5 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

90ce35aa

Parents:

8e1467d (diff), 849720f (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:

Merged from master taking the lvalue changes to expression and everything before that.

Location:

src/SymTab

Files:

• Demangle.cc (modified) (2 diffs)
• Mangler.cc (modified) (3 diffs)
• Validate.cc (modified) (5 diffs)

src/SymTab/Demangle.cc

@@ -9 +9 @@
 // Author           : Rob Schluntz
 // Created On       : Thu Jul 19 12:52:41 2018
-// Last Modified By : Rob Schluntz
-// Last Modified On : Thu Jul 19 12:54:35 2018
-// Update Count     : 2
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Jul 30 13:46:33 2019
+// Update Count     : 3
 //
 
@@ -313 +313 @@
                         typeString = "_Atomic " + typeString;
                 } // if
-                if ( type->get_lvalue() ) {
-                        // when not generating C code, print lvalue for debugging.
-                        typeString = "lvalue " + typeString;
-                }
         }
 }

src/SymTab/Mangler.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 21:40:29 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Sep 25 15:49:26 2017
-// Update Count     : 23
+// Last Modified On : Tue Jul 30 13:46:10 2019
+// Update Count     : 26
 //
 #include "Mangler.h"
@@ -377 +377 @@
                                         mangleName << Encoding::qualifiers.at(Type::Mutex);
                                 } // if
-                                if ( type->get_lvalue() ) {
-                                        // mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues
-                                        mangleName << Encoding::qualifiers.at(Type::Lvalue);
-                                }
-
                                 if ( inFunctionType ) {
                                         // turn off inFunctionType so that types can be differentiated for nested qualifiers
@@ -724 +719 @@
                                 mangleName << Encoding::qualifiers.at(Type::Mutex);
                         } // if
-                        if ( type->is_lvalue() ) {
-                                // mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues
-                                mangleName << Encoding::qualifiers.at(Type::Lvalue);
-                        }
-
                         if ( inFunctionType ) {
                                 // turn off inFunctionType so that types can be differentiated for nested qualifiers

src/SymTab/Validate.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:50:04 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Aug 28 13:47:23 2017
-// Update Count     : 359
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Aug  7 6:42:00 2019
+// Update Count     : 360
 //
 
@@ -81 +81 @@
 #include "SynTree/Label.h"             // for operator==, Label
 #include "SynTree/Mutator.h"           // for Mutator
+#include "SynTree/TopLvalue.h"         // for assertTopLvalue, clearInnerLvalue
 #include "SynTree/Type.h"              // for Type, TypeInstType, EnumInstType
 #include "SynTree/TypeSubstitution.h"  // for TypeSubstitution
@@ -308 +309 @@
                 PassVisitor<FixQualifiedTypes> fixQual;
 
+                assertTopLvalue( translationUnit );
                 {
                         Stats::Heap::newPass("validate-A");
@@ -316 +318 @@
                         acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist; before LinkReferenceToTypes_old because it is an indexer and needs correct types for mangling
                 }
+                assertTopLvalue( translationUnit );
                 {
                         Stats::Heap::newPass("validate-B");
                         Stats::Time::BlockGuard guard("validate-B");
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Link Reference To Types", [&]() {
                                 acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
                         });
+                        clearInnerLvalue( translationUnit );
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Fix Qualified Types", [&]() {
                                 mutateAll( translationUnit, fixQual ); // must happen after LinkReferenceToTypes_old, because aggregate members are accessed
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Hoist Structs", [&]() {
                                 HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Eliminate Typedefs", [&]() {
                                 EliminateTypedef::eliminateTypedef( translationUnit ); //
                         });
                 }
+                assertTopLvalue( translationUnit );
                 {
                         Stats::Heap::newPass("validate-C");
@@ -340 +349 @@
                         InitTweak::fixReturnStatements( translationUnit ); // must happen before autogen
                 }
+                assertTopLvalue( translationUnit );
                 {
                         Stats::Heap::newPass("validate-D");
                         Stats::Time::BlockGuard guard("validate-D");
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Apply Concurrent Keywords", [&]() {
                                 Concurrency::applyKeywords( translationUnit );
                         });
+                        clearInnerLvalue( translationUnit );
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Forall Pointer Decay", [&]() {
                                 acceptAll( translationUnit, fpd ); // must happen before autogenerateRoutines, after Concurrency::applyKeywords because uniqueIds must be set on declaration before resolution
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Hoist Control Declarations", [&]() {
                                 ControlStruct::hoistControlDecls( translationUnit );  // hoist initialization out of for statements; must happen before autogenerateRoutines
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Generate Autogen routines", [&]() {
                                 autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecay_old
                         });
-                }
+                        clearInnerLvalue( translationUnit );
+                }
+                assertTopLvalue( translationUnit );
                 {
                         Stats::Heap::newPass("validate-E");
                         Stats::Time::BlockGuard guard("validate-E");
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Implement Mutex Func", [&]() {
                                 Concurrency::implementMutexFuncs( translationUnit );
                         });
+                        clearInnerLvalue( translationUnit );
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Implement Thread Start", [&]() {
                                 Concurrency::implementThreadStarter( translationUnit );
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Compound Literal", [&]() {
                                 mutateAll( translationUnit, compoundliteral );
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Resolve With Expressions", [&]() {
                                 ResolvExpr::resolveWithExprs( translationUnit ); // must happen before FixObjectType because user-code is resolved and may contain with variables
                         });
-                }
+                        clearInnerLvalue( translationUnit );
+                }
+                assertTopLvalue( translationUnit );
                 {
                         Stats::Heap::newPass("validate-F");
                         Stats::Time::BlockGuard guard("validate-F");
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Fix Object Type", [&]() {
                                 FixObjectType::fix( translationUnit );
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Array Length", [&]() {
                                 ArrayLength::computeLength( translationUnit );
                         });
+                        clearInnerLvalue( translationUnit );
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Find Special Declarations", [&]() {
                                 Validate::findSpecialDecls( translationUnit );
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Fix Label Address", [&]() {
                                 mutateAll( translationUnit, labelAddrFixer );
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Handle Attributes", [&]() {
                                 Validate::handleAttributes( translationUnit );
                         });
                 }
+                assertTopLvalue( translationUnit );
         }