//
// The LLVM Compiler Infrastructure
//
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
#include "llvm/Instruction.h"
#include "llvm/SymbolTableListTraits.h"
#include "llvm/ADT/ilist"
+#include "llvm/Support/DataTypes.h"
namespace llvm {
/// modifying a program. However, the verifier will ensure that basic blocks
/// are "well formed".
/// @brief LLVM Basic Block Representation
-class BasicBlock : public Value { // Basic blocks are data objects also
+class BasicBlock : public User { // Basic blocks are data objects also
public:
typedef iplist<Instruction> InstListType;
private :
InstListType InstList;
BasicBlock *Prev, *Next; // Next and Prev links for our intrusive linked list
Function *Parent;
+ Use unwindDest;
void setParent(Function *parent);
void setNext(BasicBlock *N) { Next = N; }
/// InsertBefore is null), or before the specified basic block.
///
explicit BasicBlock(const std::string &Name = "", Function *Parent = 0,
- BasicBlock *InsertBefore = 0);
+ BasicBlock *InsertBefore = 0, BasicBlock *unwindDest = 0);
~BasicBlock();
+ /// getUnwindDest - Returns the BasicBlock that flow will enter if an unwind
+ /// instruction occurs in this block. May be null, in which case unwinding
+ /// is undefined in this block.
+ const BasicBlock *getUnwindDest() const;
+ BasicBlock *getUnwindDest();
+
+ /// setUnwindDest - Set which BasicBlock flow will enter if an unwind is
+ /// executed within this block. It may be set to null if unwinding is not
+ /// permitted in this block.
+ void setUnwindDest(BasicBlock *unwindDest);
+
/// getParent - Return the enclosing method, or null if none
///
const Function *getParent() const { return Parent; }
Function *getParent() { return Parent; }
- // getNext/Prev - Return the next or previous basic block in the list.
- BasicBlock *getNext() { return Next; }
- const BasicBlock *getNext() const { return Next; }
- BasicBlock *getPrev() { return Prev; }
- const BasicBlock *getPrev() const { return Prev; }
-
/// use_back - Specialize the methods defined in Value, as we know that an
/// BasicBlock can only be used by Instructions (specifically PHI and terms).
Instruction *use_back() { return cast<Instruction>(*use_begin());}
/// null pointer back.
///
TerminatorInst *getTerminator();
- const TerminatorInst *const getTerminator() const;
+ const TerminatorInst *getTerminator() const;
/// Returns a pointer to the first instructon in this block that is not a
/// PHINode instruction. When adding instruction to the beginning of the
static unsigned getInstListOffset() {
BasicBlock *Obj = 0;
- return reinterpret_cast<unsigned>(&Obj->InstList);
+ return unsigned(reinterpret_cast<uintptr_t>(&Obj->InstList));
}
+
+private:
+ // getNext/Prev - Return the next or previous basic block in the list. Access
+ // these with Function::iterator.
+ BasicBlock *getNext() { return Next; }
+ const BasicBlock *getNext() const { return Next; }
+ BasicBlock *getPrev() { return Prev; }
+ const BasicBlock *getPrev() const { return Prev; }
};
inline int