C++ front-end: parse GCC attributes

Author: tautschnig

src/ansi-c/scanner.l

@@ -939,14 +939,9 @@ __decltype          { if(PARSER.cpp98 &&
                      PARSER.mode==configt::ansi_ct::flavourt::CODEWARRIOR ||
                      PARSER.mode==configt::ansi_ct::flavourt::ARM)
                   {
-                    if(PARSER.cpp98)
-                      BEGIN(IGNORE_PARENS);
-                    else
-                    {
-                      BEGIN(GCC_ATTRIBUTE1);
-                      loc();
-                      return TOK_GCC_ATTRIBUTE;
-                    }
+                    BEGIN(GCC_ATTRIBUTE1);
+                    loc();
+                    return TOK_GCC_ATTRIBUTE;
                   }
                   else
                     return make_identifier();

src/cpp/cpp_typecheck_type.cpp

@@ -133,6 +133,10 @@ void cpp_typecheckt::typecheck_type(typet &type)
     if(type.subtype().get_bool(ID_C_volatile))
       type.set(ID_C_volatile, true);
   }
+  else if(type.id()==ID_vector)
+  {
+    typecheck_vector_type(to_vector_type(type));
+  }
   else if(type.id()==ID_code)
   {
     code_typet &code_type=to_code_type(type);

src/cpp/parse.cpp

@@ -276,7 +276,7 @@ class Parser // NOLINT(readability/identifiers)
   bool optStorageSpec(cpp_storage_spect &);
   bool optCvQualify(typet &);
   bool optAlignas(typet &);
-  bool rAttribute();
+  bool rAttribute(typet &);
   bool optAttribute(cpp_declarationt &);
   bool optIntegralTypeOrClassSpec(typet &);
   bool rConstructorDecl(
@@ -473,8 +473,10 @@ void Parser::merge_types(const typet &src, typet &dest)
   {
     if(dest.id()!=ID_merged_type)
     {
+      source_locationt location=dest.source_location();
       typet tmp(ID_merged_type);
       tmp.move_to_subtypes(dest);
+      tmp.add_source_location()=location;
       dest=tmp;
     }
 
@@ -2044,7 +2046,7 @@ bool Parser::optCvQualify(typet &cv)
         break;
 
       case TOK_GCC_ATTRIBUTE:
-        if(!rAttribute())
+        if(!rAttribute(cv))
           return false;
         break;
 
@@ -2103,28 +2105,204 @@ bool Parser::optAlignas(typet &cv)
   return true;
 }
 
-bool Parser::rAttribute()
+bool Parser::rAttribute(typet &t)
 {
+  #ifdef DEBUG
+  indenter _i;
+  std::cout << std::string(__indent, ' ') << "Parser::rAttribute "
+            << lex.LookAhead(0);
+  #endif
   cpp_tokent tk;
   lex.get_token(tk);
 
   switch(tk.kind)
   {
   case '(':
-    rAttribute();
+    if(lex.LookAhead(0)!=')')
+      rAttribute(t);
+
     if(lex.LookAhead(0)!=')')
       return false;
     lex.get_token(tk);
-    break;
+    return true;
 
-  case TOK_IDENTIFIER:
+  case TOK_GCC_ATTRIBUTE_PACKED:
+    {
+      typet attr(ID_packed);
+      set_location(attr, tk);
+      merge_types(attr, t);
+      break;
+    }
+
+  case TOK_GCC_ATTRIBUTE_TRANSPARENT_UNION:
+    {
+      typet attr(ID_transparent_union);
+      set_location(attr, tk);
+      merge_types(attr, t);
+      break;
+    }
+
+  case TOK_GCC_ATTRIBUTE_VECTOR_SIZE:
+    {
+      cpp_tokent tk2, tk3;
+
+      if(lex.get_token(tk2)!='(')
+        return false;
+
+      exprt exp;
+      if(!rCommaExpression(exp))
+        return false;
+
+      if(lex.get_token(tk3)!=')')
+        return false;
+
+      vector_typet attr(nil_typet(), exp);
+      attr.add_source_location()=exp.source_location();
+      merge_types(attr, t);
+      break;
+    }
+
+  case TOK_GCC_ATTRIBUTE_ALIGNED:
+    {
+      typet attr(ID_aligned);
+      set_location(attr, tk);
+
+      if(lex.LookAhead(0)=='(')
+      {
+        cpp_tokent tk2, tk3;
+
+        if(lex.get_token(tk2)!='(')
+          return false;
+
+        exprt exp;
+        if(!rCommaExpression(exp))
+          return false;
+
+        if(lex.get_token(tk3)!=')')
+          return false;
+
+        attr.add(ID_size, exp);
+      }
+
+      merge_types(attr, t);
+      break;
+    }
+
+  case TOK_GCC_ATTRIBUTE_MODE:
+    {
+      cpp_tokent tk2, tk3;
+
+      if(lex.get_token(tk2)!='(')
+        return false;
+
+      irept name;
+      if(!rName(name))
+        return false;
+
+      if(lex.get_token(tk3)!=')')
+        return false;
+
+      typet attr(ID_gcc_attribute_mode);
+      set_location(attr, tk);
+      attr.set(ID_size, name.get(ID_identifier));
+      merge_types(attr, t);
+      break;
+    }
+
+  case TOK_GCC_ATTRIBUTE_GNU_INLINE:
+    {
+      typet attr(ID_static);
+      set_location(attr, tk);
+      merge_types(attr, t);
+      break;
+    }
+
+  case TOK_GCC_ATTRIBUTE_WEAK:
+    {
+      typet attr(ID_weak);
+      set_location(attr, tk);
+      merge_types(attr, t);
+      break;
+    }
+
+  case TOK_GCC_ATTRIBUTE_ALIAS:
+    {
+      cpp_tokent tk2, tk3, tk4;
+
+      if(lex.get_token(tk2)!='(')
+        return false;
+
+      if(!rString(tk3))
+        return false;
+
+      if(lex.get_token(tk4)!=')')
+        return false;
+
+      typet attr(ID_alias);
+      set_location(attr, tk);
+      attr.move_to_sub(tk3.data);
+      merge_types(attr, t);
+      break;
+    }
+
+  case TOK_GCC_ATTRIBUTE_SECTION:
+    {
+      cpp_tokent tk2, tk3, tk4;
+
+      if(lex.get_token(tk2)!='(')
+        return false;
+
+      if(!rString(tk3))
+        return false;
+
+      if(lex.get_token(tk4)!=')')
+        return false;
+
+      typet attr(ID_section);
+      set_location(attr, tk);
+      attr.move_to_sub(tk3.data);
+      merge_types(attr, t);
+      break;
+    }
+
+  case TOK_GCC_ATTRIBUTE_NORETURN:
+    {
+      typet attr(ID_noreturn);
+      set_location(attr, tk);
+      merge_types(attr, t);
+      break;
+    }
+
+  case TOK_GCC_ATTRIBUTE_CONSTRUCTOR:
+    {
+      typet attr(ID_constructor);
+      set_location(attr, tk);
+      merge_types(attr, t);
+      break;
+    }
+
+  case TOK_GCC_ATTRIBUTE_DESTRUCTOR:
+    {
+      typet attr(ID_destructor);
+      set_location(attr, tk);
+      merge_types(attr, t);
+      break;
+    }
+
+  case ',':
+    if(lex.LookAhead(0)==')')
+      // the scanner ignored an attribute
+      return true;
     break;
 
   default:
     return false;
   }
 
-  return true;
+  if(lex.LookAhead(0)==')')
+    return true;
+
+  return rAttribute(t);
 }
 
 bool Parser::optAttribute(cpp_declarationt &declaration)
@@ -2971,6 +3149,8 @@ bool Parser::rDeclarator(
       break;
   }
 
+  optCvQualify(d_outer);
+
   #ifdef DEBUG
   std::cout << std::string(__indent, ' ') << "Parser::rDeclarator2 13\n";
   #endif