Changeset 8bf784a

Timestamp:

Dec 21, 2016, 2:54:31 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

e33f321

Parents:

6d4d1a6

Message:

name mangling for ttype, fix SynTree? operator<< to work with nullptr, add isTtype check, ttype variables are automatically "sized"

Location:

src

Files:

• GenPoly/Box.cc (modified) (1 diff)
• InitTweak/FixInit.cc (modified) (2 diffs)
• SymTab/Mangler.cc (modified) (4 diffs)
• SynTree/Declaration.cc (modified) (1 diff)
• SynTree/Expression.cc (modified) (1 diff)
• SynTree/FunctionType.cc (modified) (3 diffs)
• SynTree/Statement.cc (modified) (1 diff)
• SynTree/Type.cc (modified) (1 diff)
• SynTree/Type.h (modified) (1 diff)
• SynTree/TypeDecl.cc (modified) (2 diffs)
• Tuples/TupleExpansion.cc (modified) (1 diff)
• Tuples/Tuples.h (modified) (1 diff)

src/GenPoly/Box.cc

@@ -686 +686 @@
                         for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
                                 TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
-                                assert(paramType && "Aggregate parameters should be type expressions");
+                                assertf(paramType, "Aggregate parameters should be type expressions");
                                 paramType->set_type( replaceWithConcrete( appExpr, paramType->get_type(), false ) );
                         }

src/InitTweak/FixInit.cc

@@ -38 +38 @@
 #include "SynTree/AddStmtVisitor.h"
 #include "CodeGen/GenType.h"  // for warning/error messages
+#include "Tuples/Tuples.h"
 
 bool ctordtorp = false; // print all debug
@@ -392 +393 @@
 
                 bool ResolveCopyCtors::skipCopyConstruct( Type * type ) {
-                        return dynamic_cast< VarArgsType * >( type ) || GenPoly::getFunctionType( type );
+                        return dynamic_cast< VarArgsType * >( type ) || GenPoly::getFunctionType( type ) || Tuples::isTtype( type );
                 }
 

src/SymTab/Mangler.cc

@@ -214 +214 @@
                                 mangleName << "f";
                                 break;
+                                case TypeDecl::Ttype:
+                                mangleName << "tVARGS";
+                                break;
+                                default:
+                                assert( false );
                         } // switch
                         mangleName << numStream.str();
@@ -256 +261 @@
                 if ( ! type->get_forall().empty() ) {
                         std::list< std::string > assertionNames;
-                        int tcount = 0, dcount = 0, fcount = 0;
+                        int tcount = 0, dcount = 0, fcount = 0, vcount = 0;
                         mangleName << "A";
                         for ( Type::ForallList::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
@@ -269 +274 @@
                                         fcount++;
                                         break;
+                                  case TypeDecl::Ttype:
+                                        vcount++;
+                                        break;
+                                  default:
+                                        assert( false );
                                 } // switch
                                 varNums[ (*i )->get_name() ] = std::pair< int, int >( nextVarNum++, (int )(*i )->get_kind() );
@@ -280 +290 @@
                                 } // for
                         } // for
-                        mangleName << tcount << "_" << dcount << "_" << fcount << "_";
+                        mangleName << tcount << "_" << dcount << "_" << fcount << "_" << vcount << "_";
                         std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
                         mangleName << "_";

src/SynTree/Declaration.cc

@@ -57 +57 @@
 
 std::ostream & operator<<( std::ostream & out, const Declaration * decl ) {
-        decl->print( out );
+        if ( decl ){
+                decl->print( out );
+        } else {
+                out << "nullptr";
+        }
         return out;
 }

src/SynTree/Expression.cc

@@ -672 +672 @@
 
 std::ostream & operator<<( std::ostream & out, const Expression * expr ) {
-        expr->print( out );
+        if ( expr ) {
+                expr->print( out );
+        } else {
+                out << "nullptr";
+        }
         return out;
 }

src/SynTree/FunctionType.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// FunctionType.cc -- 
+// FunctionType.cc --
 //
 // Author           : Richard C. Bilson
@@ -19 +19 @@
 #include "Declaration.h"
 #include "Common/utility.h"
+#include "Tuples/Tuples.h"
 
 FunctionType::FunctionType( const Type::Qualifiers &tq, bool isVarArgs ) : Type( tq ), isVarArgs( isVarArgs ) {
@@ -31 +32 @@
         deleteAll( returnVals );
         deleteAll( parameters );
+}
+
+namespace {
+        bool containsTtype( const std::list<DeclarationWithType * > & l ) {
+                if ( ! l.empty() ) {
+                        return Tuples::isTtype( l.back()->get_type() );
+                }
+                return false;
+        }
+}
+
+bool FunctionType::isTtype() const {
+        return containsTtype( returnVals ) || containsTtype( parameters );
 }
 

src/SynTree/Statement.cc

@@ -388 +388 @@
 
 std::ostream & operator<<( std::ostream & out, const Statement * statement ) {
-        statement->print( out );
+        if ( statement ) {
+                statement->print( out );
+        } else {
+                out << "nullptr";
+        }
         return out;
 }

src/SynTree/Type.cc

@@ -85 +85 @@
 
 std::ostream & operator<<( std::ostream & out, const Type * type ) {
-        type->print( out );
+        if ( type ) {
+                type->print( out );
+        } else {
+                out << "nullptr";
+        }
         return out;
 }

src/SynTree/Type.h

@@ -204 +204 @@
         std::list<DeclarationWithType*> & get_returnVals() { return returnVals; }
         std::list<DeclarationWithType*> & get_parameters() { return parameters; }
-        bool get_isVarArgs() { return isVarArgs; }
+        bool get_isVarArgs() const { return isVarArgs; }
         void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
+
+        bool isTtype() const;
 
         virtual FunctionType *clone() const { return new FunctionType( *this ); }

src/SynTree/TypeDecl.cc

@@ -18 +18 @@
 #include "Common/utility.h"
 
-TypeDecl::TypeDecl( const std::string &name, DeclarationNode::StorageClass sc, Type *type, Kind kind ) : Parent( name, sc, type ), kind( kind ), sized( kind == Any ) {
+TypeDecl::TypeDecl( const std::string &name, DeclarationNode::StorageClass sc, Type *type, Kind kind ) : Parent( name, sc, type ), kind( kind ), sized( kind == Any || kind == Ttype ) {
 }
 
@@ -25 +25 @@
 
 std::string TypeDecl::typeString() const {
-        static const char *kindNames[] = { "type", "incomplete type", "function type" };
+        static const char *kindNames[] = { "type", "incomplete type", "function type", "tuple type" };
         return kindNames[ kind ];
 }

src/Tuples/TupleExpansion.cc

@@ -318 +318 @@
         }
 
+        TypeInstType * isTtype( Type * type ) {
+                if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( type ) ) {
+                        if ( inst->get_baseType()->get_kind() == TypeDecl::Ttype ) {
+                                return inst;
+                        }
+                }
+                return nullptr;
+        }
+
         namespace {
                 /// determines if impurity (read: side-effects) may exist in a piece of code. Currently gives a very crude approximation, wherein any function call expression means the code may be impure

src/Tuples/Tuples.h

@@ -42 +42 @@
         Type * makeTupleType( const std::list< Expression * > & exprs );
 
+        /// returns a TypeInstType if `type` is a ttype, nullptr otherwise
+        TypeInstType * isTtype( Type * type );
+
         /// returns true if the expression may contain side-effects.
         bool maybeImpure( Expression * expr );