← 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/Transforms/IPO/LowerSetJmp.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/Transforms/IPO/LowerSetJmp.cpp
 
1
//===- LowerSetJmp.cpp - Code pertaining to lowering set/long jumps -------===//
 
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
//  This file implements the lowering of setjmp and longjmp to use the
 
11
//  LLVM invoke and unwind instructions as necessary.
 
12
//
 
13
//  Lowering of longjmp is fairly trivial. We replace the call with a
 
14
//  call to the LLVM library function "__llvm_sjljeh_throw_longjmp()".
 
15
//  This unwinds the stack for us calling all of the destructors for
 
16
//  objects allocated on the stack.
 
17
//
 
18
//  At a setjmp call, the basic block is split and the setjmp removed.
 
19
//  The calls in a function that have a setjmp are converted to invoke
 
20
//  where the except part checks to see if it's a longjmp exception and,
 
21
//  if so, if it's handled in the function. If it is, then it gets the
 
22
//  value returned by the longjmp and goes to where the basic block was
 
23
//  split. Invoke instructions are handled in a similar fashion with the
 
24
//  original except block being executed if it isn't a longjmp except
 
25
//  that is handled by that function.
 
26
//
 
27
//===----------------------------------------------------------------------===//
 
28
 
 
29
//===----------------------------------------------------------------------===//
 
30
// FIXME: This pass doesn't deal with PHI statements just yet. That is,
 
31
// we expect this to occur before SSAification is done. This would seem
 
32
// to make sense, but in general, it might be a good idea to make this
 
33
// pass invokable via the "opt" command at will.
 
34
//===----------------------------------------------------------------------===//
 
35
 
 
36
#define DEBUG_TYPE "lowersetjmp"
 
37
#include "llvm/Transforms/IPO.h"
 
38
#include "llvm/Constants.h"
 
39
#include "llvm/DerivedTypes.h"
 
40
#include "llvm/Instructions.h"
 
41
#include "llvm/Intrinsics.h"
 
42
#include "llvm/LLVMContext.h"
 
43
#include "llvm/Module.h"
 
44
#include "llvm/Pass.h"
 
45
#include "llvm/Support/CallSite.h"
 
46
#include "llvm/Support/CFG.h"
 
47
#include "llvm/Support/InstVisitor.h"
 
48
#include "llvm/Transforms/Utils/Local.h"
 
49
#include "llvm/ADT/DepthFirstIterator.h"
 
50
#include "llvm/ADT/Statistic.h"
 
51
#include <map>
 
52
using namespace llvm;
 
53
 
 
54
STATISTIC(LongJmpsTransformed, "Number of longjmps transformed");
 
55
STATISTIC(SetJmpsTransformed , "Number of setjmps transformed");
 
56
STATISTIC(CallsTransformed   , "Number of calls invokified");
 
57
STATISTIC(InvokesTransformed , "Number of invokes modified");
 
