contrib/llvm/tools/clang/include/clang/AST/Mangle.h

   1 //===--- Mangle.h - Mangle C++ Names ----------------------------*- 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 // Defines the C++ name mangling interface.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_CLANG_AST_MANGLE_H
  15 #define LLVM_CLANG_AST_MANGLE_H
  16
  17 #include "clang/AST/Type.h"
  18 #include "clang/Basic/ABI.h"
  19 #include "llvm/ADT/DenseMap.h"
  20 #include "llvm/ADT/StringRef.h"
  21 #include "llvm/ADT/SmallString.h"
  22 #include "llvm/Support/raw_ostream.h"
  23
  24 namespace clang {
  25   class ASTContext;
  26   class BlockDecl;
  27   class CXXConstructorDecl;
  28   class CXXDestructorDecl;
  29   class CXXMethodDecl;
  30   class FunctionDecl;
  31   class NamedDecl;
  32   class ObjCMethodDecl;
  33   class VarDecl;
  34   struct ThisAdjustment;
  35   struct ThunkInfo;
  36
  37 /// MangleBuffer - a convenient class for storing a name which is
  38 /// either the result of a mangling or is a constant string with
  39 /// external memory ownership.
  40 class MangleBuffer {
  41 public:
  42   void setString(StringRef Ref) {
  43     String = Ref;
  44   }
  45
  46   SmallVectorImpl<char> &getBuffer() {
  47     return Buffer;
  48   }
  49
  50   StringRef getString() const {
  51     if (!String.empty()) return String;
  52     return Buffer.str();
  53   }
  54
  55   operator StringRef() const {
  56     return getString();
  57   }
  58
  59 private:
  60   StringRef String;
  61   llvm::SmallString<256> Buffer;
  62 };
  63
  64 /// MangleContext - Context for tracking state which persists across multiple
  65 /// calls to the C++ name mangler.
  66 class MangleContext {
  67   ASTContext &Context;
  68   DiagnosticsEngine &Diags;
  69
  70   llvm::DenseMap<const BlockDecl*, unsigned> GlobalBlockIds;
  71   llvm::DenseMap<const BlockDecl*, unsigned> LocalBlockIds;
  72
  73 public:
  74   explicit MangleContext(ASTContext &Context,
  75                          DiagnosticsEngine &Diags)
  76     : Context(Context), Diags(Diags) { }
  77
  78   virtual ~MangleContext() { }
  79
  80   ASTContext &getASTContext() const { return Context; }
  81
  82   DiagnosticsEngine &getDiags() const { return Diags; }
  83
  84   virtual void startNewFunction() { LocalBlockIds.clear(); }
  85
  86   unsigned getBlockId(const BlockDecl *BD, bool Local) {
  87     llvm::DenseMap<const BlockDecl *, unsigned> &BlockIds
  88       = Local? LocalBlockIds : GlobalBlockIds;
  89     std::pair<llvm::DenseMap<const BlockDecl *, unsigned>::iterator, bool>
  90       Result = BlockIds.insert(std::make_pair(BD, BlockIds.size()));
  91     return Result.first->second;
  92   }
  93
  94   /// @name Mangler Entry Points
  95   /// @{
  96
  97   virtual bool shouldMangleDeclName(const NamedDecl *D) = 0;
  98   virtual void mangleName(const NamedDecl *D, raw_ostream &)=0;
  99   virtual void mangleThunk(const CXXMethodDecl *MD,
 100                           const ThunkInfo &Thunk,
 101                           raw_ostream &) = 0;
 102   virtual void mangleCXXDtorThunk(const CXXDestructorDecl *DD, CXXDtorType Type,
 103                                   const ThisAdjustment &ThisAdjustment,
 104                                   raw_ostream &) = 0;
 105   virtual void mangleReferenceTemporary(const VarDecl *D,
 106                                         raw_ostream &) = 0;
 107   virtual void mangleCXXVTable(const CXXRecordDecl *RD,
 108                                raw_ostream &) = 0;
 109   virtual void mangleCXXVTT(const CXXRecordDecl *RD,
 110                             raw_ostream &) = 0;
 111   virtual void mangleCXXCtorVTable(const CXXRecordDecl *RD, int64_t Offset,
 112                                    const CXXRecordDecl *Type,
 113                                    raw_ostream &) = 0;
 114   virtual void mangleCXXRTTI(QualType T, raw_ostream &) = 0;
 115   virtual void mangleCXXRTTIName(QualType T, raw_ostream &) = 0;
 116   virtual void mangleCXXCtor(const CXXConstructorDecl *D, CXXCtorType Type,
 117                              raw_ostream &) = 0;
 118   virtual void mangleCXXDtor(const CXXDestructorDecl *D, CXXDtorType Type,
 119                              raw_ostream &) = 0;
 120
 121   void mangleGlobalBlock(const BlockDecl *BD,
 122                          raw_ostream &Out);
 123   void mangleCtorBlock(const CXXConstructorDecl *CD, CXXCtorType CT,
 124                        const BlockDecl *BD, raw_ostream &Out);
 125   void mangleDtorBlock(const CXXDestructorDecl *CD, CXXDtorType DT,
 126                        const BlockDecl *BD, raw_ostream &Out);
 127   void mangleBlock(const DeclContext *DC, const BlockDecl *BD,
 128                    raw_ostream &Out);
 129   // Do the right thing.
 130   void mangleBlock(const BlockDecl *BD, raw_ostream &Out);
 131
 132   void mangleObjCMethodName(const ObjCMethodDecl *MD,
 133                             raw_ostream &);
 134
 135   // This is pretty lame.
 136   virtual void mangleItaniumGuardVariable(const VarDecl *D,
 137                                           raw_ostream &) {
 138     llvm_unreachable("Target does not support mangling guard variables");
 139   }
 140   /// @}
 141 };
 142
 143 MangleContext *createItaniumMangleContext(ASTContext &Context,
 144                                           DiagnosticsEngine &Diags);
 145 MangleContext *createMicrosoftMangleContext(ASTContext &Context,
 146                                             DiagnosticsEngine &Diags);
 147
 148 }
 149
 150 #endif