Changeset 3b9c674

Timestamp:

Feb 18, 2020, 12:10:08 PM (4 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

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

Children:

fca3bf8

Parents:

921cd82

Message:

Expections now supported in position independent code.

Files:

• libcfa/src/exception.c (modified) (4 diffs)
• src/ResolvExpr/Resolver.cc (modified) (3 diffs)
• tests/exceptions/.expect/except-0.txt (added)
• tests/exceptions/.expect/except-1.txt (added)
• tests/exceptions/.expect/except-2.txt (added)
• tests/exceptions/.expect/except-3.txt (added)
• tests/exceptions/except-0.cfa (modified) (2 diffs)
• tests/exceptions/except-2.cfa (modified) (3 diffs)

libcfa/src/exception.c

@@ -248 +248 @@
 }
 
-#if defined(PIC)
-#warning Exceptions not yet supported when using Position-Independent Code
-__attribute__((noinline))
-void __cfaabi_ehm__try_terminate(void (*try_block)(),
-                void (*catch_block)(int index, exception_t * except),
-                __attribute__((unused)) int (*match_block)(exception_t * except)) {
-        abort();
-}
-#else // PIC
+#pragma GCC push_options
+#pragma GCC optimize("O0")
+
 // This is our personality routine. For every stack frame annotated with
 // ".cfi_personality 0x3,__gcfa_personality_v0" this function will be called twice when unwinding.
@@ -431 +425 @@
 
         // Setup the personality routine and exception table.
+#ifdef __PIC__
+        asm volatile (".cfi_personality 0x9b,CFA.ref.__gcfa_personality_v0");
+        asm volatile (".cfi_lsda 0x1b, .LLSDACFA2");
+#else
         asm volatile (".cfi_personality 0x3,__gcfa_personality_v0");
         asm volatile (".cfi_lsda 0x3, .LLSDACFA2");
+#endif
 
         // Label which defines the start of the area for which the handler is setup.
@@ -464 +463 @@
 // have a single call to the try routine.
 
+#ifdef __PIC__
+#if defined( __i386 ) || defined( __x86_64 )
+asm (
+        // HEADER
+        ".LFECFA1:\n"
+        "       .globl  __gcfa_personality_v0\n"
+        "       .section        .gcc_except_table,\"a\",@progbits\n"
+        // TABLE HEADER (important field is the BODY length at the end)
+        ".LLSDACFA2:\n"
+        "       .byte   0xff\n"
+        "       .byte   0xff\n"
+        "       .byte   0x1\n"
+        "       .uleb128 .LLSDACSECFA2-.LLSDACSBCFA2\n"
+        // BODY (language specific data)
+        // This uses language specific data and can be modified arbitrarily
+        // We use handled area offset, handled area length,
+        // handler landing pad offset and 1 (action code, gcc seems to use 0).
+        ".LLSDACSBCFA2:\n"
+        "       .uleb128 .TRYSTART-__cfaabi_ehm__try_terminate\n"
+        "       .uleb128 .TRYEND-.TRYSTART\n"
+        "       .uleb128 .CATCH-__cfaabi_ehm__try_terminate\n"
+        "       .uleb128 1\n"
+        ".LLSDACSECFA2:\n"
+        // TABLE FOOTER
+        "       .text\n"
+        "       .size   __cfaabi_ehm__try_terminate, .-__cfaabi_ehm__try_terminate\n"
+);
+
+// Somehow this piece of helps with the resolution of debug symbols.
+__attribute__((unused)) static const int dummy = 0;
+
+asm (
+        // Add a hidden symbol which points at the function.
+        "       .hidden CFA.ref.__gcfa_personality_v0\n"
+        "       .weak   CFA.ref.__gcfa_personality_v0\n"
+        // No clue what this does specifically
+        "       .section        .data.rel.local.CFA.ref.__gcfa_personality_v0,\"awG\",@progbits,CFA.ref.__gcfa_personality_v0,comdat\n"
+        "       .align 8\n"
+        "       .type CFA.ref.__gcfa_personality_v0, @object\n"
+        "       .size CFA.ref.__gcfa_personality_v0, 8\n"
+        "CFA.ref.__gcfa_personality_v0:\n"
+#if defined( __x86_64 )
+        "       .quad __gcfa_personality_v0\n"
+#else // then __i386
+        "   .long __gcfa_personality_v0\n"
+#endif
+);
+#else
+#error Exception Handling: unknown architecture for position independent code.
+#endif // __i386 || __x86_64
+#else // __PIC__
 #if defined( __i386 ) || defined( __x86_64 )
 asm (
@@ -491 +541 @@
         "       .size   __cfaabi_ehm__try_terminate, .-__cfaabi_ehm__try_terminate\n"
         "       .ident  \"GCC: (Ubuntu 6.2.0-3ubuntu11~16.04) 6.2.0 20160901\"\n"
-//      "       .section        .note.GNU-stack,\"x\",@progbits\n"
+        "       .section        .note.GNU-stack,\"x\",@progbits\n"
 );
