1 //===- llvm/Analysis/MemoryBuiltins.h- Calls to memory builtins -*- C++ -*-===//
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 family of functions identifies calls to builtin functions that allocate
11 // or free memory.
12 //
13 //===----------------------------------------------------------------------===//
14
15 #ifndef LLVM_ANALYSIS_MEMORYBUILTINS_H
16 #define LLVM_ANALYSIS_MEMORYBUILTINS_H
17
18 namespace llvm {
19 class CallInst;
20 class PointerType;
21 class TargetData;
22 class Type;
23 class Value;
24
25 //===----------------------------------------------------------------------===//
26 // malloc Call Utility Functions.
27 //
28
29 /// isMalloc - Returns true if the value is either a malloc call or a bitcast of
30 /// the result of a malloc call
31 bool isMalloc(const Value *I);
32
33 /// extractMallocCall - Returns the corresponding CallInst if the instruction
34 /// is a malloc call. Since CallInst::CreateMalloc() only creates calls, we
35 /// ignore InvokeInst here.
36 const CallInst *extractMallocCall(const Value *I);
37 CallInst *extractMallocCall(Value *I);
38
39 /// extractMallocCallFromBitCast - Returns the corresponding CallInst if the
40 /// instruction is a bitcast of the result of a malloc call.
41 const CallInst *extractMallocCallFromBitCast(const Value *I);
42 CallInst *extractMallocCallFromBitCast(Value *I);
43
44 /// isArrayMalloc - Returns the corresponding CallInst if the instruction
45 /// is a call to malloc whose array size can be determined and the array size
46 /// is not constant 1. Otherwise, return NULL.
47 const CallInst *isArrayMalloc(const Value *I, const TargetData *TD);
48
49 /// getMallocType - Returns the PointerType resulting from the malloc call.
50 /// The PointerType depends on the number of bitcast uses of the malloc call:
51 /// 0: PointerType is the malloc calls' return type.
52 /// 1: PointerType is the bitcast's result type.
53 /// >1: Unique PointerType cannot be determined, return NULL.
54 PointerType *getMallocType(const CallInst *CI);
55
56 /// getMallocAllocatedType - Returns the Type allocated by malloc call.
57 /// The Type depends on the number of bitcast uses of the malloc call:
58 /// 0: PointerType is the malloc calls' return type.
59 /// 1: PointerType is the bitcast's result type.
60 /// >1: Unique PointerType cannot be determined, return NULL.
61 Type *getMallocAllocatedType(const CallInst *CI);
62
63 /// getMallocArraySize - Returns the array size of a malloc call. If the
64 /// argument passed to malloc is a multiple of the size of the malloced type,
65 /// then return that multiple. For non-array mallocs, the multiple is
66 /// constant 1. Otherwise, return NULL for mallocs whose array size cannot be
67 /// determined.
68 Value *getMallocArraySize(CallInst *CI, const TargetData *TD,
69 bool LookThroughSExt = false);
70
71 //===----------------------------------------------------------------------===//
72 // free Call Utility Functions.
73 //
74
75 /// isFreeCall - Returns non-null if the value is a call to the builtin free()
76 const CallInst *isFreeCall(const Value *I);
77
isFreeCall(Value * I)78 static inline CallInst *isFreeCall(Value *I) {
79 return const_cast<CallInst*>(isFreeCall((const Value*)I));
80 }
81
82 } // End llvm namespace
83
84 #endif
85