58
 
 
59
namespace {
 
60
  //===--------------------------------------------------------------------===//
 
61
  // LowerSetJmp pass implementation.
 
62
  class LowerSetJmp : public ModulePass, public InstVisitor<LowerSetJmp> {
 
63
    // LLVM library functions...
 
64
    Constant *InitSJMap;        // __llvm_sjljeh_init_setjmpmap
 
65
    Constant *DestroySJMap;     // __llvm_sjljeh_destroy_setjmpmap
 
66
    Constant *AddSJToMap;       // __llvm_sjljeh_add_setjmp_to_map
 
67
    Constant *ThrowLongJmp;     // __llvm_sjljeh_throw_longjmp
 
68
    Constant *TryCatchLJ;       // __llvm_sjljeh_try_catching_longjmp_exception
 
69
    Constant *IsLJException;    // __llvm_sjljeh_is_longjmp_exception
 
70
    Constant *GetLJValue;       // __llvm_sjljeh_get_longjmp_value
 
71
 
 
72
    typedef std::pair<SwitchInst*, CallInst*> SwitchValuePair;
 
73
 
 
74
    // Keep track of those basic blocks reachable via a depth-first search of
 
75
    // the CFG from a setjmp call. We only need to transform those "call" and
 
76
    // "invoke" instructions that are reachable from the setjmp call site.
 
77
    std::set<BasicBlock*> DFSBlocks;
 
78
 
 
79
    // The setjmp map is going to hold information about which setjmps
 
80
    // were called (each setjmp gets its own number) and with which
 
81
    // buffer it was called.
 
82
    std::map<Function*, AllocaInst*>            SJMap;
 
83
 
 
84
    // The rethrow basic block map holds the basic block to branch to if
 
85
    // the exception isn't handled in the current function and needs to
 
86
    // be rethrown.
 
87
    std::map<const Function*, BasicBlock*>      RethrowBBMap;
 
88
 
 
89
    // The preliminary basic block map holds a basic block that grabs the
 
90
    // exception and determines if it's handled by the current function.
 
91
    std::map<const Function*, BasicBlock*>      PrelimBBMap;
 
92
 
 
93
    // The switch/value map holds a switch inst/call inst pair. The
 
94
    // switch inst controls which handler (if any) gets called and the
 
95
    // value is the value returned to that handler by the call to
 
96
    // __llvm_sjljeh_get_longjmp_value.
 
97
    std::map<const Function*, SwitchValuePair>  SwitchValMap;
 
98
 
 
99
    // A map of which setjmps we've seen so far in a function.
 
100
    std::map<const Function*, unsigned>         SetJmpIDMap;
 
101
 
 
102
    AllocaInst*     GetSetJmpMap(Function* Func);
 
103
    BasicBlock*     GetRethrowBB(Function* Func);
 
104
    SwitchValuePair GetSJSwitch(Function* Func, BasicBlock* Rethrow);
 
105
 
 
106
    void TransformLongJmpCall(CallInst* Inst);
 
107
    void TransformSetJmpCall(CallInst* Inst);
 
108
 
 
109
    bool IsTransformableFunction(StringRef Name);
 
110
  public:
 
111
    static char ID; // Pass identification, replacement for typeid
 
112
    LowerSetJmp() : ModulePass(ID) {}
 
113
 
 
114
    void visitCallInst(CallInst& CI);
 
115
    void visitInvokeInst(InvokeInst& II);
 
116
    void visitReturnInst(ReturnInst& RI);
 
117
    void visitUnwindInst(UnwindInst& UI);
 
118
 
 
119
    bool runOnModule(Module& M);
 
120
    bool doInitialization(Module& M);
 
121
  };
 
122
} // end anonymous namespace
 
123
 
 
124
char LowerSetJmp::ID = 0;
 
125
INITIALIZE_PASS(LowerSetJmp, "lowersetjmp", "Lower Set Jump", false, false);
 
126
 
 
127
// run - Run the transformation on the program. We grab the function
 
128
// prototypes for longjmp and setjmp. If they are used in the program,
 
129
// then we can go directly to the places they're at and transform them.
 
