Changeset ed9a1ae

Timestamp:

Aug 31, 2022, 10:57:37 AM (3 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, ast-experimental, master, pthread-emulation

Children:

64af7ac

Parents:

dc708c1

Message:

Cfa now distinguishes between thread and _Thread_local.

Location:

src

Files:

• AST/Print.cpp (modified) (3 diffs)
• AST/StorageClasses.hpp (modified) (3 diffs)
• InitTweak/InitTweak.cc (modified) (2 diffs)
• Parser/DeclarationNode.cc (modified) (2 diffs)
• Parser/lex.ll (modified) (1 diff)
• Parser/parser.yy (modified) (4 diffs)
• SynTree/Type.cc (modified) (1 diff)
• SynTree/Type.h (modified) (3 diffs)

src/AST/Print.cpp

@@ -86 +86 @@
 
                 static constexpr auto StorageClasses = make_array<const char*>(
-                        "extern", "static", "auto", "register", "_Thread_local"
+                        "extern", "static", "auto", "register", "__thread", "_Thread_local"
                 );
 
@@ -215 +215 @@
                         ++indent;
                         ptrToEnum->base->accept( *this );
-                        --indent;  
+                        --indent;
                 }
 
@@ -1623 +1623 @@
 // if the wrong size is specified
 constexpr array<const char*, 3> Printer::Names::FuncSpecifiers;
-constexpr array<const char*, 5> Printer::Names::StorageClasses;
+constexpr array<const char*, 6> Printer::Names::StorageClasses;
 constexpr array<const char*, 6> Printer::Names::Qualifiers;
 }

src/AST/StorageClasses.hpp

@@ -24 +24 @@
         /// Bitflags for storage classes
         enum {
-                Extern      = 1 << 0,
-                Static      = 1 << 1,
-                Auto        = 1 << 2,
-                Register    = 1 << 3,
-                ThreadLocal = 1 << 4,
-                NumClasses       = 5
+                Extern         = 1 << 0,
+                Static         = 1 << 1,
+                Auto           = 1 << 2,
+                Register       = 1 << 3,
+                ThreadLocalGcc = 1 << 4,
+                ThreadLocalC11 = 1 << 5,
+                NumClasses          = 6
         };
 
@@ -37 +38 @@
                         unsigned int val;
                         struct {
-                                bool is_extern      : 1;
-                                bool is_static      : 1;
-                                bool is_auto        : 1;
-                                bool is_register    : 1;
-                                bool is_threadlocal : 1;
+                                bool is_extern         : 1;
+                                bool is_static         : 1;
+                                bool is_auto           : 1;
+                                bool is_register       : 1;
+                                bool is_threadlocalGcc : 1;
+                                bool is_threadlocalC11 : 1;
                         };
 
@@ -48 +50 @@
 
                 constexpr class_flags( unsigned int val = 0 ) : val(val) {}
+
+                bool is_threadlocal_any() { return this->is_threadlocalC11 || this->is_threadlocalGcc; }
         };
 

src/InitTweak/InitTweak.cc

