diff options
Diffstat (limited to 'contrib/llvm/tools/clang/lib/AST/AttrImpl.cpp')
| -rw-r--r-- | contrib/llvm/tools/clang/lib/AST/AttrImpl.cpp | 205 |
1 files changed, 205 insertions, 0 deletions
diff --git a/contrib/llvm/tools/clang/lib/AST/AttrImpl.cpp b/contrib/llvm/tools/clang/lib/AST/AttrImpl.cpp new file mode 100644 index 0000000..0fab22c --- /dev/null +++ b/contrib/llvm/tools/clang/lib/AST/AttrImpl.cpp @@ -0,0 +1,205 @@ +//===--- AttrImpl.cpp - Classes for representing attributes -----*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file contains out-of-line virtual methods for Attr classes. +// +//===----------------------------------------------------------------------===// + +#include "clang/AST/Attr.h" +#include "clang/AST/ASTContext.h" +using namespace clang; + +void Attr::Destroy(ASTContext &C) { + if (Next) { + Next->Destroy(C); + Next = 0; + } + this->~Attr(); + C.Deallocate((void*)this); +} + +AttrWithString::AttrWithString(Attr::Kind AK, ASTContext &C, llvm::StringRef s) + : Attr(AK) { + assert(!s.empty()); + StrLen = s.size(); + Str = new (C) char[StrLen]; + memcpy(const_cast<char*>(Str), s.data(), StrLen); +} + +void AttrWithString::Destroy(ASTContext &C) { + C.Deallocate(const_cast<char*>(Str)); + Attr::Destroy(C); +} + +void AttrWithString::ReplaceString(ASTContext &C, llvm::StringRef newS) { + if (newS.size() > StrLen) { + C.Deallocate(const_cast<char*>(Str)); + Str = new (C) char[newS.size()]; + } + StrLen = newS.size(); + memcpy(const_cast<char*>(Str), newS.data(), StrLen); +} + +void FormatAttr::setType(ASTContext &C, llvm::StringRef type) { + ReplaceString(C, type); +} + +NonNullAttr::NonNullAttr(ASTContext &C, unsigned* arg_nums, unsigned size) + : Attr(NonNull), ArgNums(0), Size(0) { + if (size == 0) + return; + assert(arg_nums); + ArgNums = new (C) unsigned[size]; + Size = size; + memcpy(ArgNums, arg_nums, sizeof(*ArgNums)*size); +} + +void NonNullAttr::Destroy(ASTContext &C) { + if (ArgNums) + C.Deallocate(ArgNums); + Attr::Destroy(C); +} + +#define DEF_SIMPLE_ATTR_CLONE(ATTR) \ + Attr *ATTR##Attr::clone(ASTContext &C) const { \ + return ::new (C) ATTR##Attr; \ + } + +// FIXME: Can we use variadic macro to define DEF_SIMPLE_ATTR_CLONE for +// "non-simple" classes? + +DEF_SIMPLE_ATTR_CLONE(AlignMac68k) +DEF_SIMPLE_ATTR_CLONE(AlwaysInline) +DEF_SIMPLE_ATTR_CLONE(AnalyzerNoReturn) +DEF_SIMPLE_ATTR_CLONE(BaseCheck) +DEF_SIMPLE_ATTR_CLONE(CDecl) +DEF_SIMPLE_ATTR_CLONE(CFReturnsNotRetained) +DEF_SIMPLE_ATTR_CLONE(CFReturnsRetained) +DEF_SIMPLE_ATTR_CLONE(Const) +DEF_SIMPLE_ATTR_CLONE(DLLExport) +DEF_SIMPLE_ATTR_CLONE(DLLImport) +DEF_SIMPLE_ATTR_CLONE(Deprecated) +DEF_SIMPLE_ATTR_CLONE(FastCall) +DEF_SIMPLE_ATTR_CLONE(Final) +DEF_SIMPLE_ATTR_CLONE(Hiding) +DEF_SIMPLE_ATTR_CLONE(Malloc) +DEF_SIMPLE_ATTR_CLONE(NSReturnsNotRetained) +DEF_SIMPLE_ATTR_CLONE(NSReturnsRetained) +DEF_SIMPLE_ATTR_CLONE(NoDebug) +DEF_SIMPLE_ATTR_CLONE(NoInline) +DEF_SIMPLE_ATTR_CLONE(NoReturn) +DEF_SIMPLE_ATTR_CLONE(NoThrow) +DEF_SIMPLE_ATTR_CLONE(ObjCException) +DEF_SIMPLE_ATTR_CLONE(ObjCNSObject) +DEF_SIMPLE_ATTR_CLONE(Override) +DEF_SIMPLE_ATTR_CLONE(Packed) +DEF_SIMPLE_ATTR_CLONE(Pure) +DEF_SIMPLE_ATTR_CLONE(StdCall) +DEF_SIMPLE_ATTR_CLONE(ThisCall) +DEF_SIMPLE_ATTR_CLONE(TransparentUnion) +DEF_SIMPLE_ATTR_CLONE(Unavailable) +DEF_SIMPLE_ATTR_CLONE(Unused) +DEF_SIMPLE_ATTR_CLONE(Used) +DEF_SIMPLE_ATTR_CLONE(WarnUnusedResult) +DEF_SIMPLE_ATTR_CLONE(Weak) +DEF_SIMPLE_ATTR_CLONE(WeakImport) +DEF_SIMPLE_ATTR_CLONE(WeakRef) +DEF_SIMPLE_ATTR_CLONE(X86ForceAlignArgPointer) + +Attr* MaxFieldAlignmentAttr::clone(ASTContext &C) const { + return ::new (C) MaxFieldAlignmentAttr(Alignment); +} + +Attr* AlignedAttr::clone(ASTContext &C) const { + return ::new (C) AlignedAttr(Alignment); +} + +Attr* AnnotateAttr::clone(ASTContext &C) const { + return ::new (C) AnnotateAttr(C, getAnnotation()); +} + +Attr *AsmLabelAttr::clone(ASTContext &C) const { + return ::new (C) AsmLabelAttr(C, getLabel()); +} + +Attr *AliasAttr::clone(ASTContext &C) const { + return ::new (C) AliasAttr(C, getAliasee()); +} + +Attr *ConstructorAttr::clone(ASTContext &C) const { + return ::new (C) ConstructorAttr(priority); +} + +Attr *DestructorAttr::clone(ASTContext &C) const { + return ::new (C) DestructorAttr(priority); +} + +Attr *IBOutletAttr::clone(ASTContext &C) const { + return ::new (C) IBOutletAttr; +} + +Attr *IBOutletCollectionAttr::clone(ASTContext &C) const { + return ::new (C) IBOutletCollectionAttr(D); +} + +Attr *IBActionAttr::clone(ASTContext &C) const { + return ::new (C) IBActionAttr; +} + +Attr *GNUInlineAttr::clone(ASTContext &C) const { + return ::new (C) GNUInlineAttr; +} + +Attr *SectionAttr::clone(ASTContext &C) const { + return ::new (C) SectionAttr(C, getName()); +} + +Attr *NonNullAttr::clone(ASTContext &C) const { + return ::new (C) NonNullAttr(C, ArgNums, Size); +} + +Attr *FormatAttr::clone(ASTContext &C) const { + return ::new (C) FormatAttr(C, getType(), formatIdx, firstArg); +} + +Attr *FormatArgAttr::clone(ASTContext &C) const { + return ::new (C) FormatArgAttr(formatIdx); +} + +Attr *SentinelAttr::clone(ASTContext &C) const { + return ::new (C) SentinelAttr(sentinel, NullPos); +} + +Attr *VisibilityAttr::clone(ASTContext &C) const { + return ::new (C) VisibilityAttr(VisibilityType); +} + +Attr *OverloadableAttr::clone(ASTContext &C) const { + return ::new (C) OverloadableAttr; +} + +Attr *BlocksAttr::clone(ASTContext &C) const { + return ::new (C) BlocksAttr(BlocksAttrType); +} + +Attr *CleanupAttr::clone(ASTContext &C) const { + return ::new (C) CleanupAttr(FD); +} + +Attr *RegparmAttr::clone(ASTContext &C) const { + return ::new (C) RegparmAttr(NumParams); +} + +Attr *ReqdWorkGroupSizeAttr::clone(ASTContext &C) const { + return ::new (C) ReqdWorkGroupSizeAttr(X, Y, Z); +} + +Attr *MSP430InterruptAttr::clone(ASTContext &C) const { + return ::new (C) MSP430InterruptAttr(Number); +} |
