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
24namespace 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.
40class MangleBuffer {
41public:
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
59private:
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.
66class MangleContext {
67  ASTContext &Context;
68  DiagnosticsEngine &Diags;
69
70  llvm::DenseMap<const BlockDecl*, unsigned> GlobalBlockIds;
71  llvm::DenseMap<const BlockDecl*, unsigned> LocalBlockIds;
72
73public:
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
143MangleContext *createItaniumMangleContext(ASTContext &Context,
144                                          DiagnosticsEngine &Diags);
145MangleContext *createMicrosoftMangleContext(ASTContext &Context,
146                                            DiagnosticsEngine &Diags);
147
148}
149
150#endif
151