@@ -1241 +1241 @@
         static const char * const tlsd_section = ".tdata" ASM_COMMENT;
         void addDataSectionAttribute( ObjectDecl * objDecl ) {
-                const bool is_tls = objDecl->get_storageClasses().is_threadlocal;
+                const bool is_tls = objDecl->get_storageClasses().is_threadlocal_any();
                 const char * section = is_tls ? tlsd_section : data_section;
                 objDecl->attributes.push_back(new Attribute("section", {
@@ -1249 +1249 @@
 
         void addDataSectionAttribute( ast::ObjectDecl * objDecl ) {
-                const bool is_tls = objDecl->storage.is_threadlocal;
+                const bool is_tls = objDecl->storage.is_threadlocal_any();
                 const char * section = is_tls ? tlsd_section : data_section;
                 objDecl->attributes.push_back(new ast::Attribute("section", {

src/Parser/DeclarationNode.cc

@@ -262 +262 @@
         newnode->type->enumeration.anon = name == nullptr;
         if ( base && base->type)  {
-                newnode->type->base = base->type;       
+                newnode->type->base = base->type;
         } // if
 
@@ -505 +505 @@
                         } // for
                         // src is the new item being added and has a single bit
-                } else if ( ! src->storageClasses.is_threadlocal ) { // conflict ?
+                } else if ( ! src->storageClasses.is_threadlocal_any() ) { // conflict ?
                         appendError( error, string( "conflicting " ) + Type::StorageClassesNames[storageClasses.ffs()] +
                                                  " & " + Type::StorageClassesNames[src->storageClasses.ffs()] );

src/Parser/lex.ll

@@ -314 +314 @@
 switch                  { KEYWORD_RETURN(SWITCH); }
 thread                  { KEYWORD_RETURN(THREAD); }                             // C11
-__thread                { KEYWORD_RETURN(THREADLOCAL); }                // GCC
-_Thread_local   { KEYWORD_RETURN(THREADLOCAL); }                // C11
+__thread                { KEYWORD_RETURN(THREADLOCALGCC); }             // GCC
+_Thread_local   { KEYWORD_RETURN(THREADLOCALC11); }             // C11
 throw                   { KEYWORD_RETURN(THROW); }                              // CFA
 throwResume             { KEYWORD_RETURN(THROWRESUME); }                // CFA

src/Parser/parser.yy

@@ -293 +293 @@
 %token TYPEDEF
 %token EXTERN STATIC AUTO REGISTER
-%token THREADLOCAL                                                                              // C11
+%token THREADLOCALGCC THREADLOCALC11                                            // GCC, C11
 %token INLINE FORTRAN                                                                   // C99, extension ISO/IEC 9899:1999 Section J.5.9(1)
 %token NORETURN                                                                                 // C11
@@ -1345 +1345 @@
                 {
                         if ( $2 == OperKinds::LThan || $2 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; }
-                        else { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; } 
+                        else { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
                 }
         | comma_expression updowneq comma_expression '~' comma_expression // CFA, anonymous loop-index
@@ -1357 +1357 @@
                 {
                         if ( $2 == OperKinds::LThan || $2 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; }
-                        else { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; } 
+                        else { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
                 }
         | comma_expression updowneq comma_expression '~' '@' // CFA, error
@@ -2082 +2082 @@
         | REGISTER
                 { $$ = DeclarationNode::newStorageClass( Type::Register ); }
-        | THREADLOCAL                                                                           // C11
-                { $$ = DeclarationNode::newStorageClass( Type::Threadlocal ); }
+        | THREADLOCALGCC                                                                                // GCC
+                { $$ = DeclarationNode::newStorageClass( Type::ThreadlocalGcc ); }
+        | THREADLOCALC11                                                                                // C11
+                { $$ = DeclarationNode::newStorageClass( Type::ThreadlocalC11 ); }
                 // Put function specifiers here to simplify parsing rules, but separate them semantically.
         | INLINE                                                                                        // C99

src/SynTree/Type.cc

@@ -80 +80 @@
 // These must remain in the same order as the corresponding bit fields.
 const char * Type::FuncSpecifiersNames[] = { "inline", "_Noreturn", "fortran" };
-const char * Type::StorageClassesNames[] = { "extern", "static", "auto", "register", "_Thread_local" };
+const char * Type::StorageClassesNames[] = { "extern", "static", "auto", "register", "__thread", "_Thread_local" };
 const char * Type::QualifiersNames[] = { "const", "restrict", "volatile", "mutex", "_Atomic" };
 

src/SynTree/Type.h

@@ -84 +84 @@
         }; // FuncSpecifiers
 
-        enum { Extern = 1 << 0, Static = 1 << 1, Auto = 1 << 2, Register = 1 << 3, Threadlocal = 1 << 4, NumStorageClass = 5 };
+        enum { Extern = 1 << 0, Static = 1 << 1, Auto = 1 << 2, Register = 1 << 3, ThreadlocalGcc = 1 << 4, ThreadlocalC11 = 1 << 5, NumStorageClass = 6 };
         static const char * StorageClassesNames[];
         union StorageClasses {
@@ -93 +93 @@
                         bool is_auto : 1;
                         bool is_register : 1;
-                        bool is_threadlocal : 1;
+                        bool is_threadlocalGcc : 1;
+                        bool is_threadlocalC11 : 1;
                 };
 
@@ -100 +101 @@
                 // equality (==, !=) works implicitly on first field "val", relational operations are undefined.
                 BFCommon( StorageClasses, NumStorageClass )
+
+                bool is_threadlocal_any() { return this->is_threadlocalC11 || this->is_threadlocalGcc; }
         }; // StorageClasses