130
bool LowerSetJmp::runOnModule(Module& M) {
 
131
  bool Changed = false;
 
132
 
 
133
  // These are what the functions are called.
 
134
  Function* SetJmp = M.getFunction("llvm.setjmp");
 
135
  Function* LongJmp = M.getFunction("llvm.longjmp");
 
136
 
 
137
  // This program doesn't have longjmp and setjmp calls.
 
138
  if ((!LongJmp || LongJmp->use_empty()) &&
 
139
        (!SetJmp || SetJmp->use_empty())) return false;
 
140
 
 
141
  // Initialize some values and functions we'll need to transform the
 
142
  // setjmp/longjmp functions.
 
143
  doInitialization(M);
 
144
 
 
145
  if (SetJmp) {
 
146
    for (Value::use_iterator B = SetJmp->use_begin(), E = SetJmp->use_end();
 
147
         B != E; ++B) {
 
148
      BasicBlock* BB = cast<Instruction>(*B)->getParent();
 
149
      for (df_ext_iterator<BasicBlock*> I = df_ext_begin(BB, DFSBlocks),
 
150
             E = df_ext_end(BB, DFSBlocks); I != E; ++I)
 
151
        /* empty */;
 
152
    }
 
153
 
 
154
    while (!SetJmp->use_empty()) {
 
155
      assert(isa<CallInst>(SetJmp->use_back()) &&
 
156
             "User of setjmp intrinsic not a call?");
 
157
      TransformSetJmpCall(cast<CallInst>(SetJmp->use_back()));
 
158
      Changed = true;
 
159
    }
 
160
  }
 
161
 
 
162
  if (LongJmp)
 
163
    while (!LongJmp->use_empty()) {
 
164
      assert(isa<CallInst>(LongJmp->use_back()) &&
 
165
             "User of longjmp intrinsic not a call?");
 
166
      TransformLongJmpCall(cast<CallInst>(LongJmp->use_back()));
 
167
      Changed = true;
 
168
    }
 
169
 
 
170
  // Now go through the affected functions and convert calls and invokes
 
171
  // to new invokes...
 
172
  for (std::map<Function*, AllocaInst*>::iterator
 
173
      B = SJMap.begin(), E = SJMap.end(); B != E; ++B) {
 
174
    Function* F = B->first;
 
175
    for (Function::iterator BB = F->begin(), BE = F->end(); BB != BE; ++BB)
 
176
      for (BasicBlock::iterator IB = BB->begin(), IE = BB->end(); IB != IE; ) {
 
177
        visit(*IB++);
 
178
        if (IB != BB->end() && IB->getParent() != BB)
 
179
          break;  // The next instruction got moved to a different block!
 
180
      }
 
181
  }
 
182
 
 
183
  DFSBlocks.clear();
 
184
  SJMap.clear();
 
185
  RethrowBBMap.clear();
 
186
  PrelimBBMap.clear();
 
187
  SwitchValMap.clear();
 
188
  SetJmpIDMap.clear();
 
189
 
 
190
  return Changed;
 
191
}
 
192
 
 
193
// doInitialization - For the lower long/setjmp pass, this ensures that a
 
194
// module contains a declaration for the intrisic functions we are going
 
195
// to call to convert longjmp and setjmp calls.
 
196
//
 
197
// This function is always successful, unless it isn't.
 
198
bool LowerSetJmp::doInitialization(Module& M)
 
199
{
 
200
  const Type *SBPTy = Type::getInt8PtrTy(M.getContext());
 
201
  const Type *SBPPTy = PointerType::getUnqual(SBPTy);
 
202
 
 
203
  // N.B. See llvm/runtime/GCCLibraries/libexception/SJLJ-Exception.h for
 
204
  // a description of the following library functions.
 
205
 
 
206
  // void __llvm_sjljeh_init_setjmpmap(void**)
 
207
  InitSJMap = M.getOrInsertFunction("__llvm_sjljeh_init_setjmpmap",
 
208
                                    Type::getVoidTy(M.getContext()),
 
209
                                    SBPPTy, (Type *)0);
 
210
  // void __llvm_sjljeh_destroy_setjmpmap(void**)
 
211
  DestroySJMap = M.getOrInsertFunction("__llvm_sjljeh_destroy_setjmpmap",
 
212
                                       Type::getVoidTy(M.getContext()),
 
213
                                       SBPPTy, (Type *)0);
 
214
 
 
215
  // void __llvm_sjljeh_add_setjmp_to_map(void**, void*, unsigned)
 
216
  AddSJToMap = M.getOrInsertFunction("__llvm_sjljeh_add_setjmp_to_map",
 
217
                                     Type::getVoidTy(M.getContext()),
 
218
                                     SBPPTy, SBPTy,
 
219
                                     Type::getInt32Ty(M.getContext()),
 
220
                                     (Type *)0);
 
221
 
 
222
  // void __llvm_sjljeh_throw_longjmp(int*, int)
 
223
  ThrowLongJmp = M.getOrInsertFunction("__llvm_sjljeh_throw_longjmp",
 
224
                                       Type::getVoidTy(M.getContext()), SBPTy, 
 
225
                                       Type::getInt32Ty(M.getContext()),
 
226
                                       (Type *)0);
 
227
 
 
228
  // unsigned __llvm_sjljeh_try_catching_longjmp_exception(void **)
 
229
  TryCatchLJ =
 
230
    M.getOrInsertFunction("__llvm_sjljeh_try_catching_longjmp_exception",
 
231
                          Type::getInt32Ty(M.getContext()), SBPPTy, (Type *)0);
 
232
 
 
233
  // bool __llvm_sjljeh_is_longjmp_exception()
 
234
  IsLJException = M.getOrInsertFunction("__llvm_sjljeh_is_longjmp_exception",
 
235
                                        Type::getInt1Ty(M.getContext()),
 
236
                                        (Type *)0);
 
237
 
 
238
  // int __llvm_sjljeh_get_longjmp_value()
 
239
  GetLJValue = M.getOrInsertFunction("__llvm_sjljeh_get_longjmp_value",
 
240
                                     Type::getInt32Ty(M.getContext()),
 
241
                                     (Type *)0);
 
242
  return true;
 
243
}
 
