nsz Git - cparser/blob - attribute.c

   1 /*
   2  * This file is part of cparser.
   3  * Copyright (C) 2007-2009 Matthias Braun <matze@braunis.de>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  18  * 02111-1307, USA.
  19  */
  20 #include <config.h>
  21
  22 #include <assert.h>
  23 #include "adt/strutil.h"
  24 #include "diagnostic.h"
  25 #include "warning.h"
  26 #include "attribute_t.h"
  27 #include "symbol_t.h"
  28 #include "adt/error.h"
  29 #include "type_t.h"
  30
  31 static const char *const attribute_names[ATTRIBUTE_LAST+1] = {
  32         [ATTRIBUTE_GNU_ALIAS]                  = "alias",
  33         [ATTRIBUTE_GNU_ALIGNED]                = "aligned",
  34         [ATTRIBUTE_GNU_ALWAYS_INLINE]          = "always_inline",
  35         [ATTRIBUTE_GNU_CDECL]                  = "cdecl",
  36         [ATTRIBUTE_GNU_COMMON]                 = "common",
  37         [ATTRIBUTE_GNU_CONST]                  = "const",
  38         [ATTRIBUTE_GNU_CONSTRUCTOR]            = "constructor",
  39         [ATTRIBUTE_GNU_DEPRECATED]             = "deprecated",
  40         [ATTRIBUTE_GNU_DESTRUCTOR]             = "destructor",
  41         [ATTRIBUTE_GNU_DLLEXPORT]              = "dllexport",
  42         [ATTRIBUTE_GNU_DLLIMPORT]              = "dllimport",
  43         [ATTRIBUTE_GNU_EIGTHBIT_DATA]          = "eightbit_data",
  44         [ATTRIBUTE_GNU_EXTERNALLY_VISIBLE]     = "externally_visible",
  45         [ATTRIBUTE_GNU_FAR]                    = "far",
  46         [ATTRIBUTE_GNU_FASTCALL]               = "fastcall",
  47         [ATTRIBUTE_GNU_FLATTEN]                = "flatten",
  48         [ATTRIBUTE_GNU_FORMAT_ARG]             = "format_arg",
  49         [ATTRIBUTE_GNU_FORMAT]                 = "format",
  50         [ATTRIBUTE_GNU_FUNCTION_VECTOR]        = "function_vector",
  51         [ATTRIBUTE_GNU_GCC_STRUCT]             = "gcc_struct",
  52         [ATTRIBUTE_GNU_INTERRUPT_HANDLER]      = "interrupt_handler",
  53         [ATTRIBUTE_GNU_INTERRUPT]              = "interrupt",
  54         [ATTRIBUTE_GNU_LEAF]                   = "leaf",
  55         [ATTRIBUTE_GNU_LONGCALL]               = "longcall",
  56         [ATTRIBUTE_GNU_LONG_CALL]              = "long_call",
  57         [ATTRIBUTE_GNU_MALLOC]                 = "malloc",
  58         [ATTRIBUTE_GNU_MAY_ALIAS]              = "may_alias",
  59         [ATTRIBUTE_GNU_MODEL]                  = "model",
  60         [ATTRIBUTE_GNU_MODE]                   = "mode",
  61         [ATTRIBUTE_GNU_MS_STRUCT]              = "ms_struct",
  62         [ATTRIBUTE_GNU_NAKED]                  = "naked",
  63         [ATTRIBUTE_GNU_NEAR]                   = "near",
  64         [ATTRIBUTE_GNU_NESTING]                = "nesting",
  65         [ATTRIBUTE_GNU_NMI_HANDLER]            = "nmi_handler",
  66         [ATTRIBUTE_GNU_NOCOMMON]               = "nocommon",
  67         [ATTRIBUTE_GNU_NOINLINE]               = "noinline",
  68         [ATTRIBUTE_GNU_NO_INSTRUMENT_FUNCTION] = "no_instrument_function",
  69         [ATTRIBUTE_GNU_NONNULL]                = "nonnull",
  70         [ATTRIBUTE_GNU_NORETURN]               = "noreturn",
  71         [ATTRIBUTE_GNU_NOTHROW]                = "nothrow",
  72         [ATTRIBUTE_GNU_NOTSHARED]              = "notshared",
  73         [ATTRIBUTE_GNU_PACKED]                 = "packed",
  74         [ATTRIBUTE_GNU_PURE]                   = "pure",
  75         [ATTRIBUTE_GNU_REGPARM]                = "regparm",
  76         [ATTRIBUTE_GNU_RETURNS_TWICE]          = "returns_twice",
  77         [ATTRIBUTE_GNU_SAVEALL]                = "saveall",
  78         [ATTRIBUTE_GNU_SECTION]                = "section",
  79         [ATTRIBUTE_GNU_SENTINEL]               = "sentinel",
  80         [ATTRIBUTE_GNU_SHARED]                 = "shared",
  81         [ATTRIBUTE_GNU_SHORTCALL]              = "shortcall",
  82         [ATTRIBUTE_GNU_SHORT_CALL]             = "short_call",
  83         [ATTRIBUTE_GNU_SIGNAL]                 = "signal",
  84         [ATTRIBUTE_GNU_SP_SWITCH]              = "sp_switch",
  85         [ATTRIBUTE_GNU_SSEREGPARM]             = "sseregparm",
  86         [ATTRIBUTE_GNU_STDCALL]                = "stdcall",
  87         [ATTRIBUTE_GNU_TINY_DATA]              = "tiny_data",
  88         [ATTRIBUTE_GNU_TLS_MODEL]              = "tls_model",
  89         [ATTRIBUTE_GNU_TRANSPARENT_UNION]      = "transparent_union",
  90         [ATTRIBUTE_GNU_TRAP_EXIT]              = "trap_exit",
  91         [ATTRIBUTE_GNU_UNUSED]                 = "unused",
  92         [ATTRIBUTE_GNU_USED]                   = "used",
  93         [ATTRIBUTE_GNU_VISIBILITY]             = "visibility",
  94         [ATTRIBUTE_GNU_VOLATILE]               = "volatile",
  95         [ATTRIBUTE_GNU_WARN_UNUSED_RESULT]     = "warn_unused_result",
  96         [ATTRIBUTE_GNU_WEAKREF]                = "weakref",
  97         [ATTRIBUTE_GNU_WEAK]                   = "weak",
  98
  99         [ATTRIBUTE_MS_ALIGN]                   = "align",
 100         [ATTRIBUTE_MS_ALLOCATE]                = "allocate",
 101         [ATTRIBUTE_MS_DEPRECATED]              = "deprecated",
 102         [ATTRIBUTE_MS_DLLEXPORT]               = "dllexport",
 103         [ATTRIBUTE_MS_DLLIMPORT]               = "dllimport",
 104         [ATTRIBUTE_MS_NAKED]                   = "naked",
 105         [ATTRIBUTE_MS_NOALIAS]                 = "noalias",
 106         [ATTRIBUTE_MS_NOINLINE]                = "noinline",
 107         [ATTRIBUTE_MS_NORETURN]                = "noreturn",
 108         [ATTRIBUTE_MS_NOTHROW]                 = "nothrow",
 109         [ATTRIBUTE_MS_NOVTABLE]                = "novtable",
 110         [ATTRIBUTE_MS_PROPERTY]                = "property",
 111         [ATTRIBUTE_MS_RESTRICT]                = "restrict",
 112         [ATTRIBUTE_MS_RETURNS_TWICE]           = "returns_twice",
 113         [ATTRIBUTE_MS_SELECTANY]               = "selectany",
 114         [ATTRIBUTE_MS_THREAD]                  = "thread",
 115         [ATTRIBUTE_MS_UUID]                    = "uuid",
 116 };
 117
 118 const char *get_attribute_name(attribute_kind_t kind)
 119 {
 120         assert(kind <= ATTRIBUTE_LAST);
 121         return attribute_names[kind];
 122 }
 123
 124 type_t *handle_attribute_mode(const attribute_t *attribute, type_t *orig_type)
 125 {
 126         type_t *type = skip_typeref(orig_type);
 127
 128         /* at least: byte, word, pointer, list of machine modes
 129          * __XXX___ is interpreted as XXX */
 130
 131         /* This isn't really correct, the backend should provide a list of machine
 132          * specific modes (according to gcc philosophy that is...) */
 133         attribute_argument_t *arg = attribute->a.arguments;
 134         if (arg == NULL) {
 135                 errorf(&attribute->source_position,
 136                        "__attribute__((mode(X))) misses argument");
 137                 return orig_type;
 138         }
 139
 140         const char         *symbol_str = arg->v.symbol->string;
 141         bool                sign       = is_type_signed(type);
 142         atomic_type_kind_t  akind;
 143         if (streq_underscore("QI",   symbol_str) ||
 144             streq_underscore("byte", symbol_str)) {
 145                 akind = sign ? ATOMIC_TYPE_CHAR : ATOMIC_TYPE_UCHAR;
 146         } else if (streq_underscore("HI", symbol_str)) {
 147                 akind = sign ? ATOMIC_TYPE_SHORT : ATOMIC_TYPE_USHORT;
 148         } else if (streq_underscore("SI",      symbol_str)
 149                 || streq_underscore("word",    symbol_str)
 150                 || streq_underscore("pointer", symbol_str)) {
 151                 akind = sign ? ATOMIC_TYPE_INT : ATOMIC_TYPE_UINT;
 152         } else if (streq_underscore("DI", symbol_str)) {
 153                 akind = sign ? ATOMIC_TYPE_LONGLONG : ATOMIC_TYPE_ULONGLONG;
 154         } else {
 155                 source_position_t const *const pos = &attribute->source_position;
 156                 warningf(WARN_OTHER, pos, "ignoring unknown mode '%s'", symbol_str);
 157                 return orig_type;
 158         }
 159
 160         if (type->kind == TYPE_ATOMIC || type->kind == TYPE_ENUM) {
 161                 type_t *copy       = duplicate_type(type);
 162                 copy->atomic.akind = akind;
 163                 return identify_new_type(copy);
 164         } else if (is_type_pointer(type)) {
 165                 source_position_t const *const pos = &attribute->source_position;
 166                 warningf(WARN_OTHER, pos, "__attribute__((mode)) on pointers not implemented yet (ignored)");
 167                 return type;
 168         }
 169
 170         errorf(&attribute->source_position,
 171                "__attribute__((mode)) only allowed on integer, enum or pointer type");
 172         return orig_type;
 173 }
 174
 175 static inline bool is_po2(unsigned x)
 176 {
 177         return (x & (x-1)) == 0;
 178 }
 179
 180 static void handle_attribute_aligned(const attribute_t *attribute,
 181                                      entity_t *entity)
 182 {
 183         int alignment = 32; /* TODO: fill in maximum useful alignment for
 184                                                    target machine */
 185         if (attribute->a.arguments) {
 186                 attribute_argument_t *argument = attribute->a.arguments;
 187                 alignment = fold_constant_to_int(argument->v.expression);
 188         }
 189
 190         if (!is_po2(alignment)) {
 191                 errorf(&attribute->source_position,
 192                            "alignment must be a power of 2 but is %d\n",
 193                            alignment);
 194                 return;
 195         }
 196         if (alignment <= 0) {
 197                 errorf(&attribute->source_position,
 198                            "alignment must be bigger than 0 but is %d\n",
 199                            alignment);
 200                 return;
 201         }
 202
 203         switch (entity->kind) {
 204         case DECLARATION_KIND_CASES:
 205                 entity->declaration.alignment = alignment;
 206         case ENTITY_TYPEDEF:
 207                 entity->typedefe.alignment = alignment;
 208                 break;
 209         case ENTITY_STRUCT:
 210         case ENTITY_UNION:
 211                 if (alignment > (int)entity->compound.alignment) {
 212                         entity->compound.alignment = alignment;
 213                 }
 214                 break;
 215         default: {
 216                 source_position_t const *const pos  = &attribute->source_position;
 217                 char              const *const what = get_entity_kind_name(entity->kind);
 218                 symbol_t          const *const sym  = entity->base.symbol;
 219                 warningf(WARN_OTHER, pos, "alignment attribute specification on %s '%S' ignored", what, sym);
 220                 break;
 221         }
 222         }
 223 }
 224
 225 static const char *get_argument_string(const attribute_argument_t *argument)
 226 {
 227         if (argument == NULL)
 228                 return NULL;
 229         if (argument->kind != ATTRIBUTE_ARGUMENT_EXPRESSION)
 230                 return NULL;
 231         expression_t *expression = argument->v.expression;
 232         if (expression->kind != EXPR_STRING_LITERAL)
 233                 return NULL;
 234         return expression->literal.value.begin;
 235 }
 236
 237 static void handle_attribute_visibility(const attribute_t *attribute,
 238                                         entity_t *entity)
 239 {
 240         /* This isn't really correct, the backend should provide a list of machine
 241          * specific modes (according to gcc philosophy that is...) */
 242         attribute_argument_t *arg = attribute->a.arguments;
 243         if (arg == NULL) {
 244                 errorf(&attribute->source_position,
 245                        "__attribute__((visibility(X))) misses argument");
 246                 return;
 247         }
 248         const char *string = get_argument_string(arg);
 249         if (string == NULL) {
 250                 errorf(&attribute->source_position,
 251                        "__attribute__((visibility(X))) argument is not a string");
 252                 return;
 253         }
 254         elf_visibility_tag_t visibility = get_elf_visibility_from_string(string);
 255         if (visibility == ELF_VISIBILITY_ERROR) {
 256                 errorf(&attribute->source_position,
 257                        "unknown visibility type '%s'", string);
 258                 return;
 259         }
 260
 261         switch (entity->kind) {
 262         case ENTITY_VARIABLE:
 263                 entity->variable.elf_visibility = visibility;
 264                 break;
 265         case ENTITY_FUNCTION:
 266                 entity->function.elf_visibility = visibility;
 267                 break;
 268         default: {
 269                 source_position_t const *const pos  = &attribute->source_position;
 270                 char              const *const what = get_entity_kind_name(entity->kind);
 271                 symbol_t          const *const sym  = entity->base.symbol;
 272                 warningf(WARN_OTHER, pos, "visibility attribute specification on %s '%S' ignored", what, sym);
 273                 break;
 274         }
 275         }
 276 }
 277
 278 static void warn_arguments(const attribute_t *attribute)
 279 {
 280         if (attribute->a.arguments == NULL)
 281                 return;
 282
 283         source_position_t const *const pos  = &attribute->source_position;
 284         char              const *const what = get_attribute_name(attribute->kind);
 285         warningf(WARN_OTHER, pos, "attribute '%s' needs no arguments", what);
 286 }
 287
 288 static void handle_attribute_packed_e(const attribute_t *attribute,
 289                                       entity_t *entity)
 290 {
 291 #if 0
 292         if (entity->kind != ENTITY_STRUCT) {
 293                 source_position_t const *const pos  = &attribute->source_position;
 294                 char              const *const what = get_entity_kind_name(entity->kind);
 295                 symbol_t          const *const sym  = entity->base.symbol;
 296                 warningf(WARN_OTHER, pos, "packed attribute on %s '%S' ignored", what, sym);
 297                 return;
 298         }
 299 #endif
 300
 301         warn_arguments(attribute);
 302         entity->compound.packed = true;
 303 }
 304
 305 static void handle_attribute_packed(const attribute_t *attribute, type_t *type)
 306 {
 307         if (type->kind != TYPE_COMPOUND_STRUCT) {
 308                 source_position_t const *const pos  = &attribute->source_position;
 309                 warningf(WARN_OTHER, pos, "packed attribute on type '%T' ignored", type);
 310                 return;
 311         }
 312
 313         handle_attribute_packed_e(attribute, (entity_t*) type->compound.compound);
 314 }
 315
 316 static void handle_attribute_asm(const attribute_t *attribute,
 317                                       entity_t *entity)
 318 {
 319         attribute_argument_t *argument = attribute->a.arguments;
 320         assert (argument->kind == ATTRIBUTE_ARGUMENT_EXPRESSION);
 321         expression_t *expression = argument->v.expression;
 322         if (expression->kind != EXPR_STRING_LITERAL)
 323                 errorf(&attribute->source_position,
 324                        "Invalid asm attribute expression");
 325         symbol_t *sym = symbol_table_insert(expression->string_literal.value.begin);
 326         entity->function.actual_name = sym;
 327         assert(argument->next == NULL);
 328         return;
 329 }
 330
 331 void handle_entity_attributes(const attribute_t *attributes, entity_t *entity)
 332 {
 333         if (entity->kind == ENTITY_TYPEDEF) {
 334                 type_t *type = entity->typedefe.type;
 335                 type = handle_type_attributes(attributes, type);
 336                 entity->typedefe.type = type;
 337         } else if (is_declaration(entity)) {
 338                 type_t *type = entity->declaration.type;
 339                 type = handle_type_attributes(attributes, type);
 340                 entity->declaration.type = type;
 341         }
 342
 343         decl_modifiers_t modifiers = 0;
 344         const attribute_t *attribute = attributes;
 345         for ( ; attribute != NULL; attribute = attribute->next) {
 346                 switch(attribute->kind) {
 347                 case ATTRIBUTE_GNU_CONST:         modifiers |= DM_CONST; break;
 348                 case ATTRIBUTE_GNU_DEPRECATED:    modifiers |= DM_DEPRECATED; break;
 349                 case ATTRIBUTE_GNU_NOINLINE:      modifiers |= DM_NOINLINE; break;
 350                 case ATTRIBUTE_GNU_NAKED:         modifiers |= DM_NAKED; break;
 351                 case ATTRIBUTE_GNU_PURE:          modifiers |= DM_PURE; break;
 352                 case ATTRIBUTE_GNU_ALWAYS_INLINE: modifiers |= DM_FORCEINLINE; break;
 353                 case ATTRIBUTE_GNU_CONSTRUCTOR:   modifiers |= DM_CONSTRUCTOR; break;
 354                 case ATTRIBUTE_GNU_DESTRUCTOR:    modifiers |= DM_DESTRUCTOR; break;
 355                 case ATTRIBUTE_GNU_TRANSPARENT_UNION:
 356                                                                                   modifiers |= DM_TRANSPARENT_UNION;
 357                                                                                   break;
 358                 case ATTRIBUTE_GNU_USED:          modifiers |= DM_USED; break;
 359                 case ATTRIBUTE_GNU_UNUSED:        modifiers |= DM_UNUSED; break;
 360                 case ATTRIBUTE_GNU_DLLIMPORT:     modifiers |= DM_DLLIMPORT; break;
 361                 case ATTRIBUTE_GNU_DLLEXPORT:     modifiers |= DM_DLLEXPORT; break;
 362                 case ATTRIBUTE_GNU_WEAK:          modifiers |= DM_WEAK; break;
 363                 case ATTRIBUTE_GNU_LEAF:          modifiers |= DM_LEAF; break;
 364
 365                 case ATTRIBUTE_MS_DLLIMPORT:     modifiers |= DM_DLLIMPORT; break;
 366                 case ATTRIBUTE_MS_DLLEXPORT:     modifiers |= DM_DLLEXPORT; break;
 367                 case ATTRIBUTE_MS_NAKED:         modifiers |= DM_NAKED; break;
 368                 case ATTRIBUTE_MS_NOINLINE:      modifiers |= DM_NOINLINE; break;
 369                 case ATTRIBUTE_MS_THREAD:        modifiers |= DM_THREAD; break;
 370                 case ATTRIBUTE_MS_DEPRECATED:    modifiers |= DM_DEPRECATED; break;
 371                 case ATTRIBUTE_MS_RESTRICT:      modifiers |= DM_RESTRICT; break;
 372                 case ATTRIBUTE_MS_NOALIAS:       modifiers |= DM_NOALIAS; break;
 373
 374                 case ATTRIBUTE_GNU_PACKED:
 375                         handle_attribute_packed_e(attribute, entity);
 376                         break;
 377
 378                 case ATTRIBUTE_GNU_ASM:
 379                         handle_attribute_asm(attribute, entity);
 380                         break;
 381
 382                 case ATTRIBUTE_GNU_VISIBILITY:
 383                         handle_attribute_visibility(attribute, entity);
 384                         break;
 385
 386                 case ATTRIBUTE_MS_ALIGN:
 387                 case ATTRIBUTE_GNU_ALIGNED:
 388                         handle_attribute_aligned(attribute, entity);
 389                         break;
 390                 default: break;
 391                 }
 392         }
 393
 394         if (modifiers != 0) {
 395                 switch(entity->kind) {
 396                 case ENTITY_TYPEDEF:
 397                         entity->typedefe.modifiers |= modifiers;
 398                         break;
 399                 case ENTITY_UNION:
 400                 case ENTITY_STRUCT:
 401                         entity->compound.modifiers |= modifiers;
 402                         break;
 403                 case ENTITY_COMPOUND_MEMBER:
 404                 case ENTITY_VARIABLE:
 405                 case ENTITY_FUNCTION:
 406                         entity->declaration.modifiers |= modifiers;
 407                         break;
 408                 default:
 409                         /* TODO: warning */
 410                         break;
 411                 }
 412         }
 413 }
 414
 415 static type_t *change_calling_convention(type_t *type, cc_kind_t cconv)
 416 {
 417         if (is_typeref(type) || !is_type_function(type)) {
 418                 return type;
 419         }
 420
 421         if (type->function.calling_convention == cconv)
 422                 return type;
 423
 424         type_t* new_type = duplicate_type(type);
 425         new_type->function.calling_convention = cconv;
 426         return identify_new_type(new_type);
 427 }
 428
 429 static type_t *add_modifiers(type_t *type, decl_modifiers_t modifiers)
 430 {
 431         if (is_typeref(type) || !is_type_function(type)) {
 432                 return type;
 433         }
 434
 435         if ((type->function.modifiers & modifiers) == modifiers)
 436                 return type;
 437
 438         type_t* new_type = duplicate_type(type);
 439         new_type->function.modifiers |= modifiers;
 440         return identify_new_type(new_type);
 441 }
 442
 443 type_t *handle_type_attributes(const attribute_t *attributes, type_t *type)
 444 {
 445         const attribute_t *attribute = attributes;
 446         for ( ; attribute != NULL; attribute = attribute->next) {
 447                 switch(attribute->kind) {
 448                 case ATTRIBUTE_GNU_PACKED:
 449                         handle_attribute_packed(attribute, type);
 450                         break;
 451                 case ATTRIBUTE_GNU_CDECL:
 452                 case ATTRIBUTE_MS_CDECL:
 453                         type = change_calling_convention(type, CC_CDECL);
 454                         break;
 455                 case ATTRIBUTE_MS_STDCALL:
 456                 case ATTRIBUTE_GNU_STDCALL:
 457                         type = change_calling_convention(type, CC_STDCALL);
 458                         break;
 459                 case ATTRIBUTE_MS_FASTCALL:
 460                 case ATTRIBUTE_GNU_FASTCALL:
 461                         type = change_calling_convention(type, CC_FASTCALL);
 462                         break;
 463                 case ATTRIBUTE_MS_THISCALL:
 464                         type = change_calling_convention(type, CC_THISCALL);
 465                         break;
 466                 case ATTRIBUTE_GNU_RETURNS_TWICE:
 467                 case ATTRIBUTE_MS_RETURNS_TWICE:
 468                         type = add_modifiers(type, DM_RETURNS_TWICE);
 469                         break;
 470                 case ATTRIBUTE_GNU_NORETURN:
 471                 case ATTRIBUTE_MS_NORETURN:
 472                         type = add_modifiers(type, DM_NORETURN);
 473                         break;
 474                 case ATTRIBUTE_GNU_MALLOC:
 475                 case ATTRIBUTE_MS_ALLOCATE:
 476                         type = add_modifiers(type, DM_MALLOC);
 477                         break;
 478                 case ATTRIBUTE_GNU_NOTHROW:
 479                 case ATTRIBUTE_MS_NOTHROW:
 480                         type = add_modifiers(type, DM_NOTHROW);
 481                         break;
 482                 case ATTRIBUTE_GNU_MODE:
 483                         type = handle_attribute_mode(attribute, type);
 484                         break;
 485                 default:
 486                         break;
 487                 }
 488         }
 489
 490         return type;
 491 }
 492
 493 const char *get_deprecated_string(const attribute_t *attribute)
 494 {
 495         for ( ; attribute != NULL; attribute = attribute->next) {
 496                 if (attribute->kind != ATTRIBUTE_MS_DEPRECATED)
 497                         continue;
 498
 499                 attribute_argument_t *argument = attribute->a.arguments;
 500                 return get_argument_string(argument);
 501         }
 502         return NULL;
 503 }
 504
 505 static bool property_attribute_equal(const attribute_property_argument_t *prop1,
 506                                      const attribute_property_argument_t *prop2)
 507 {
 508         return prop1->put_symbol == prop2->put_symbol
 509                 && prop1->get_symbol == prop2->get_symbol;
 510 }
 511
 512 static bool attribute_argument_equal(const attribute_argument_t *arg1,
 513                                      const attribute_argument_t *arg2)
 514 {
 515         if (arg1->kind != arg2->kind)
 516                 return false;
 517
 518         switch (arg1->kind) {
 519         case ATTRIBUTE_ARGUMENT_SYMBOL:
 520                 return arg1->v.symbol == arg2->v.symbol;
 521         case ATTRIBUTE_ARGUMENT_EXPRESSION:
 522                 /* TODO */
 523                 return false;
 524         }
 525         panic("Unknown argument type found");
 526 }
 527
 528 static bool attribute_arguments_equal(const attribute_argument_t *args1,
 529                                       const attribute_argument_t *args2)
 530 {
 531         for ( ; args1 != NULL && args2 != NULL;
 532              args1 = args1->next, args2 = args2->next) {
 533                 if (!attribute_argument_equal(args1, args2))
 534                         return false;
 535         }
 536         /* both should be NULL now */
 537         return args1 == args2;
 538 }
 539
 540 bool attributes_equal(const attribute_t *attr1, const attribute_t *attr2)
 541 {
 542         if (attr1->kind != attr2->kind)
 543                 return false;
 544
 545         switch (attr1->kind) {
 546         case ATTRIBUTE_MS_PROPERTY:
 547                 return property_attribute_equal(attr1->a.property, attr2->a.property);
 548         default:
 549                 return attribute_arguments_equal(attr1->a.arguments,
 550                                                  attr2->a.arguments);
 551         }
 552 }