contrib/llvm/tools/clang/lib/Sema/TargetAttributesSema.cpp

   1 //===-- TargetAttributesSema.cpp - Encapsulate target attributes-*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains semantic analysis implementation for target-specific
  11 // attributes.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "TargetAttributesSema.h"
  16 #include "clang/Sema/SemaInternal.h"
  17 #include "clang/Basic/TargetInfo.h"
  18 #include "clang/AST/DeclCXX.h"
  19 #include "llvm/ADT/Triple.h"
  20
  21 using namespace clang;
  22
  23 TargetAttributesSema::~TargetAttributesSema() {}
  24 bool TargetAttributesSema::ProcessDeclAttribute(Scope *scope, Decl *D,
  25                                     const AttributeList &Attr, Sema &S) const {
  26   return false;
  27 }
  28
  29 static void HandleMSP430InterruptAttr(Decl *d,
  30                                       const AttributeList &Attr, Sema &S) {
  31     // Check the attribute arguments.
  32     if (Attr.getNumArgs() != 1) {
  33       S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
  34       return;
  35     }
  36
  37     // FIXME: Check for decl - it should be void ()(void).
  38
  39     Expr *NumParamsExpr = static_cast<Expr *>(Attr.getArg(0));
  40     llvm::APSInt NumParams(32);
  41     if (!NumParamsExpr->isIntegerConstantExpr(NumParams, S.Context)) {
  42       S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
  43         << "interrupt" << NumParamsExpr->getSourceRange();
  44       return;
  45     }
  46
  47     unsigned Num = NumParams.getLimitedValue(255);
  48     if ((Num & 1) || Num > 30) {
  49       S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
  50         << "interrupt" << (int)NumParams.getSExtValue()
  51         << NumParamsExpr->getSourceRange();
  52       return;
  53     }
  54
  55     d->addAttr(::new (S.Context) MSP430InterruptAttr(Attr.getLoc(), S.Context, Num));
  56     d->addAttr(::new (S.Context) UsedAttr(Attr.getLoc(), S.Context));
  57   }
  58
  59 namespace {
  60   class MSP430AttributesSema : public TargetAttributesSema {
  61   public:
  62     MSP430AttributesSema() { }
  63     bool ProcessDeclAttribute(Scope *scope, Decl *D,
  64                               const AttributeList &Attr, Sema &S) const {
  65       if (Attr.getName()->getName() == "interrupt") {
  66         HandleMSP430InterruptAttr(D, Attr, S);
  67         return true;
  68       }
  69       return false;
  70     }
  71   };
  72 }
  73
  74 static void HandleMBlazeInterruptHandlerAttr(Decl *d, const AttributeList &Attr,
  75                                              Sema &S) {
  76   // Check the attribute arguments.
  77   if (Attr.getNumArgs() != 0) {
  78     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
  79     return;
  80   }
  81
  82   // FIXME: Check for decl - it should be void ()(void).
  83
  84   d->addAttr(::new (S.Context) MBlazeInterruptHandlerAttr(Attr.getLoc(),
  85                                                           S.Context));
  86   d->addAttr(::new (S.Context) UsedAttr(Attr.getLoc(), S.Context));
  87 }
  88
  89 static void HandleMBlazeSaveVolatilesAttr(Decl *d, const AttributeList &Attr,
  90                                           Sema &S) {
  91   // Check the attribute arguments.
  92   if (Attr.getNumArgs() != 0) {
  93     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
  94     return;
  95   }
  96
  97   // FIXME: Check for decl - it should be void ()(void).
  98
  99   d->addAttr(::new (S.Context) MBlazeSaveVolatilesAttr(Attr.getLoc(),
 100                                                        S.Context));
 101   d->addAttr(::new (S.Context) UsedAttr(Attr.getLoc(), S.Context));
 102 }
 103
 104
 105 namespace {
 106   class MBlazeAttributesSema : public TargetAttributesSema {
 107   public:
 108     MBlazeAttributesSema() { }
 109     bool ProcessDeclAttribute(Scope *scope, Decl *D, const AttributeList &Attr,
 110                               Sema &S) const {
 111       if (Attr.getName()->getName() == "interrupt_handler") {
 112         HandleMBlazeInterruptHandlerAttr(D, Attr, S);
 113         return true;
 114       } else if (Attr.getName()->getName() == "save_volatiles") {
 115         HandleMBlazeSaveVolatilesAttr(D, Attr, S);
 116         return true;
 117       }
 118       return false;
 119     }
 120   };
 121 }
 122
 123 static void HandleX86ForceAlignArgPointerAttr(Decl *D,
 124                                               const AttributeList& Attr,
 125                                               Sema &S) {
 126   // Check the attribute arguments.
 127   if (Attr.getNumArgs() != 0) {
 128     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
 129     return;
 130   }
 131
 132   // If we try to apply it to a function pointer, don't warn, but don't
 133   // do anything, either. It doesn't matter anyway, because there's nothing
 134   // special about calling a force_align_arg_pointer function.
 135   ValueDecl *VD = dyn_cast<ValueDecl>(D);
 136   if (VD && VD->getType()->isFunctionPointerType())
 137     return;
 138   // Also don't warn on function pointer typedefs.
 139   TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D);
 140   if (TD && (TD->getUnderlyingType()->isFunctionPointerType() ||
 141              TD->getUnderlyingType()->isFunctionType()))
 142     return;
 143   // Attribute can only be applied to function types.
 144   if (!isa<FunctionDecl>(D)) {
 145     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
 146       << Attr.getName() << /* function */0;
 147     return;
 148   }
 149
 150   D->addAttr(::new (S.Context) X86ForceAlignArgPointerAttr(Attr.getRange(),
 151                                                            S.Context));
 152 }
 153
 154 DLLImportAttr *Sema::mergeDLLImportAttr(Decl *D, SourceRange Range) {
 155   if (D->hasAttr<DLLExportAttr>()) {
 156     Diag(Range.getBegin(), diag::warn_attribute_ignored) << "dllimport";
 157     return NULL;
 158   }
 159
 160   if (D->hasAttr<DLLImportAttr>())
 161     return NULL;
 162
 163   return ::new (Context) DLLImportAttr(Range, Context);
 164 }
 165
 166 static void HandleDLLImportAttr(Decl *D, const AttributeList &Attr, Sema &S) {
 167   // check the attribute arguments.
 168   if (Attr.getNumArgs() != 0) {
 169     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
 170     return;
 171   }
 172
 173   // Attribute can be applied only to functions or variables.
 174   FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
 175   if (!FD && !isa<VarDecl>(D)) {
 176     // Apparently Visual C++ thinks it is okay to not emit a warning
 177     // in this case, so only emit a warning when -fms-extensions is not
 178     // specified.
 179     if (!S.getLangOpts().MicrosoftExt)
 180       S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
 181         << Attr.getName() << 2 /*variable and function*/;
 182     return;
 183   }
 184
 185   // Currently, the dllimport attribute is ignored for inlined functions.
 186   // Warning is emitted.
 187   if (FD && FD->isInlineSpecified()) {
 188     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "dllimport";
 189     return;
 190   }
 191
 192   DLLImportAttr *NewAttr = S.mergeDLLImportAttr(D, Attr.getRange());
 193   if (NewAttr)
 194     D->addAttr(NewAttr);
 195 }
 196
 197 DLLExportAttr *Sema::mergeDLLExportAttr(Decl *D, SourceRange Range) {
 198   if (DLLImportAttr *Import = D->getAttr<DLLImportAttr>()) {
 199     Diag(Import->getLocation(), diag::warn_attribute_ignored) << "dllimport";
 200     D->dropAttr<DLLImportAttr>();
 201   }
 202
 203   if (D->hasAttr<DLLExportAttr>())
 204     return NULL;
 205
 206   return ::new (Context) DLLExportAttr(Range, Context);
 207 }
 208
 209 static void HandleDLLExportAttr(Decl *D, const AttributeList &Attr, Sema &S) {
 210   // check the attribute arguments.
 211   if (Attr.getNumArgs() != 0) {
 212     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
 213     return;
 214   }
 215
 216   // Attribute can be applied only to functions or variables.
 217   FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
 218   if (!FD && !isa<VarDecl>(D)) {
 219     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
 220       << Attr.getName() << 2 /*variable and function*/;
 221     return;
 222   }
 223
 224   // Currently, the dllexport attribute is ignored for inlined functions, unless
 225   // the -fkeep-inline-functions flag has been used. Warning is emitted;
 226   if (FD && FD->isInlineSpecified()) {
 227     // FIXME: ... unless the -fkeep-inline-functions flag has been used.
 228     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "dllexport";
 229     return;
 230   }
 231
 232   DLLExportAttr *NewAttr = S.mergeDLLExportAttr(D, Attr.getRange());
 233   if (NewAttr)
 234     D->addAttr(NewAttr);
 235 }
 236
 237 namespace {
 238   class X86AttributesSema : public TargetAttributesSema {
 239   public:
 240     X86AttributesSema() { }
 241     bool ProcessDeclAttribute(Scope *scope, Decl *D,
 242                               const AttributeList &Attr, Sema &S) const {
 243       const llvm::Triple &Triple(S.Context.getTargetInfo().getTriple());
 244       if (Triple.getOS() == llvm::Triple::Win32 ||
 245           Triple.getOS() == llvm::Triple::MinGW32) {
 246         switch (Attr.getKind()) {
 247         case AttributeList::AT_DLLImport: HandleDLLImportAttr(D, Attr, S);
 248                                           return true;
 249         case AttributeList::AT_DLLExport: HandleDLLExportAttr(D, Attr, S);
 250                                           return true;
 251         default:                          break;
 252         }
 253       }
 254       if (Triple.getArch() != llvm::Triple::x86_64 &&
 255           (Attr.getName()->getName() == "force_align_arg_pointer" ||
 256            Attr.getName()->getName() == "__force_align_arg_pointer__")) {
 257         HandleX86ForceAlignArgPointerAttr(D, Attr, S);
 258         return true;
 259       }
 260       return false;
 261     }
 262   };
 263 }
 264
 265 const TargetAttributesSema &Sema::getTargetAttributesSema() const {
 266   if (TheTargetAttributesSema)
 267     return *TheTargetAttributesSema;
 268
 269   const llvm::Triple &Triple(Context.getTargetInfo().getTriple());
 270   switch (Triple.getArch()) {
 271   case llvm::Triple::msp430:
 272     return *(TheTargetAttributesSema = new MSP430AttributesSema);
 273   case llvm::Triple::mblaze:
 274     return *(TheTargetAttributesSema = new MBlazeAttributesSema);
 275   case llvm::Triple::x86:
 276   case llvm::Triple::x86_64:
 277     return *(TheTargetAttributesSema = new X86AttributesSema);
 278   default:
 279     return *(TheTargetAttributesSema = new TargetAttributesSema);
 280   }
 281 }