244
 
 
245
// IsTransformableFunction - Return true if the function name isn't one
 
246
// of the ones we don't want transformed. Currently, don't transform any
 
247
// "llvm.{setjmp,longjmp}" functions and none of the setjmp/longjmp error
 
248
// handling functions (beginning with __llvm_sjljeh_...they don't throw
 
249
// exceptions).
 
250
bool LowerSetJmp::IsTransformableFunction(StringRef Name) {
 
251
  return !Name.startswith("__llvm_sjljeh_");
 
252
}
 
253
 
 
254
// TransformLongJmpCall - Transform a longjmp call into a call to the
 
255
// internal __llvm_sjljeh_throw_longjmp function. It then takes care of
 
256
// throwing the exception for us.
 
257
void LowerSetJmp::TransformLongJmpCall(CallInst* Inst)
 
258
{
 
259
  const Type* SBPTy = Type::getInt8PtrTy(Inst->getContext());
 
260
 
 
261
  // Create the call to "__llvm_sjljeh_throw_longjmp". This takes the
 
262
  // same parameters as "longjmp", except that the buffer is cast to a
 
263
  // char*. It returns "void", so it doesn't need to replace any of
 
264
  // Inst's uses and doesn't get a name.
 
265
  CastInst* CI = 
 
266
    new BitCastInst(Inst->getArgOperand(0), SBPTy, "LJBuf", Inst);
 
267
  Value *Args[] = { CI, Inst->getArgOperand(1) };
 
268
  CallInst::Create(ThrowLongJmp, Args, Args + 2, "", Inst);
 
269
 
 
270
  SwitchValuePair& SVP = SwitchValMap[Inst->getParent()->getParent()];
 
271
 
 
272
  // If the function has a setjmp call in it (they are transformed first)
 
273
  // we should branch to the basic block that determines if this longjmp
 
274
  // is applicable here. Otherwise, issue an unwind.
 
275
  if (SVP.first)
 
276
    BranchInst::Create(SVP.first->getParent(), Inst);
 
277
  else
 
278
    new UnwindInst(Inst->getContext(), Inst);
 
279
 
 
280
  // Remove all insts after the branch/unwind inst.  Go from back to front to
 
281
  // avoid replaceAllUsesWith if possible.
 
282
  BasicBlock *BB = Inst->getParent();
 
283
  Instruction *Removed;
 
284
  do {
 
285
    Removed = &BB->back();
 
286
    // If the removed instructions have any users, replace them now.
 
287
    if (!Removed->use_empty())
 
288
      Removed->replaceAllUsesWith(UndefValue::get(Removed->getType()));
 
289
    Removed->eraseFromParent();
 
290
  } while (Removed != Inst);
 
291
 
 
292
  ++LongJmpsTransformed;
 
293
}
 
294
 
 
295
// GetSetJmpMap - Retrieve (create and initialize, if necessary) the
 
296
// setjmp map. This map is going to hold information about which setjmps
 
297
// were called (each setjmp gets its own number) and with which buffer it
 
298
// was called. There can be only one!
 
299
AllocaInst* LowerSetJmp::GetSetJmpMap(Function* Func)
 
300
{
 
301
  if (SJMap[Func]) return SJMap[Func];
 
302
 
 
303
  // Insert the setjmp map initialization before the first instruction in
 
304
  // the function.
 
305
  Instruction* Inst = Func->getEntryBlock().begin();
 
306
  assert(Inst && "Couldn't find even ONE instruction in entry block!");
 
307
 
 
308
  // Fill in the alloca and call to initialize the SJ map.
 
309
  const Type *SBPTy =
 
310
        Type::getInt8PtrTy(Func->getContext());
 
311
  AllocaInst* Map = new AllocaInst(SBPTy, 0, "SJMap", Inst);
 
312
  CallInst::Create(InitSJMap, Map, "", Inst);
 
313
  return SJMap[Func] = Map;
 
314
}
 
