Changeset 8da7421f

Timestamp:

Oct 20, 2020, 12:35:25 PM (4 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

3aec25f

Parents:

5afb49a (diff), d5631b3 (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:

• src/AST/Expr.cpp (modified) (2 diffs)
• src/AST/Expr.hpp (modified) (2 diffs)
• src/InitTweak/FixGlobalInit.cc (modified) (1 diff)
• src/InitTweak/FixInit.cc (modified) (1 diff)
• src/InitTweak/InitTweak.cc (modified) (1 diff)
• src/InitTweak/InitTweak.h (modified) (1 diff)
• src/SynTree/Expression.h (modified) (2 diffs)
• tests/.expect/const-init.txt (modified) (1 diff)
• tests/complex.cfa (modified) (1 diff)
• tests/const-init.cfa (modified) (2 diffs)
• tests/exceptions/cancel/coroutine.cfa (modified) (1 diff)
• tests/exceptions/conditional.cfa (modified) (1 diff)
• tests/exceptions/except-io.hfa (modified) (1 diff)
• tests/exceptions/trash.cfa (modified) (1 diff)
• tests/global-monomorph.cfa (modified) (1 diff)
• tests/poly-d-cycle.cfa (modified) (1 diff)
• tests/poly-o-cycle.cfa (modified) (1 diff)

src/AST/Expr.cpp

@@ -102 +102 @@
         }
         return ret;
+}
+
+// --- VariableExpr
+
+VariableExpr::VariableExpr( const CodeLocation & loc )
+: Expr( loc ), var( nullptr ) {}
+
+VariableExpr::VariableExpr( const CodeLocation & loc, const DeclWithType * v )
+: Expr( loc ), var( v ) {
+        assert( var );
+        assert( var->get_type() );
+        result = shallowCopy( var->get_type() );
+}
+
+bool VariableExpr::get_lvalue() const {
+        // It isn't always an lvalue, but it is never an rvalue.
+        return true;
+}
+
+VariableExpr * VariableExpr::functionPointer(
+                const CodeLocation & loc, const FunctionDecl * decl ) {
+        // wrap usually-determined result type in a pointer
+        VariableExpr * funcExpr = new VariableExpr{ loc, decl };
+        funcExpr->result = new PointerType{ funcExpr->result };
+        return funcExpr;
 }
 
@@ -238 +263 @@
 }
 
-// --- VariableExpr
-
-VariableExpr::VariableExpr( const CodeLocation & loc )
-: Expr( loc ), var( nullptr ) {}
-
-VariableExpr::VariableExpr( const CodeLocation & loc, const DeclWithType * v )
-: Expr( loc ), var( v ) {
-        assert( var );
-        assert( var->get_type() );
-        result = shallowCopy( var->get_type() );
-}
-
-bool VariableExpr::get_lvalue() const {
-        // It isn't always an lvalue, but it is never an rvalue.
-        return true;
-}
-
-VariableExpr * VariableExpr::functionPointer(
-                const CodeLocation & loc, const FunctionDecl * decl ) {
-        // wrap usually-determined result type in a pointer
-        VariableExpr * funcExpr = new VariableExpr{ loc, decl };
-        funcExpr->result = new PointerType{ funcExpr->result };
-        return funcExpr;
-}
-
 // --- ConstantExpr
 

src/AST/Expr.hpp

@@ -250 +250 @@
 };
 
