| //===- AllocatorInfo.h ------------------------------------------*- C++ -*----// |
| // |
| // The SAFECode Compiler |
| // |
| // 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. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // Define the abstraction of a pair of allocator / deallocator, including: |
| // |
| // * The size of the object being allocated. |
| // * Whether the size may be a constant, which can be used for exactcheck |
| // optimization. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "safecode/SAFECode.h" |
| |
| #include <stdint.h> |
| |
| #include <string> |
| |
| /// Forward declaration |
| namespace llvm { |
| class Value; |
| } |
| |
| NAMESPACE_SC_BEGIN |
| |
| /// AllocatorInfo - define the abstraction of a pair of allocator / deallocator. |
| class AllocatorInfo { |
| public: |
| AllocatorInfo(const std::string & allocCallName, |
| const std::string & freeCallName) : |
| allocCallName(allocCallName), freeCallName(freeCallName) {} |
| |
| virtual ~AllocatorInfo(); |
| /// Test whether the size of a particular allocation site may be a constant or |
| /// not. |
| /// This is used to determined whether SAFECode can perform an exactcheck |
| /// optimization on the particular allocation site. |
| /// |
| /// For simple allocators such as malloc() / poolalloc(), that is always |
| /// true. However, allocators such as kmem_cache_alloc() put the size of |
| /// allocation inside a struct, which needs extra instructions to get the size |
| /// out. We don't want to get into this complexity right now, even running |
| /// ADCE right after exactcheck optimization might fix the problem. |
| /// |
| virtual bool isAllocSizeMayConstant(llvm::Value * AllocSite) const { return true; } |
| |
| /// Return the size of the object being allocated |
| /// Assume the caller knows it is an allocation for this allocator |
| /// Return NULL when something is wrong |
| virtual llvm::Value * getAllocSize(llvm::Value * AllocSite) const = 0; |
| |
| /// Return the pointer being freed |
| /// Return NULL when something is wrong |
| virtual llvm::Value * getFreedPointer(llvm::Value * FreeSite) const = 0; |
| |
| /// Return the function name of the allocator, say "malloc". |
| const std::string & getAllocCallName() const { return allocCallName; } |
| |
| /// Return the function name of the deallocator, say "free". |
| const std::string & getFreeCallName() const { return freeCallName; } |
| protected: |
| std::string allocCallName; |
| std::string freeCallName; |
| }; |
| |
| /// SimpleAllocatorInfo - define the abstraction of simple allcators / |
| /// deallocators such as malloc / free |
| class SimpleAllocatorInfo : public AllocatorInfo { |
| public: |
| SimpleAllocatorInfo(const std::string & allocCallName, |
| const std::string & freeCallName, |
| uint32_t allocSizeOperand, |
| uint32_t freePtrOperand) : |
| AllocatorInfo(allocCallName, freeCallName), |
| allocSizeOperand(allocSizeOperand), freePtrOperand(freePtrOperand) {} |
| virtual llvm::Value * getAllocSize(llvm::Value * AllocSite) const; |
| virtual llvm::Value * getFreedPointer(llvm::Value * FreeSite) const; |
| private: |
| uint32_t allocSizeOperand; |
| uint32_t freePtrOperand; |
| }; |
| |
| NAMESPACE_SC_END |