315
 
 
316
// GetRethrowBB - Only one rethrow basic block is needed per function.
 
317
// If this is a longjmp exception but not handled in this block, this BB
 
318
// performs the rethrow.
 
319
BasicBlock* LowerSetJmp::GetRethrowBB(Function* Func)
 
320
{
 
321
  if (RethrowBBMap[Func]) return RethrowBBMap[Func];
 
322
 
 
323
  // The basic block we're going to jump to if we need to rethrow the
 
324
  // exception.
 
325
  BasicBlock* Rethrow =
 
326
        BasicBlock::Create(Func->getContext(), "RethrowExcept", Func);
 
327
 
 
328
  // Fill in the "Rethrow" BB with a call to rethrow the exception. This
 
329
  // is the last instruction in the BB since at this point the runtime
 
330
  // should exit this function and go to the next function.
 
331
  new UnwindInst(Func->getContext(), Rethrow);
 
332
  return RethrowBBMap[Func] = Rethrow;
 
333
}
 
334
 
 
335
// GetSJSwitch - Return the switch statement that controls which handler
 
336
// (if any) gets called and the value returned to that handler.
 
337
LowerSetJmp::SwitchValuePair LowerSetJmp::GetSJSwitch(Function* Func,
 
338
                                                      BasicBlock* Rethrow)
 
339
{
 
340
  if (SwitchValMap[Func].first) return SwitchValMap[Func];
 
341
 
 
342
  BasicBlock* LongJmpPre =
 
343
        BasicBlock::Create(Func->getContext(), "LongJmpBlkPre", Func);
 
344
 
 
345
  // Keep track of the preliminary basic block for some of the other
 
346
  // transformations.
 
347
  PrelimBBMap[Func] = LongJmpPre;
 
348
 
 
349
  // Grab the exception.
 
350
  CallInst* Cond = CallInst::Create(IsLJException, "IsLJExcept", LongJmpPre);
 
351
 
 
352
  // The "decision basic block" gets the number associated with the
 
353
  // setjmp call returning to switch on and the value returned by
 
354
  // longjmp.
 
355
  BasicBlock* DecisionBB =
 
356
        BasicBlock::Create(Func->getContext(), "LJDecisionBB", Func);
 
357
 
 
358
  BranchInst::Create(DecisionBB, Rethrow, Cond, LongJmpPre);
 
359
 
 
360
  // Fill in the "decision" basic block.
 
361
  CallInst* LJVal = CallInst::Create(GetLJValue, "LJVal", DecisionBB);
 
362
  CallInst* SJNum = CallInst::Create(TryCatchLJ, GetSetJmpMap(Func), "SJNum",
 
363
                                     DecisionBB);
 
364
 
 
365
  SwitchInst* SI = SwitchInst::Create(SJNum, Rethrow, 0, DecisionBB);
 
366
  return SwitchValMap[Func] = SwitchValuePair(SI, LJVal);
 
367
}
 
368
 
 
369
// TransformSetJmpCall - The setjmp call is a bit trickier to transform.
 
370
// We're going to convert all setjmp calls to nops. Then all "call" and
 
371
// "invoke" instructions in the function are converted to "invoke" where
 
372
// the "except" branch is used when returning from a longjmp call.
 
373
void LowerSetJmp::TransformSetJmpCall(CallInst* Inst)
 