+/// A reference to a named variable.
+class VariableExpr final : public Expr {
+public:
+        readonly<DeclWithType> var;
+
+        VariableExpr( const CodeLocation & loc );
+        VariableExpr( const CodeLocation & loc, const DeclWithType * v );
+
+        bool get_lvalue() const final;
+
+        /// generates a function pointer for a given function
+        static VariableExpr * functionPointer( const CodeLocation & loc, const FunctionDecl * decl );
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        VariableExpr * clone() const override { return new VariableExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
 /// Address-of expression `&e`
 class AddressExpr final : public Expr {
@@ -390 +409 @@
         friend class ::ConverterOldToNew;
         friend class ::ConverterNewToOld;
-};
-
-/// A reference to a named variable.
-class VariableExpr final : public Expr {
-public:
-        readonly<DeclWithType> var;
-
-        VariableExpr( const CodeLocation & loc );
-        VariableExpr( const CodeLocation & loc, const DeclWithType * v );
-
-        bool get_lvalue() const final;
-
-        /// generates a function pointer for a given function
-        static VariableExpr * functionPointer( const CodeLocation & loc, const FunctionDecl * decl );
-
-        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        VariableExpr * clone() const override { return new VariableExpr{ *this }; }
-        MUTATE_FRIEND
 };
 

src/InitTweak/FixGlobalInit.cc

@@ -112 +112 @@
                         } // if
                         if ( Statement * ctor = ctorInit->ctor ) {
-                                // Translation 1: Add this attribute on the global declaration:
-                                //    __attribute__((section (".data#")))
-                                // which makes gcc put the global in the data section,
-                                // so that the global is writeable (via a const cast) in the init function.
-                                // The trailing # is an injected assembly comment, to suppress the "a" in
-                                //    .section .data,"a"
-                                //    .section .data#,"a"
-                                // to avoid assembler warning "ignoring changed section attributes for .data"
-                                Type *strLitT = new PointerType( Type::Qualifiers( ),
-                                        new BasicType( Type::Qualifiers( ), BasicType::Char ) );
-                                std::list< Expression * > attr_params;
-                                attr_params.push_back( 
-                                        new ConstantExpr( Constant( strLitT, "\".data#\"", std::nullopt ) ) );
-                                objDecl->attributes.push_back(new Attribute("section", attr_params));
-                                // Translation 2: Move the initizliation off the global declaration,
-                                // into the startup function.
+                                addDataSectonAttribute( objDecl );
                                 initStatements.push_back( ctor );
                                 objDecl->init = nullptr;

src/InitTweak/FixInit.cc

@@ -802 +802 @@
                                 if ( Statement * ctor = ctorInit->get_ctor() ) {
                                         if ( objDecl->get_storageClasses().is_static ) {
+
+                                                // The ojbect needs to go in the data section, regardless of dtor complexity below.
+                                                // The attribute works, and is meant to apply, both for leaving the static local alone,
+                                                // and for hoisting it out as a static global.
+                                                addDataSectonAttribute( objDecl );
+
                                                 // originally wanted to take advantage of gcc nested functions, but
                                                 // we get memory errors with this approach. To remedy this, the static

src/InitTweak/InitTweak.cc

@@ -1055 +1055 @@
                 return isCopyFunction( decl, "?{}" );
         }
+
+        void addDataSectonAttribute( ObjectDecl * objDecl ) {
+                Type *strLitT = new PointerType( Type::Qualifiers( ),
+                        new BasicType( Type::Qualifiers( ), BasicType::Char ) );
+                std::list< Expression * > attr_params;
+                attr_params.push_back( 
+                        new ConstantExpr( Constant( strLitT, "\".data#\"", std::nullopt ) ) );
+                objDecl->attributes.push_back(new Attribute("section", attr_params));
+        }
+
 }

src/InitTweak/InitTweak.h

@@ -103 +103 @@
         bool isConstExpr( Initializer * init );
 
+        /// Modifies objDecl to have:
+        ///    __attribute__((section (".data#")))
+        /// which makes gcc put the declared variable in the data section,
+        /// which is helpful for global constants on newer gcc versions,
+        /// so that CFA's generated initialization won't segfault when writing it via a const cast.
+        /// The trailing # is an injected assembly comment, to suppress the "a" in
+        ///    .section .data,"a"
+        ///    .section .data#,"a"
+        /// to avoid assembler warning "ignoring changed section attributes for .data"
+        void addDataSectonAttribute( ObjectDecl * objDecl );
+
         class InitExpander_old {
         public:

src/SynTree/Expression.h

@@ -163 +163 @@
 };
 
+/// VariableExpr represents an expression that simply refers to the value of a named variable.
+/// Does not take ownership of var.
+class VariableExpr : public Expression {
+  public:
+        DeclarationWithType * var;
+
+        VariableExpr();
+        VariableExpr( DeclarationWithType * var );
+        VariableExpr( const VariableExpr & other );
+        virtual ~VariableExpr();
+
+        bool get_lvalue() const final;
+
+        DeclarationWithType * get_var() const { return var; }
+        void set_var( DeclarationWithType * newValue ) { var = newValue; }
+
+        static VariableExpr * functionPointer( FunctionDecl * decl );
+
+        virtual VariableExpr * clone() const override { return new VariableExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+};
+
 // The following classes are used to represent expression types that cannot be converted into
 // function-call format.
@@ -329 +354 @@
 };
 
-/// VariableExpr represents an expression that simply refers to the value of a named variable.
-/// Does not take ownership of var.
-class VariableExpr : public Expression {
-  public:
-        DeclarationWithType * var;
-
-        VariableExpr();
-        VariableExpr( DeclarationWithType * var );
-        VariableExpr( const VariableExpr & other );
-        virtual ~VariableExpr();
-
-        bool get_lvalue() const final;
-
-        DeclarationWithType * get_var() const { return var; }
-        void set_var( DeclarationWithType * newValue ) { var = newValue; }
-
-        static VariableExpr * functionPointer( FunctionDecl * decl );
-
-        virtual VariableExpr * clone() const override { return new VariableExpr( * this ); }
-        virtual void accept( Visitor & v ) override { v.visit( this ); }
-        virtual void accept( Visitor & v ) const override { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
-};
-
 /// ConstantExpr represents an expression that simply refers to the value of a constant
 class ConstantExpr : public Expression {

tests/.expect/const-init.txt

@@ -1 @@
-done
+almost done
+dtor

tests/complex.cfa

@@ -14 +14 @@
 //
 
-#include <stdio.h>
 #include <complex.h>
 #ifdef __CFA__

tests/const-init.cfa

@@ -16 +16 @@
 /*
 
-This test shows non-crashing of generated code for constants with interesting initizers.
+These tests show non-crashing of generated code for constants with interesting initializers.
 The potential for these to crash is compiler dependent.
 
 There are two cases:
-1. static constants in one compilation unit (tested here)
+1. static constants in one compilation unit (tested here, in a few sub-cases)
 2. extern constants across compilation units (tested by libcfa being loadable, specifically
-   the constant declarations in libcfa/src/limits.cfa, which almost every test exercises,
+   the constant definitions in libcfa/src/limits.cfa, which almost every test exercises,
    including "hello;" but notably, the "limits" test does not exercise it because that test
    is compile-only)
@@ -37 +37 @@
 GCC-10 on Ubuntu 20.04    Has crashed      Has crashed
 
-For this test case to fail, with most other tests passing, would be a situation only ever
+For this test to fail, with most other tests passing, would be a situation only ever
 observed with GCC-8.
 
 */
 
+// initailized by generated function, called before main
 static const char foo = -1;
 
+struct thing{};
+void ^?{}( thing & ) { printf("dtor\n"); }
+
 int main() {
-    printf("done\n");
+    // foo is already initialized
+
+    // no dtor => stays a (static) local, initialized here
+    static const char bar = -1;
+
+    // has dtor => becomes a global, ctor called here, dtor called at exit
+    static const thing it;
+
+    printf("almost done\n");
 }

tests/exceptions/cancel/coroutine.cfa

@@ -1 +1 @@
 // Try cancelling a coroutine.
 
-#include <stdio.h>
 #include <coroutine.hfa>
 #include <exception.hfa>

tests/exceptions/conditional.cfa

@@ -5 +5 @@
 
 #include <exception.hfa>
-#include <stdio.h>
 
 VTABLE_DECLARATION(num_error)(

tests/exceptions/except-io.hfa

@@ -1 +1 @@
 // Common tools for the exception tests.
-
-#include <stdio.h>
 
 // Echo when a destructor is run and an area/block is left.

tests/exceptions/trash.cfa

@@ -2 +2 @@
 
 #include <exception.hfa>
-#include <stdio.h>
 
 TRIVIAL_EXCEPTION(yin);

tests/global-monomorph.cfa

@@ -1 @@
-// Crea
-
-#include <stdlib.hfa>
-#include <stdio.h>
+// Create monomorphic instances of polymorphic types at global scope.
 
 forall(dtype T)

tests/poly-d-cycle.cfa

@@ -1 +1 @@
 // Check that a cycle of polymorphic dtype structures can be instancated.
-
-#include <stdio.h>
 
 forall(dtype T)

tests/poly-o-cycle.cfa

@@ -1 +1 @@
 // Check that a cycle of polymorphic otype structures can be instancated.
-
-#include <stdio.h>
 
 forall(otype T)