mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-01-20 12:31:40 +00:00
2491ce0353
identifying the malloc as a non-array malloc. This broke GlobalOpt's optimization of stores of mallocs to global variables. The fix is to classify malloc's into 3 categories: 1. non-array mallocs 2. array mallocs whose array size can be determined 3. mallocs that cannot be determined to be of type 1 or 2 and cannot be optimized getMallocArraySize() returns NULL for category 3, and all users of this function must avoid their malloc optimization if this function returns NULL. Eventually, currently unexpected codegen for computing the malloc's size argument will be supported in isArrayMalloc() and getMallocArraySize(), extending malloc optimizations to those examples. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@84199 91177308-0d34-0410-b5e6-96231b3b80d8
86 lines
3.5 KiB
C++
86 lines
3.5 KiB
C++
//===- llvm/Analysis/MallocHelper.h ---- Identify malloc calls --*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This family of functions identifies calls to malloc, bitcasts of malloc
|
|
// calls, and the types and array sizes associated with them.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_ANALYSIS_MALLOCHELPER_H
|
|
#define LLVM_ANALYSIS_MALLOCHELPER_H
|
|
|
|
namespace llvm {
|
|
class CallInst;
|
|
class LLVMContext;
|
|
class PointerType;
|
|
class TargetData;
|
|
class Type;
|
|
class Value;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// malloc Call Utility Functions.
|
|
//
|
|
|
|
/// isMalloc - Returns true if the the value is either a malloc call or a
|
|
/// bitcast of the result of a malloc call
|
|
bool isMalloc(const Value* I);
|
|
|
|
/// extractMallocCall - Returns the corresponding CallInst if the instruction
|
|
/// is a malloc call. Since CallInst::CreateMalloc() only creates calls, we
|
|
/// ignore InvokeInst here.
|
|
const CallInst* extractMallocCall(const Value* I);
|
|
CallInst* extractMallocCall(Value* I);
|
|
|
|
/// extractMallocCallFromBitCast - Returns the corresponding CallInst if the
|
|
/// instruction is a bitcast of the result of a malloc call.
|
|
const CallInst* extractMallocCallFromBitCast(const Value* I);
|
|
CallInst* extractMallocCallFromBitCast(Value* I);
|
|
|
|
/// isArrayMalloc - Returns the corresponding CallInst if the instruction
|
|
/// matches the malloc call IR generated by CallInst::CreateMalloc(). This
|
|
/// means that it is a malloc call with one bitcast use AND the malloc call's
|
|
/// size argument is:
|
|
/// 1. a constant not equal to the size of the malloced type
|
|
/// or
|
|
/// 2. the result of a multiplication by the size of the malloced type
|
|
/// Otherwise it returns NULL.
|
|
/// The unique bitcast is needed to determine the type/size of the array
|
|
/// allocation.
|
|
CallInst* isArrayMalloc(Value* I, LLVMContext &Context, const TargetData* TD);
|
|
const CallInst* isArrayMalloc(const Value* I, LLVMContext &Context,
|
|
const TargetData* TD);
|
|
|
|
/// getMallocType - Returns the PointerType resulting from the malloc call.
|
|
/// This PointerType is the result type of the call's only bitcast use.
|
|
/// If there is no unique bitcast use, then return NULL.
|
|
const PointerType* getMallocType(const CallInst* CI);
|
|
|
|
/// getMallocAllocatedType - Returns the Type allocated by malloc call. This
|
|
/// Type is the result type of the call's only bitcast use. If there is no
|
|
/// unique bitcast use, then return NULL.
|
|
const Type* getMallocAllocatedType(const CallInst* CI);
|
|
|
|
/// getMallocArraySize - Returns the array size of a malloc call. For array
|
|
/// mallocs, the size is computated in 1 of 3 ways:
|
|
/// 1. If the element type is of size 1, then array size is the argument to
|
|
/// malloc.
|
|
/// 2. Else if the malloc's argument is a constant, the array size is that
|
|
/// argument divided by the element type's size.
|
|
/// 3. Else the malloc argument must be a multiplication and the array size is
|
|
/// the first operand of the multiplication.
|
|
/// For non-array mallocs, the computed size is constant 1.
|
|
/// This function returns NULL for all mallocs whose array size cannot be
|
|
/// determined.
|
|
Value* getMallocArraySize(CallInst* CI, LLVMContext &Context,
|
|
const TargetData* TD);
|
|
|
|
} // End llvm namespace
|
|
|
|
#endif
|