Interpret __attribute__((alias("foo")))

Author: tautschnig

regression/cbmc/gcc_attribute_alias1/main.c

@@ -0,0 +1,21 @@
+#include <assert.h>
+
+int foo(int a)
+{
+  return a;
+}
+
+// this is a GCC extension
+
+int bar(int b) __attribute__((alias("foo")));
+
+__typeof__(foo) bar2 __attribute__((alias("foo")));
+
+int main()
+{
+  #ifdef __GNUC__
+  assert(bar(42)==42);
+  assert(bar2(42)==42);
+  #endif
+  return 0;
+}

regression/cbmc/gcc_attribute_alias1/test.desc

@@ -0,0 +1,8 @@
+CORE
+main.c
+
+^EXIT=0$
+^SIGNAL=0$
+--
+^warning: ignoring
+^CONVERSION ERROR$

src/ansi-c/ansi_c_convert_type.cpp

@@ -233,6 +233,12 @@ void ansi_c_convert_typet::read_rec(const typet &type)
     constructor=true;
   else if(type.id()==ID_destructor)
     destructor=true;
+  else if(type.id()==ID_alias &&
+          type.has_subtype() &&
+          type.subtype().id()==ID_string_constant)
+  {
+    c_storage_spec.alias=type.subtype().get(ID_value);
+  }
   else
     other.push_back(type);
 }

src/ansi-c/c_storage_spec.cpp

@@ -55,4 +55,10 @@ void c_storage_spect::read(const typet &type)
       if(it->id()==ID_thread)
         is_thread_local=true;
   }
+  else if(type.id()==ID_alias &&
+          type.has_subtype() &&
+          type.subtype().id()==ID_string_constant)
+  {
+    alias=type.subtype().get(ID_value);
+  }
 }

src/ansi-c/c_storage_spec.h

@@ -34,10 +34,14 @@ class c_storage_spect
     is_register=false;
     is_inline=false;
     is_weak=false;
+    alias.clear();
   }
 
   bool is_typedef, is_extern, is_static, is_register,
        is_inline, is_thread_local, is_weak;
+
+  // __attribute__((alias("foo")))
+  irep_idt alias;
 
   friend bool operator == (
     const c_storage_spect &a,
@@ -49,7 +53,8 @@ class c_storage_spect
            a.is_register==b.is_register &&
            a.is_thread_local==b.is_thread_local &&
            a.is_inline==b.is_inline &&
-           a.is_weak==b.is_weak;
+           a.is_weak==b.is_weak &&
+           a.alias==b.alias;
   }
 
   friend bool operator != (
@@ -70,6 +75,7 @@ class c_storage_spect
     a.is_inline       |=b.is_inline;
     a.is_thread_local |=b.is_thread_local;
     a.is_weak         |=b.is_weak;
+    if(!b.alias.empty()) a.alias=b.alias;
 
     return a;
   }

src/ansi-c/c_typecheck_base.cpp