374
{
 
375
  BasicBlock* ABlock = Inst->getParent();
 
376
  Function* Func = ABlock->getParent();
 
377
 
 
378
  // Add this setjmp to the setjmp map.
 
379
  const Type* SBPTy =
 
380
          Type::getInt8PtrTy(Inst->getContext());
 
381
  CastInst* BufPtr = 
 
382
    new BitCastInst(Inst->getArgOperand(0), SBPTy, "SBJmpBuf", Inst);
 
383
  Value *Args[] = {
 
384
    GetSetJmpMap(Func), BufPtr,
 
385
    ConstantInt::get(Type::getInt32Ty(Inst->getContext()), SetJmpIDMap[Func]++)
 
386
  };
 
387
  CallInst::Create(AddSJToMap, Args, Args + 3, "", Inst);
 
388
 
 
389
  // We are guaranteed that there are no values live across basic blocks
 
390
  // (because we are "not in SSA form" yet), but there can still be values live
 
391
  // in basic blocks.  Because of this, splitting the setjmp block can cause
 
392
  // values above the setjmp to not dominate uses which are after the setjmp
 
393
  // call.  For all of these occasions, we must spill the value to the stack.
 
394
  //
 
395
  std::set<Instruction*> InstrsAfterCall;
 
396
 
 
397
  // The call is probably very close to the end of the basic block, for the
 
398
  // common usage pattern of: 'if (setjmp(...))', so keep track of the
 
399
  // instructions after the call.
 
400
  for (BasicBlock::iterator I = ++BasicBlock::iterator(Inst), E = ABlock->end();
 
401
       I != E; ++I)
 
402
    InstrsAfterCall.insert(I);
 
403
 
 
404
  for (BasicBlock::iterator II = ABlock->begin();
 
405
       II != BasicBlock::iterator(Inst); ++II)
 
406
    // Loop over all of the uses of instruction.  If any of them are after the
 
407
    // call, "spill" the value to the stack.
 
408
    for (Value::use_iterator UI = II->use_begin(), E = II->use_end();
 
409
         UI != E; ++UI) {
 
410
      User *U = *UI;
 
411
      if (cast<Instruction>(U)->getParent() != ABlock ||
 
412
          InstrsAfterCall.count(cast<Instruction>(U))) {
 
413
        DemoteRegToStack(*II);
 
414
        break;
 
415
      }
 
416
    }
 
417
  InstrsAfterCall.clear();
 
418
 
 
419
  // Change the setjmp call into a branch statement. We'll remove the
 
420
  // setjmp call in a little bit. No worries.
 
421
  BasicBlock* SetJmpContBlock = ABlock->splitBasicBlock(Inst);
 
422
  assert(SetJmpContBlock && "Couldn't split setjmp BB!!");
 
423
 
 
424
  SetJmpContBlock->setName(ABlock->getName()+"SetJmpCont");
 
425
 
 
426
  // Add the SetJmpContBlock to the set of blocks reachable from a setjmp.
 
427
  DFSBlocks.insert(SetJmpContBlock);
 
428
 
 
429
  // This PHI node will be in the new block created from the
 
430
  // splitBasicBlock call.
 
431
  PHINode* PHI = PHINode::Create(Type::getInt32Ty(Inst->getContext()),
 
432
                                 "SetJmpReturn", Inst);
 
433
 
 
434
  // Coming from a call to setjmp, the return is 0.
 
435
  PHI->addIncoming(Constant::getNullValue(Type::getInt32Ty(Inst->getContext())),
 
436
                   ABlock);
 
437
 
 
438
  // Add the case for this setjmp's number...
 
439
  SwitchValuePair SVP = GetSJSwitch(Func, GetRethrowBB(Func));
 
440
  SVP.first->addCase(ConstantInt::get(Type::getInt32Ty(Inst->getContext()),
 
441
                                      SetJmpIDMap[Func] - 1),
 
442
                     SetJmpContBlock);
 
443
 
 
444
  // Value coming from the handling of the exception.
 
445
  PHI->addIncoming(SVP.second, SVP.second->getParent());
 
446
 
 
447
  // Replace all uses of this instruction with the PHI node created by
 
448
  // the eradication of setjmp.
 
449
  Inst->replaceAllUsesWith(PHI);
 
450
  Inst->eraseFromParent();
 
451
 
 
452
  ++SetJmpsTransformed;
 
453
}
 
454
 
 
455
// visitCallInst - This converts all LLVM call instructions into invoke
 
456
// instructions. The except part of the invoke goes to the "LongJmpBlkPre"
 
457
// that grabs the exception and proceeds to determine if it's a longjmp
 
458
// exception or not.
 
459
void LowerSetJmp::visitCallInst(CallInst& CI)
 