+#else
+#error Exception Handling: unknown architecture for position dependent code.
 #endif // __i386 || __x86_64
-#endif // PIC
+#endif // __PIC__
+
+#pragma GCC pop_options

src/ResolvExpr/Resolver.cc

@@ -84 +84 @@
                 void previsit( ThrowStmt * throwStmt );
                 void previsit( CatchStmt * catchStmt );
+                void postvisit( CatchStmt * catchStmt );
                 void previsit( WaitForStmt * stmt );
 
@@ -567 +568 @@
 
         void Resolver_old::previsit( CatchStmt * catchStmt ) {
+                // Until we are very sure this invarent (ifs that move between passes have thenPart)
+                // holds, check it. This allows a check for when to decode the mangling.
+                if ( IfStmt * ifStmt = dynamic_cast<IfStmt *>( catchStmt->body ) ) {
+                        assert( ifStmt->thenPart );
+                }
+                // Encode the catchStmt so the condition can see the declaration.
                 if ( catchStmt->cond ) {
-                        findSingleExpression( catchStmt->cond, new BasicType( noQualifiers, BasicType::Bool ), indexer );
+                        IfStmt * ifStmt = new IfStmt( catchStmt->cond, nullptr, catchStmt->body );
+                        catchStmt->cond = nullptr;
+                        catchStmt->body = ifStmt;
+                }
+        }
+
+        void Resolver_old::postvisit( CatchStmt * catchStmt ) {
+                // Decode the catchStmt so everything is stored properly.
+                IfStmt * ifStmt = dynamic_cast<IfStmt *>( catchStmt->body );
+                if ( nullptr != ifStmt && nullptr == ifStmt->thenPart ) {
+                        assert( ifStmt->condition );
+                        assert( ifStmt->elsePart );
+                        catchStmt->cond = ifStmt->condition;
+                        catchStmt->body = ifStmt->elsePart;
+                        ifStmt->condition = nullptr;
+                        ifStmt->elsePart = nullptr;
+                        delete ifStmt;
                 }
         }
@@ -1466 +1489 @@
 
         const ast::CatchStmt * Resolver_new::previsit( const ast::CatchStmt * catchStmt ) {
+                // TODO: This will need a fix for the decl/cond scoping problem.
                 if ( catchStmt->cond ) {
                         ast::ptr< ast::Type > boolType = new ast::BasicType{ ast::BasicType::Bool };

tests/exceptions/except-0.cfa

@@ -19 +19 @@
 };
 
-void ?{}(signal_exit * this, const char * area) {
-        this->area = area;
-}
-
-void ^?{}(signal_exit * this) {
-        printf("Exiting: %s\n", this->area);
+void ?{}(signal_exit & this, const char * area) {
+        this.area = area;
+}
+
+void ^?{}(signal_exit & this) {
+        printf("Exiting: %s\n", this.area);
 //      sout | "Exiting:" | this->area;
 }
@@ -242 +242 @@
 
         // Uncaught termination test.
+        /* Removed due to non-deterministic output.
         printf("Throw uncaught.\n");
         yang z;
         terminate(&z);
-}
+        */
+}

tests/exceptions/except-2.cfa

@@ -12 +12 @@
         struct TABLE(BASE_EXCEPT) const * parent;
         size_t size;
-        void (*copy)(num_error *this, num_error * other);
-        void (*free)(num_error *this);
+        void (*copy)(num_error &this, num_error & other);
+        void (*free)(num_error &this);
         const char * (*msg)(num_error *this);
         int (*code)(num_error *this);
@@ -28 +28 @@
         if ( ! this->msg ) {
                 static const char * base = "Num Error with code: X";
-                this->msg = malloc(22);
+                this->msg = (char *)malloc(22);
                 for (int i = 0 ; (this->msg[i] = base[i]) ; ++i);
         }
@@ -34 +34 @@
         return this->msg;
 }
-void ?{}(num_error * this, int num) {
-        this->virtual_table = &INSTANCE(num_error);
-        this->msg = 0;
-        this->num = num;
+void ?{}(num_error & this, int num) {
+        this.virtual_table = &INSTANCE(num_error);
+        this.msg = 0;
+        this.num = num;
 }
-void ?{}(num_error * this, num_error * other) {
-        this->virtual_table = other->virtual_table;
-        this->msg = 0;
-        this->num = other->num;
+void ?{}(num_error & this, num_error & other) {
+        this.virtual_table = other.virtual_table;
+        this.msg = 0;
+        this.num = other.num;
 }
-void ^?{}(num_error * this) {
-        if( this->msg ) free( this->msg );
+void ^?{}(num_error & this) {
+        if( this.msg ) free( this.msg );
 }
 int num_error_code( num_error * this ) {