@@ -759,6 +759,17 @@ void c_typecheck_baset::typecheck_declaration(
       // now check other half of type
       typecheck_type(symbol.type);
 
+      if(!full_spec.alias.empty())
+      {
+        if(symbol.value.is_not_nil())
+          throw "alias attribute cannot be used with a body";
+
+        // alias function need not have been declared yet, thus
+        // can't lookup
+        symbol.value=symbol_exprt(full_spec.alias);
+        symbol.is_macro=true;
+      }
+
       typecheck_symbol(symbol);
 
       // add code contract (if any); we typecheck this after the

src/ansi-c/parser.y

@@ -132,6 +132,7 @@ extern char *yyansi_ctext;
 %token TOK_GCC_ATTRIBUTE_MODE "mode"
 %token TOK_GCC_ATTRIBUTE_GNU_INLINE "__gnu_inline__"
 %token TOK_GCC_ATTRIBUTE_WEAK "weak"
+%token TOK_GCC_ATTRIBUTE_ALIAS "alias"
 %token TOK_GCC_ATTRIBUTE_NORETURN "noreturn"
 %token TOK_GCC_ATTRIBUTE_CONSTRUCTOR "constructor"
 %token TOK_GCC_ATTRIBUTE_DESTRUCTOR "destructor"
@@ -1564,6 +1565,8 @@ gcc_type_attribute:
         { $$=$1; set($$, ID_static); } /* GCC extern inline - cleanup in ansi_c_declarationt::to_symbol */
         | TOK_GCC_ATTRIBUTE_WEAK TOK_GCC_ATTRIBUTE_END
         { $$=$1; set($$, ID_weak); }
+        | TOK_GCC_ATTRIBUTE_ALIAS '(' TOK_STRING ')' TOK_GCC_ATTRIBUTE_END
+        { $$=$1; set($$, ID_alias); mto($$, $3); }
         | TOK_NORETURN
         { $$=$1; set($$, ID_noreturn); }
         | TOK_GCC_ATTRIBUTE_NORETURN TOK_GCC_ATTRIBUTE_END

src/ansi-c/scanner.l

@@ -1,5 +1,6 @@
 %option nounput
 %option noinput
+%option stack
 
 %{
 
@@ -230,7 +231,7 @@ void ansi_c_scanner_init()
 }
 
 <STRING_LITERAL_COMMENT>{
-   "*/"         { BEGIN(STRING_LITERAL); } /* end comment state, back to STRING_LITERAL */
+   "*/"         { yy_pop_state(); } /* end comment state, back to STRING_LITERAL */
    "/*"         { yyansi_cerror("Probably nested comments"); }
    <<EOF>>      { yyansi_cerror("Unterminated comment"); return TOK_SCANNER_ERROR; }
    [^*/\n]*     { /* ignore every char except '*' and NL (performance!) */ }
@@ -252,14 +253,16 @@ void ansi_c_scanner_init()
                   return TOK_CHARACTER;
                 }
 
-<GRAMMAR>{string_lit} {
+<GRAMMAR,GCC_ATTRIBUTE3>{string_lit} {
                   PARSER.string_literal.clear();
                   PARSER.string_literal.append(yytext);
                   newstack(yyansi_clval);
                   PARSER.set_source_location(stack(yyansi_clval));
                   // String literals can be continued in
                   // the next line
-                  BEGIN(STRING_LITERAL);
+                  yy_push_state(STRING_LITERAL);
+                  // use yy_top_state() to keep the compiler happy
+                  (void)yy_top_state();
                 }
 
 <STRING_LITERAL>{string_lit} { PARSER.string_literal.append(yytext); }
@@ -270,13 +273,13 @@ void ansi_c_scanner_init()
                   PARSER.set_line_no(PARSER.get_line_no()-1);
                 }
 <STRING_LITERAL>{cppdirective} { /* ignore */ }
-<STRING_LITERAL>"/*" { BEGIN(STRING_LITERAL_COMMENT); /* C comment, ignore */ }
+<STRING_LITERAL>"/*" { yy_push_state(STRING_LITERAL_COMMENT); /* C comment, ignore */ }
 <STRING_LITERAL>"//".*\n { /* C++ comment, ignore */ }
 <STRING_LITERAL>. { // anything else: back to normal
                   source_locationt l=stack(yyansi_clval).source_location();
                   stack(yyansi_clval)=convert_string_literal(PARSER.string_literal);
                   stack(yyansi_clval).add_source_location().swap(l);
-                  BEGIN(GRAMMAR); // back to normal
+                  yy_pop_state(); // back to normal
                   yyless(0); // put back
                   return TOK_STRING;
                 }
@@ -1390,6 +1393,9 @@ __decltype          { if(PARSER.cpp98 && PARSER.mode==ansi_c_parsert::GCC)
 "weak" |
 "__weak__"          { BEGIN(GCC_ATTRIBUTE3); loc(); return TOK_GCC_ATTRIBUTE_WEAK; }
 
+"alias" |
+"__alias__"          { BEGIN(GCC_ATTRIBUTE3); loc(); return TOK_GCC_ATTRIBUTE_ALIAS; }
+
 "noreturn" |
 "__noreturn__"      { BEGIN(GCC_ATTRIBUTE3); loc(); return TOK_GCC_ATTRIBUTE_NORETURN; }