← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/clamav/jaunty-backports

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/lib/Target/Mangler.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2010-03-12 11:30:04 UTC
  • mfrom: (1.39.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 11.
  • Revision ID: james.westby@ubuntu.com-20100312113004-b0fop4bkycszdd0z
Tags: 0.96~rc1+dfsg-0ubuntu1
https://launchpad.net/bugs/537636
* New upstream RC - FFE (LP: #537636):
  - Add OfficialDatabaseOnly option to clamav-base.postinst.in
  - Add LocalSocketGroup option to clamav-base.postinst.in
  - Add LocalSocketMode option to clamav-base.postinst.in
  - Add CrossFilesystems option to clamav-base.postinst.in
  - Add ClamukoScannerCount option to clamav-base.postinst.in
  - Add BytecodeSecurity opiton to clamav-base.postinst.in
  - Add DetectionStatsHostID option to clamav-freshclam.postinst.in
  - Add Bytecode option to clamav-freshclam.postinst.in
  - Add MilterSocketGroup option to clamav-milter.postinst.in
  - Add MilterSocketMode option to clamav-milter.postinst.in
  - Add ReportHostname option to clamav-milter.postinst.in
  - Bump libclamav SO version to 6.1.0 in libclamav6.install
  - Drop clamdmon from clamav.examples (no longer shipped by upstream)
  - Drop libclamav.a from libclamav-dev.install (not built by upstream)
  - Update SO version for lintian override for libclamav6
  - Add new Bytecode Testing Tool, usr/bin/clambc, to clamav.install
  - Add build-depends on python and python-setuptools for new test suite
  - Update debian/copyright for the embedded copy of llvm (using the system
    llvm is not currently feasible)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/lib/Target/Mangler.cpp
 
1
//===-- Mangler.cpp - Self-contained c/asm llvm name mangler --------------===//
 
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
// Unified name mangler for assembly backends.
 
11
//
 
12
//===----------------------------------------------------------------------===//
 
13
 
 
14
#include "llvm/Target/Mangler.h"
 
15
#include "llvm/GlobalValue.h"
 
16
#include "llvm/MC/MCAsmInfo.h"
 
17
#include "llvm/ADT/SmallString.h"
 
18
#include "llvm/ADT/Twine.h"
 
19
using namespace llvm;
 
20
 
 
21
static bool isAcceptableChar(char C) {
 
22
  if ((C < 'a' || C > 'z') &&
 
23
      (C < 'A' || C > 'Z') &&
 
24
      (C < '0' || C > '9') &&
 
25
      C != '_' && C != '$' && C != '.' && C != '@')
 
26
    return false;
 
27
  return true;
 
28
}
 
29
 
 
30
static char HexDigit(int V) {
 
31
  return V < 10 ? V+'0' : V+'A'-10;
 
32
}
 
33
 
 
34
static void MangleLetter(SmallVectorImpl<char> &OutName, unsigned char C) {
 
35
  OutName.push_back('_');
 
36
  OutName.push_back(HexDigit(C >> 4));
 
37
  OutName.push_back(HexDigit(C & 15));
 
38
  OutName.push_back('_');
 
39
}
 
40
 
 
41
/// NameNeedsEscaping - Return true if the identifier \arg Str needs quotes
 
42
/// for this assembler.
 
43
static bool NameNeedsEscaping(StringRef Str, const MCAsmInfo &MAI) {
 
44
  assert(!Str.empty() && "Cannot create an empty MCSymbol");
 
45
  
 
46
  // If the first character is a number and the target does not allow this, we
 
47
  // need quotes.
 
48
  if (!MAI.doesAllowNameToStartWithDigit() && Str[0] >= '0' && Str[0] <= '9')
 
49
    return true;
 
50
  
 
51
  // If any of the characters in the string is an unacceptable character, force
 
52
  // quotes.
 
53
  for (unsigned i = 0, e = Str.size(); i != e; ++i)
 
54
    if (!isAcceptableChar(Str[i]))
 
55
      return true;
 
56
  return false;
 
57
}
 
58
 
 
59
/// appendMangledName - Add the specified string in mangled form if it uses
 
60
/// any unusual characters.
 
61
static void appendMangledName(SmallVectorImpl<char> &OutName, StringRef Str,
 
62
                              const MCAsmInfo *MAI) {
 
63
  // The first character is not allowed to be a number unless the target
 
64
  // explicitly allows it.
 
65
  if ((MAI == 0 || !MAI->doesAllowNameToStartWithDigit()) &&
 
66
      Str[0] >= '0' && Str[0] <= '9') {
 
67
    MangleLetter(OutName, Str[0]);
 
68
    Str = Str.substr(1);
 
69
  }
 
70
  
 
71
  for (unsigned i = 0, e = Str.size(); i != e; ++i) {
 
72
    if (!isAcceptableChar(Str[i]))
 
73
      MangleLetter(OutName, Str[i]);
 
74
    else
 
75
      OutName.push_back(Str[i]);
 
76
  }
 
77
}
 
78
 
 
79
 
 
80
/// appendMangledQuotedName - On systems that support quoted symbols, we still
 
81
/// have to escape some (obscure) characters like " and \n which would break the
 
82
/// assembler's lexing.
 
83
static void appendMangledQuotedName(SmallVectorImpl<char> &OutName,
 
84
                                   StringRef Str) {
 
85
  for (unsigned i = 0, e = Str.size(); i != e; ++i) {
 
86
    if (Str[i] == '"' || Str[i] == '\n')
 
87
      MangleLetter(OutName, Str[i]);
 
88
    else
 
89
      OutName.push_back(Str[i]);
 
90
  }
 
91
}
 
92
 
 
93
 
 
94
/// getNameWithPrefix - Fill OutName with the name of the appropriate prefix
 
95
/// and the specified name as the global variable name.  GVName must not be
 
96
/// empty.
 
97
void Mangler::getNameWithPrefix(SmallVectorImpl<char> &OutName,
 
98
                                const Twine &GVName, ManglerPrefixTy PrefixTy) {
 
99
  SmallString<256> TmpData;
 
100
  StringRef Name = GVName.toStringRef(TmpData);
 
101
  assert(!Name.empty() && "getNameWithPrefix requires non-empty name");
 
102
  
 
103
  // If the global name is not led with \1, add the appropriate prefixes.
 
104
  if (Name[0] == '\1') {
 
105
    Name = Name.substr(1);
 
106
  } else {
 
107
    if (PrefixTy == Mangler::Private) {
 
108
      const char *Prefix = MAI.getPrivateGlobalPrefix();
 
109
      OutName.append(Prefix, Prefix+strlen(Prefix));
 
110
    } else if (PrefixTy == Mangler::LinkerPrivate) {
 
111
      const char *Prefix = MAI.getLinkerPrivateGlobalPrefix();
 
112
      OutName.append(Prefix, Prefix+strlen(Prefix));
 
113
    }
 
114
 
 
115
    const char *Prefix = MAI.getGlobalPrefix();
 
116
    if (Prefix[0] == 0)
 
117
      ; // Common noop, no prefix.
 
118
    else if (Prefix[1] == 0)
 
119
      OutName.push_back(Prefix[0]);  // Common, one character prefix.
 
120
    else
 
121
      OutName.append(Prefix, Prefix+strlen(Prefix)); // Arbitrary length prefix.
 
122
  }
 
123
  
 
124
  // If this is a simple string that doesn't need escaping, just append it.
 
125
  if (!NameNeedsEscaping(Name, MAI) ||
 
126
      // If quotes are supported, they can be used unless the string contains
 
127
      // a quote or newline.
 
128
      (MAI.doesAllowQuotesInName() &&
 
129
       Name.find_first_of("\n\"") == StringRef::npos)) {
 
130
    OutName.append(Name.begin(), Name.end());
 
131
    return;
 
132
  }
 
133
  
 
134
  // On systems that do not allow quoted names, we need to mangle most
 
135
  // strange characters.
 
136
  if (!MAI.doesAllowQuotesInName())
 
137
    return appendMangledName(OutName, Name, &MAI);
 
138
  
 
139
  // Okay, the system allows quoted strings.  We can quote most anything, the
 
140
  // only characters that need escaping are " and \n.
 
141
  assert(Name.find_first_of("\n\"") != StringRef::npos);
 
142
  return appendMangledQuotedName(OutName, Name);
 
143
}
 
144
 
 
145
 
 
146
/// getNameWithPrefix - Fill OutName with the name of the appropriate prefix
 
147
/// and the specified global variable's name.  If the global variable doesn't
 
148
/// have a name, this fills in a unique name for the global.
 
149
void Mangler::getNameWithPrefix(SmallVectorImpl<char> &OutName,
 
150
                                const GlobalValue *GV,
 
151
                                bool isImplicitlyPrivate) {
 
152
  ManglerPrefixTy PrefixTy = Mangler::Default;
 
153
  if (GV->hasPrivateLinkage() || isImplicitlyPrivate)
 
154
    PrefixTy = Mangler::Private;
 
155
  else if (GV->hasLinkerPrivateLinkage())
 
156
    PrefixTy = Mangler::LinkerPrivate;
 
157
  
 
158
  // If this global has a name, handle it simply.
 
159
  if (GV->hasName())
 
160
    return getNameWithPrefix(OutName, GV->getName(), PrefixTy);
 
161
  
 
162
  // Get the ID for the global, assigning a new one if we haven't got one
 
163
  // already.
 
164
  unsigned &ID = AnonGlobalIDs[GV];
 
165
  if (ID == 0) ID = NextAnonGlobalID++;
 
166
  
 
167
  // Must mangle the global into a unique ID.
 
168
  getNameWithPrefix(OutName, "__unnamed_" + Twine(ID), PrefixTy);
 
169
}
 
170
 
 
171
/// getNameWithPrefix - Fill OutName with the name of the appropriate prefix
 
172
/// and the specified global variable's name.  If the global variable doesn't
 
173
/// have a name, this fills in a unique name for the global.
 
174
std::string Mangler::getNameWithPrefix(const GlobalValue *GV,
 
175
                                       bool isImplicitlyPrivate) {
 
176
  SmallString<64> Buf;
 
177
  getNameWithPrefix(Buf, GV, isImplicitlyPrivate);
 
178
  return std::string(Buf.begin(), Buf.end());
 
179
}