← Back to branch summary

~ubuntu-branches/ubuntu/wily/clamav/wily-proposed

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/lib/VMCore/DebugLoc.cpp

  • Committer: Package Import Robot
  • Author(s): Scott Kitterman, Sebastian Andrzej Siewior, Andreas Cadhalpun, Scott Kitterman, Javier Fernández-Sanguino
  • Date: 2015-01-28 00:25:13 UTC
  • mfrom: (0.48.14 sid)
  • Revision ID: package-import@ubuntu.com-20150128002513-lil2oi74cooy4lzr
Tags: 0.98.6+dfsg-1
http://bugs.debian.org/774686
http://bugs.debian.org/767350
http://bugs.debian.org/775400
http://bugs.debian.org/767353
http://bugs.debian.org/773563
[ Sebastian Andrzej Siewior ]
* update "fix-ssize_t-size_t-off_t-printf-modifier", include of misc.h was
  missing but was pulled in via the systemd patch.
* Don't leak return codes from libmspack to clamav API. (Closes: #774686).

[ Andreas Cadhalpun ]
* Add patch to avoid emitting incremental progress messages when not
  outputting to a terminal. (Closes: #767350)
* Update lintian-overrides for unused-file-paragraph-in-dep5-copyright.
* clamav-base.postinst: always chown /var/log/clamav and /var/lib/clamav
  to clamav:clamav, not only on fresh installations. (Closes: #775400)
* Adapt the clamav-daemon and clamav-freshclam logrotate scripts,
  so that they correctly work under systemd.
* Move the PidFile variable from the clamd/freshclam configuration files
  to the init scripts. This makes the init scripts more robust against
  misconfiguration and avoids error messages with systemd. (Closes: #767353)
* debian/copyright: drop files from Files-Excluded only present in github
  tarballs
* Drop Workaround-a-bug-in-libc-on-Hurd.patch, because hurd got fixed.
  (see #752237)
* debian/rules: Remove useless --with-system-tommath --without-included-ltdl
  configure options.

[ Scott Kitterman ]
* Stop stripping llvm when repacking the tarball as the system llvm on some
  releases is too old to use
* New upstream bugfix release
  - Library shared object revisions.
  - Includes a patch from Sebastian Andrzej Siewior making ClamAV pid files
    compatible with systemd.
  - Fix a heap out of bounds condition with crafted Yoda's crypter files.
    This issue was discovered by Felix Groebert of the Google Security Team.
  - Fix a heap out of bounds condition with crafted mew packer files. This
    issue was discovered by Felix Groebert of the Google Security Team.
  - Fix a heap out of bounds condition with crafted upx packer files. This
    issue was discovered by Kevin Szkudlapski of Quarkslab.
  - Fix a heap out of bounds condition with crafted upack packer files. This
    issue was discovered by Sebastian Andrzej Siewior. CVE-2014-9328.
  - Compensate a crash due to incorrect compiler optimization when handling
    crafted petite packer files. This issue was discovered by Sebastian
    Andrzej Siewior.
* Update lintian override for embedded zlib to match new so version

[ Javier Fernández-Sanguino ]
* Updated Spanish Debconf template translation (Closes: #773563)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/lib/VMCore/DebugLoc.cpp
 
1
//===-- DebugLoc.cpp - Implement DebugLoc class ---------------------------===//
 
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
#include "llvm/Support/DebugLoc.h"
 
11
#include "LLVMContextImpl.h"
 
12
using namespace llvm;
 
13
 
 
14
//===----------------------------------------------------------------------===//
 
15
// DebugLoc Implementation
 
16
//===----------------------------------------------------------------------===//
 
17
 
 
18
MDNode *DebugLoc::getScope(const LLVMContext &Ctx) const {
 
19
  if (ScopeIdx == 0) return 0;
 
20
  
 
21
  if (ScopeIdx > 0) {
 
22
    // Positive ScopeIdx is an index into ScopeRecords, which has no inlined-at
 
23
    // position specified.
 
24
    assert(unsigned(ScopeIdx) <= Ctx.pImpl->ScopeRecords.size() &&
 
25
           "Invalid ScopeIdx!");
 
26
    return Ctx.pImpl->ScopeRecords[ScopeIdx-1].get();
 
27
  }
 
28
  
 
29
  // Otherwise, the index is in the ScopeInlinedAtRecords array.
 
30
  assert(unsigned(-ScopeIdx) <= Ctx.pImpl->ScopeInlinedAtRecords.size() &&
 
31
         "Invalid ScopeIdx");
 
32
  return Ctx.pImpl->ScopeInlinedAtRecords[-ScopeIdx-1].first.get();
 
33
}
 
34
 
 
35
MDNode *DebugLoc::getInlinedAt(const LLVMContext &Ctx) const {
 
36
  // Positive ScopeIdx is an index into ScopeRecords, which has no inlined-at
 
37
  // position specified.  Zero is invalid.
 
38
  if (ScopeIdx >= 0) return 0;
 
39
  
 
40
  // Otherwise, the index is in the ScopeInlinedAtRecords array.
 
41
  assert(unsigned(-ScopeIdx) <= Ctx.pImpl->ScopeInlinedAtRecords.size() &&
 
42
         "Invalid ScopeIdx");
 
43
  return Ctx.pImpl->ScopeInlinedAtRecords[-ScopeIdx-1].second.get();
 
44
}
 
45
 
 
46
/// Return both the Scope and the InlinedAt values.
 
47
void DebugLoc::getScopeAndInlinedAt(MDNode *&Scope, MDNode *&IA,
 
48
                                    const LLVMContext &Ctx) const {
 
49
  if (ScopeIdx == 0) {
 
50
    Scope = IA = 0;
 
51
    return;
 
52
  }
 
53
  
 
54
  if (ScopeIdx > 0) {
 
55
    // Positive ScopeIdx is an index into ScopeRecords, which has no inlined-at
 
56
    // position specified.
 
57
    assert(unsigned(ScopeIdx) <= Ctx.pImpl->ScopeRecords.size() &&
 
58
           "Invalid ScopeIdx!");
 
59
    Scope = Ctx.pImpl->ScopeRecords[ScopeIdx-1].get();
 
60
    IA = 0;
 
61
    return;
 
62
  }
 
63
  
 
64
  // Otherwise, the index is in the ScopeInlinedAtRecords array.
 
65
  assert(unsigned(-ScopeIdx) <= Ctx.pImpl->ScopeInlinedAtRecords.size() &&
 
66
         "Invalid ScopeIdx");
 
67
  Scope = Ctx.pImpl->ScopeInlinedAtRecords[-ScopeIdx-1].first.get();
 
68
  IA    = Ctx.pImpl->ScopeInlinedAtRecords[-ScopeIdx-1].second.get();
 
69
}
 
70
 
 
71
 
 
72
DebugLoc DebugLoc::get(unsigned Line, unsigned Col,
 
73
                       MDNode *Scope, MDNode *InlinedAt) {
 
74
  DebugLoc Result;
 
75
  
 
76
  // If no scope is available, this is an unknown location.
 
77
  if (Scope == 0) return Result;
 
78
  
 
79
  // Saturate line and col to "unknown".
 
80
  if (Col > 255) Col = 0;
 
81
  if (Line >= (1 << 24)) Line = 0;
 
82
  Result.LineCol = Line | (Col << 24);
 
83
  
 
84
  LLVMContext &Ctx = Scope->getContext();
 
85
  
 
86
  // If there is no inlined-at location, use the ScopeRecords array.
 
87
  if (InlinedAt == 0)
 
88
    Result.ScopeIdx = Ctx.pImpl->getOrAddScopeRecordIdxEntry(Scope, 0);
 
89
  else
 
90
    Result.ScopeIdx = Ctx.pImpl->getOrAddScopeInlinedAtIdxEntry(Scope,
 
91
                                                                InlinedAt, 0);
 
92
 
 
93
  return Result;
 
94
}
 
95
 
 
96
/// getAsMDNode - This method converts the compressed DebugLoc node into a
 
97
/// DILocation compatible MDNode.
 
98
MDNode *DebugLoc::getAsMDNode(const LLVMContext &Ctx) const {
 
99
  if (isUnknown()) return 0;
 
100
  
 
101
  MDNode *Scope, *IA;
 
102
  getScopeAndInlinedAt(Scope, IA, Ctx);
 
103
  assert(Scope && "If scope is null, this should be isUnknown()");
 
104
  
 
105
  LLVMContext &Ctx2 = Scope->getContext();
 
106
  const Type *Int32 = Type::getInt32Ty(Ctx2);
 
107
  Value *Elts[] = {
 
108
    ConstantInt::get(Int32, getLine()), ConstantInt::get(Int32, getCol()),
 
109
    Scope, IA
 
110
  };
 
111
  return MDNode::get(Ctx2, &Elts[0], 4);
 
112
}
 
113
 
 
114
/// getFromDILocation - Translate the DILocation quad into a DebugLoc.
 
115
DebugLoc DebugLoc::getFromDILocation(MDNode *N) {
 
116
  if (N == 0 || N->getNumOperands() != 4) return DebugLoc();
 
117
  
 
118
  MDNode *Scope = dyn_cast_or_null<MDNode>(N->getOperand(2));
 
119
  if (Scope == 0) return DebugLoc();
 
120
  
 
121
  unsigned LineNo = 0, ColNo = 0;
 
122
  if (ConstantInt *Line = dyn_cast_or_null<ConstantInt>(N->getOperand(0)))
 
123
    LineNo = Line->getZExtValue();
 
124
  if (ConstantInt *Col = dyn_cast_or_null<ConstantInt>(N->getOperand(1)))
 
125
    ColNo = Col->getZExtValue();
 
126
  
 
127
  return get(LineNo, ColNo, Scope, dyn_cast_or_null<MDNode>(N->getOperand(3)));
 
128
}
 
129
 
 
130
//===----------------------------------------------------------------------===//
 
131
// LLVMContextImpl Implementation
 
132
//===----------------------------------------------------------------------===//
 
133
 
 
134
int LLVMContextImpl::getOrAddScopeRecordIdxEntry(MDNode *Scope,
 
135
                                                 int ExistingIdx) {
 
136
  // If we already have an entry for this scope, return it.
 
137
  int &Idx = ScopeRecordIdx[Scope];
 
138
  if (Idx) return Idx;
 
139
  
 
140
  // If we don't have an entry, but ExistingIdx is specified, use it.
 
141
  if (ExistingIdx)
 
142
    return Idx = ExistingIdx;
 
143
  
 
144
  // Otherwise add a new entry.
 
145
  
 
146
  // Start out ScopeRecords with a minimal reasonable size to avoid
 
147
  // excessive reallocation starting out.
 
148
  if (ScopeRecords.empty())
 
149
    ScopeRecords.reserve(128);
 
150
  
 
151
  // Index is biased by 1 for index.
 
152
  Idx = ScopeRecords.size()+1;
 
153
  ScopeRecords.push_back(DebugRecVH(Scope, this, Idx));
 
154
  return Idx;
 
155
}
 
156
 
 
157
int LLVMContextImpl::getOrAddScopeInlinedAtIdxEntry(MDNode *Scope, MDNode *IA,
 
158
                                                    int ExistingIdx) {
 
159
  // If we already have an entry, return it.
 
160
  int &Idx = ScopeInlinedAtIdx[std::make_pair(Scope, IA)];
 
161
  if (Idx) return Idx;
 
162
  
 
163
  // If we don't have an entry, but ExistingIdx is specified, use it.
 
164
  if (ExistingIdx)
 
165
    return Idx = ExistingIdx;
 
166
  
 
167
  // Start out ScopeInlinedAtRecords with a minimal reasonable size to avoid
 
168
  // excessive reallocation starting out.
 
169
  if (ScopeInlinedAtRecords.empty())
 
170
    ScopeInlinedAtRecords.reserve(128);
 
171
    
 
172
  // Index is biased by 1 and negated.
 
173
  Idx = -ScopeInlinedAtRecords.size()-1;
 
174
  ScopeInlinedAtRecords.push_back(std::make_pair(DebugRecVH(Scope, this, Idx),
 
175
                                                 DebugRecVH(IA, this, Idx)));
 
176
  return Idx;
 
177
}
 
178
 
 
179
 
 
180
//===----------------------------------------------------------------------===//
 
181
// DebugRecVH Implementation
 
182
//===----------------------------------------------------------------------===//
 
183
 
 
184
/// deleted - The MDNode this is pointing to got deleted, so this pointer needs
 
185
/// to drop to null and we need remove our entry from the DenseMap.
 
186
void DebugRecVH::deleted() {
 
187
  // If this is a  non-canonical reference, just drop the value to null, we know
 
188
  // it doesn't have a map entry.
 
189
  if (Idx == 0) {
 
190
    setValPtr(0);
 
191
    return;
 
192
  }
 
193
    
 
194
  MDNode *Cur = get();
 
195
  
 
196
  // If the index is positive, it is an entry in ScopeRecords.
 
197
  if (Idx > 0) {
 
198
    assert(Ctx->ScopeRecordIdx[Cur] == Idx && "Mapping out of date!");
 
199
    Ctx->ScopeRecordIdx.erase(Cur);
 
200
    // Reset this VH to null and we're done.
 
201
    setValPtr(0);
 
202
    Idx = 0;
 
203
    return;
 
204
  }
 
205
  
 
206
  // Otherwise, it is an entry in ScopeInlinedAtRecords, we don't know if it
 
207
  // is the scope or the inlined-at record entry.
 
208
  assert(unsigned(-Idx-1) < Ctx->ScopeInlinedAtRecords.size());
 
209
  std::pair<DebugRecVH, DebugRecVH> &Entry = Ctx->ScopeInlinedAtRecords[-Idx-1];
 
210
  assert((this == &Entry.first || this == &Entry.second) &&
 
211
         "Mapping out of date!");
 
212
  
 
213
  MDNode *OldScope = Entry.first.get();
 
214
  MDNode *OldInlinedAt = Entry.second.get();
 
215
  assert(OldScope != 0 && OldInlinedAt != 0 &&
 
216
         "Entry should be non-canonical if either val dropped to null");
 
217
 
 
218
  // Otherwise, we do have an entry in it, nuke it and we're done.
 
219
  assert(Ctx->ScopeInlinedAtIdx[std::make_pair(OldScope, OldInlinedAt)] == Idx&&
 
220
         "Mapping out of date");
 
221
  Ctx->ScopeInlinedAtIdx.erase(std::make_pair(OldScope, OldInlinedAt));
 
222
  
 
223
  // Reset this VH to null.  Drop both 'Idx' values to null to indicate that
 
224
  // we're in non-canonical form now.
 
225
  setValPtr(0);
 
226
  Entry.first.Idx = Entry.second.Idx = 0;
 
227
}
 
228
 
 
229
void DebugRecVH::allUsesReplacedWith(Value *NewVa) {
 
230
  // If being replaced with a non-mdnode value (e.g. undef) handle this as if
 
231
  // the mdnode got deleted.
 
232
  MDNode *NewVal = dyn_cast<MDNode>(NewVa);
 
233
  if (NewVal == 0) return deleted();
 
234
  
 
235
  // If this is a non-canonical reference, just change it, we know it already
 
236
  // doesn't have a map entry.
 
237
  if (Idx == 0) {
 
238
    setValPtr(NewVa);
 
239
    return;
 
240
  }
 
241
  
 
242
  MDNode *OldVal = get();
 
243
  assert(OldVal != NewVa && "Node replaced with self?");
 
244
  
 
245
  // If the index is positive, it is an entry in ScopeRecords.
 
246
  if (Idx > 0) {
 
247
    assert(Ctx->ScopeRecordIdx[OldVal] == Idx && "Mapping out of date!");
 
248
    Ctx->ScopeRecordIdx.erase(OldVal);
 
249
    setValPtr(NewVal);
 
250
 
 
251
    int NewEntry = Ctx->getOrAddScopeRecordIdxEntry(NewVal, Idx);
 
252
    
 
253
    // If NewVal already has an entry, this becomes a non-canonical reference,
 
254
    // just drop Idx to 0 to signify this.
 
255
    if (NewEntry != Idx)
 
256
      Idx = 0;
 
257
    return;
 
258
  }
 
259
  
 
260
  // Otherwise, it is an entry in ScopeInlinedAtRecords, we don't know if it
 
261
  // is the scope or the inlined-at record entry.
 
262
  assert(unsigned(-Idx-1) < Ctx->ScopeInlinedAtRecords.size());
 
263
  std::pair<DebugRecVH, DebugRecVH> &Entry = Ctx->ScopeInlinedAtRecords[-Idx-1];
 
264
  assert((this == &Entry.first || this == &Entry.second) &&
 
265
         "Mapping out of date!");
 
266
  
 
267
  MDNode *OldScope = Entry.first.get();
 
268
  MDNode *OldInlinedAt = Entry.second.get();
 
269
  assert(OldScope != 0 && OldInlinedAt != 0 &&
 
270
         "Entry should be non-canonical if either val dropped to null");
 
271
  
 
272
  // Otherwise, we do have an entry in it, nuke it and we're done.
 
273
  assert(Ctx->ScopeInlinedAtIdx[std::make_pair(OldScope, OldInlinedAt)] == Idx&&
 
274
         "Mapping out of date");
 
275
  Ctx->ScopeInlinedAtIdx.erase(std::make_pair(OldScope, OldInlinedAt));
 
276
  
 
277
  // Reset this VH to the new value.
 
278
  setValPtr(NewVal);
 
279
 
 
280
  int NewIdx = Ctx->getOrAddScopeInlinedAtIdxEntry(Entry.first.get(),
 
281
                                                   Entry.second.get(), Idx);
 
282
  // If NewVal already has an entry, this becomes a non-canonical reference,
 
283
  // just drop Idx to 0 to signify this.
 
284
  if (NewIdx != Idx) {
 
285
    std::pair<DebugRecVH, DebugRecVH> &Entry=Ctx->ScopeInlinedAtRecords[-Idx-1];
 
286
    Entry.first.Idx = Entry.second.Idx = 0;
 
287
  }
 
288
}