460
{
 
461
  if (CI.getCalledFunction())
 
462
    if (!IsTransformableFunction(CI.getCalledFunction()->getName()) ||
 
463
        CI.getCalledFunction()->isIntrinsic()) return;
 
464
 
 
465
  BasicBlock* OldBB = CI.getParent();
 
466
 
 
467
  // If not reachable from a setjmp call, don't transform.
 
468
  if (!DFSBlocks.count(OldBB)) return;
 
469
 
 
470
  BasicBlock* NewBB = OldBB->splitBasicBlock(CI);
 
471
  assert(NewBB && "Couldn't split BB of \"call\" instruction!!");
 
472
  DFSBlocks.insert(NewBB);
 
473
  NewBB->setName("Call2Invoke");
 
474
 
 
475
  Function* Func = OldBB->getParent();
 
476
 
 
477
  // Construct the new "invoke" instruction.
 
478
  TerminatorInst* Term = OldBB->getTerminator();
 
479
  CallSite CS(&CI);
 
480
  std::vector<Value*> Params(CS.arg_begin(), CS.arg_end());
 
481
  InvokeInst* II =
 
482
    InvokeInst::Create(CI.getCalledValue(), NewBB, PrelimBBMap[Func],
 
483
                       Params.begin(), Params.end(), CI.getName(), Term);
 
484
  II->setCallingConv(CI.getCallingConv());
 
485
  II->setAttributes(CI.getAttributes());
 
486
 
 
487
  // Replace the old call inst with the invoke inst and remove the call.
 
488
  CI.replaceAllUsesWith(II);
 
489
  CI.eraseFromParent();
 
490
 
 
491
  // The old terminator is useless now that we have the invoke inst.
 
492
  Term->eraseFromParent();
 
493
  ++CallsTransformed;
 
494
}
 
495
 
 
496
// visitInvokeInst - Converting the "invoke" instruction is fairly
 
497
// straight-forward. The old exception part is replaced by a query asking
 
498
// if this is a longjmp exception. If it is, then it goes to the longjmp
 
499
// exception blocks. Otherwise, control is passed the old exception.
 
500
void LowerSetJmp::visitInvokeInst(InvokeInst& II)
 
501
{
 
502
  if (II.getCalledFunction())
 
503
    if (!IsTransformableFunction(II.getCalledFunction()->getName()) ||
 
504
        II.getCalledFunction()->isIntrinsic()) return;
 
505
 
 
506
  BasicBlock* BB = II.getParent();
 
507
 
 
508
  // If not reachable from a setjmp call, don't transform.
 
509
  if (!DFSBlocks.count(BB)) return;
 
510
 
 
511
  BasicBlock* ExceptBB = II.getUnwindDest();
 
512
 
 
513
  Function* Func = BB->getParent();
 
514
  BasicBlock* NewExceptBB = BasicBlock::Create(II.getContext(), 
 
515
                                               "InvokeExcept", Func);
 
516
 
 
517
  // If this is a longjmp exception, then branch to the preliminary BB of
 
518
  // the longjmp exception handling. Otherwise, go to the old exception.
 
519
  CallInst* IsLJExcept = CallInst::Create(IsLJException, "IsLJExcept",
 
520
                                          NewExceptBB);
 
521
 
 
522
  BranchInst::Create(PrelimBBMap[Func], ExceptBB, IsLJExcept, NewExceptBB);
 
523
 
 
524
  II.setUnwindDest(NewExceptBB);
 
525
  ++InvokesTransformed;
 
526
}
 
527
 
 
528
// visitReturnInst - We want to destroy the setjmp map upon exit from the
 
529
// function.
 
530
void LowerSetJmp::visitReturnInst(ReturnInst &RI) {
 
531
  Function* Func = RI.getParent()->getParent();
 
532
  CallInst::Create(DestroySJMap, GetSetJmpMap(Func), "", &RI);
 
533
}
 
534
 
 
535
// visitUnwindInst - We want to destroy the setjmp map upon exit from the
 
536
// function.
 
537
void LowerSetJmp::visitUnwindInst(UnwindInst &UI) {
 
538
  Function* Func = UI.getParent()->getParent();
 
539
  CallInst::Create(DestroySJMap, GetSetJmpMap(Func), "", &UI);
 
540
}
 
541
 
 
542
ModulePass *llvm::createLowerSetJmpPass() {
 
543
  return new LowerSetJmp();
 
544
}
 
545