Fixed #507: Improved support for static variables.

Author: andreasfertig

ASTHelpers.cpp

@@ -680,6 +680,12 @@ BinaryOperator* Mul(Expr* lhs, Expr* rhs)
 }
 //-----------------------------------------------------------------------------
 
+BinaryOperator* And(VarDecl* lhs, Expr* rhs)
+{
+    return mkBinaryOperator(mkDeclRefExpr(lhs), rhs, BinaryOperator::Opcode::BO_And, lhs->getType());
+}
+//-----------------------------------------------------------------------------
+
 void StmtsContainer::AddBodyStmts(Stmt* body)
 {
     if(auto* b = dyn_cast_or_null<CompoundStmt>(body)) {

ASTHelpers.h

@@ -54,6 +54,7 @@ CXXBoolLiteralExpr* Bool(bool b);
 CallExpr*           CallDestructor(const VarDecl* fieldDecl);
 CXXNewExpr*         New(ArrayRef<Expr*> placementArgs, const Expr* expr, QualType t);
 BinaryOperator*     Mul(Expr* lhs, Expr* rhs);
+BinaryOperator*     And(VarDecl* lhs, Expr* rhs);
 QualType            Typedef(std::string_view name, QualType underlayingType);
 
 SmallVector<Expr*, 5> ArgsToExprVector(const Expr* expr);

CodeGenerator.cpp

@@ -4594,14 +4594,16 @@ void CodeGenerator::HandleLocalStaticNonTrivialClass(const VarDecl* stmt)
 
     if(threadSafe) {
         innerBodyStmts.AddBodyStmts(Call("__cxa_guard_release"sv, {Ref(compilerGuardVar)}));
+        innerBodyStmts.Add(Comment(
+            StrCat("__cxa_atexit("sv, typeName, "::~"sv, typeName, ", &"sv, internalVarName, ", &__dso_handle);"sv)));
 
         auto* aquireIf = If(Call("__cxa_guard_acquire"sv, {Ref(compilerGuardVar)}), innerBodyStmts);
         bodyStmts.AddBodyStmts(aquireIf);
     } else {
         bodyStmts.AddBodyStmts(allocAndFlagBodyCompound);
     }
 
-    InsertArg(If(Not(compilerGuardVar), bodyStmts));
+    InsertArg(If(Equal(And(compilerGuardVar, Int32(0xff)), Int32(0)), bodyStmts));
 }
 //-----------------------------------------------------------------------------
 

tests/Issue369.expect

@@ -13,7 +13,7 @@ const foo & create()
   static uint64_t __valueGuard;
   alignas(const foo) static char __value[sizeof(const foo)];
 
-  if(!__valueGuard) {
+  if((__valueGuard & 255) == 0) {
     if(__cxa_guard_acquire(&__valueGuard)) {
       try 
       {
@@ -24,6 +24,7 @@ const foo & create()
         throw ;
       }
       __cxa_guard_release(&__valueGuard);
+      /* __cxa_atexit(const foo::~const foo, &__value, &__dso_handle); */
     } 
 
   } 

tests/Issue369_1.expect

@@ -38,7 +38,7 @@ const foo & create()
   static uint64_t __valueGuard;
   alignas(foo) static char __value[sizeof(foo)];
 
-  if(!__valueGuard) {
+  if((__valueGuard & 255) == 0) {
     if(__cxa_guard_acquire(&__valueGuard)) {
       try 
       {
@@ -49,6 +49,7 @@ const foo & create()
         throw ;
       }
       __cxa_guard_release(&__valueGuard);
+      /* __cxa_atexit(foo::~foo, &__value, &__dso_handle); */
     } 
 
   } 

tests/Issue369_2.expect

@@ -38,11 +38,12 @@ const void withNoexcept()
   static uint64_t __valueGuard;
   alignas(foo) static char __value[sizeof(foo)];
 
-  if(!__valueGuard) {
+  if((__valueGuard & 255) == 0) {
     if(__cxa_guard_acquire(&__valueGuard)) {
       new (&__value)foo{std::move(__lambda_4_23.operator()())};
       __valueGuard = true;
       __cxa_guard_release(&__valueGuard);
+      /* __cxa_atexit(foo::~foo, &__value, &__dso_handle); */
     } 
 
   } 
@@ -78,7 +79,7 @@ const void withNoexceptFalse()
   static uint64_t __valueGuard;
   alignas(foo) static char __value[sizeof(foo)];
 
-  if(!__valueGuard) {
+  if((__valueGuard & 255) == 0) {
     if(__cxa_guard_acquire(&__valueGuard)) {
       try 
       {
@@ -89,6 +90,7 @@ const void withNoexceptFalse()
         throw ;
       }
       __cxa_guard_release(&__valueGuard);
+      /* __cxa_atexit(foo::~foo, &__value, &__dso_handle); */
     } 
 
   } 
@@ -124,11 +126,12 @@ const void withNoexceptTrue()
   static uint64_t __valueGuard;
   alignas(foo) static char __value[sizeof(foo)];
 
-  if(!__valueGuard) {
+  if((__valueGuard & 255) == 0) {
     if(__cxa_guard_acquire(&__valueGuard)) {
       new (&__value)foo{std::move(__lambda_12_23.operator()())};
       __valueGuard = true;
       __cxa_guard_release(&__valueGuard);
+      /* __cxa_atexit(foo::~foo, &__value, &__dso_handle); */
     } 
 
   } 
@@ -179,7 +182,7 @@ void viaFunction()
   static uint64_t __fGuard;
   alignas(foo) static char __f[sizeof(foo)];
 
-  if(!__fGuard) {
+  if((__fGuard & 255) == 0) {
     if(__cxa_guard_acquire(&__fGuard)) {
       try 
       {
@@ -190,6 +193,7 @@ void viaFunction()
         throw ;
       }
       __cxa_guard_release(&__fGuard);
+      /* __cxa_atexit(foo::~foo, &__f, &__dso_handle); */
     } 
 
   } 

tests/Issue507.cpp

@@ -0,0 +1,12 @@
+struct example_struct
+{
+	example_struct() { throw; }
+	~example_struct() { }
+};
+
+example_struct& get_example()
+{
+	static example_struct temp;
+	return temp;
+}
+

tests/Issue507.expect

@@ -0,0 +1,40 @@
+#include <new> // for thread-safe static's placement new
+#include <stdint.h> // for uint64_t under Linux/GCC
+
+struct example_struct
+{
+  inline example_struct()
+  {
+    throw ;
+  }
+  
+  inline ~example_struct() noexcept
+  {
+  }
+  
+};
+
+
+example_struct & get_example()
+{
+  static uint64_t __tempGuard;
+  alignas(example_struct) static char __temp[sizeof(example_struct)];
+  
+  if((__tempGuard & 255) == 0) {
+    if(__cxa_guard_acquire(&__tempGuard)) {
+      try 
+      {
+        new (&__temp)example_struct();
+        __tempGuard = true;
+      } catch(...) {
+        __cxa_guard_abort(&__tempGuard);
+        throw ;
+      }
+      __cxa_guard_release(&__tempGuard);
+      /* __cxa_atexit(example_struct::~example_struct, &__temp, &__dso_handle); */
+    } 
+    
+  } 
+  
+  return *reinterpret_cast<example_struct*>(__temp);
+}

tests/StaticHandler4Test.expect

@@ -23,7 +23,7 @@ Sing & Test()
   static uint64_t __sGuard;
   alignas(Sing) static char __s[sizeof(Sing)];
 
-  if(!__sGuard) {
+  if((__sGuard & 255) == 0) {
     if(__cxa_guard_acquire(&__sGuard)) {
       try 
       {
@@ -34,6 +34,7 @@ Sing & Test()
         throw ;
       }
       __cxa_guard_release(&__sGuard);
+      /* __cxa_atexit(Sing::~Sing, &__s, &__dso_handle); */
     } 
 
   } 

tests/StaticHandler5Test.expect

@@ -23,7 +23,7 @@ Sing & Test()
   static bool __sGuard;
   alignas(Sing) static char __s[sizeof(Sing)];
 
-  if(!__sGuard) {
+  if((__sGuard & 255) == 0) {
     new (&__s)Sing();
     __sGuard = true;
   }