/tmp/buildd/llvm-toolchain-snapshot-3.9~svn271203/lib/Transforms/Scalar/ScalarReplAggregates.cpp

Bug Summary

File:	lib/Transforms/Scalar/ScalarReplAggregates.cpp
Location:	line 1997, column 13
Description:	Called C++ object pointer is null

Annotated Source Code

//===- ScalarReplAggregates.cpp - Scalar Replacement of Aggregates --------===//

// The LLVM Compiler Infrastructure

// This file is distributed under the University of Illinois Open Source

// License. See LICENSE.TXT for details.

//===----------------------------------------------------------------------===//

// This transformation implements the well known scalar replacement of

// aggregates transformation. This xform breaks up alloca instructions of

// aggregate type (structure or array) into individual alloca instructions for

// each member (if possible). Then, if possible, it transforms the individual

// alloca instructions into nice clean scalar SSA form.

// This combines a simple SRoA algorithm with the Mem2Reg algorithm because they

// often interact, especially for C++ programs. As such, iterating between

// SRoA, then Mem2Reg until we run out of things to promote works well.

//===----------------------------------------------------------------------===//

#include "llvm/Transforms/Scalar.h"

#include "llvm/ADT/SetVector.h"

#include "llvm/ADT/SmallVector.h"

#include "llvm/ADT/Statistic.h"

#include "llvm/Analysis/AssumptionCache.h"

#include "llvm/Analysis/Loads.h"

#include "llvm/Analysis/ValueTracking.h"

#include "llvm/IR/CallSite.h"

#include "llvm/IR/Constants.h"

#include "llvm/IR/DIBuilder.h"

#include "llvm/IR/DataLayout.h"

#include "llvm/IR/DebugInfo.h"

#include "llvm/IR/DerivedTypes.h"

#include "llvm/IR/Dominators.h"

#include "llvm/IR/Function.h"

#include "llvm/IR/GetElementPtrTypeIterator.h"

#include "llvm/IR/GlobalVariable.h"

#include "llvm/IR/IRBuilder.h"

#include "llvm/IR/Instructions.h"

#include "llvm/IR/IntrinsicInst.h"

#include "llvm/IR/LLVMContext.h"

#include "llvm/IR/Module.h"

#include "llvm/IR/Operator.h"

#include "llvm/Pass.h"

#include "llvm/Support/Debug.h"

#include "llvm/Support/ErrorHandling.h"

#include "llvm/Support/MathExtras.h"

#include "llvm/Support/raw_ostream.h"

#include "llvm/Transforms/Utils/Local.h"

#include "llvm/Transforms/Utils/PromoteMemToReg.h"

#include "llvm/Transforms/Utils/SSAUpdater.h"

using namespace llvm;

#define DEBUG_TYPE"scalarrepl" "scalarrepl"

STATISTIC(NumReplaced, "Number of allocas broken up")static llvm::Statistic NumReplaced = { "scalarrepl", "Number of allocas broken up"
, 0, 0 };

STATISTIC(NumPromoted, "Number of allocas promoted")static llvm::Statistic NumPromoted = { "scalarrepl", "Number of allocas promoted"
, 0, 0 };

STATISTIC(NumAdjusted, "Number of scalar allocas adjusted to allow promotion")static llvm::Statistic NumAdjusted = { "scalarrepl", "Number of scalar allocas adjusted to allow promotion"
, 0, 0 };

STATISTIC(NumConverted, "Number of aggregates converted to scalar")static llvm::Statistic NumConverted = { "scalarrepl", "Number of aggregates converted to scalar"
, 0, 0 };

namespace {

#define SROASROA_ SROA_

struct SROASROA_ : public FunctionPass {

SROASROA_(int T, bool hasDT, char &ID, int ST, int AT, int SLT)

: FunctionPass(ID), HasDomTree(hasDT) {

if (T == -1)

SRThreshold = 128;

else

SRThreshold = T;

if (ST == -1)

StructMemberThreshold = 32;

else

StructMemberThreshold = ST;

if (AT == -1)

ArrayElementThreshold = 8;

else

ArrayElementThreshold = AT;

if (SLT == -1)

// Do not limit the scalar integer load size if no threshold is given.

ScalarLoadThreshold = -1;

else

ScalarLoadThreshold = SLT;

}

bool runOnFunction(Function &F) override;

bool performScalarRepl(Function &F);

bool performPromotion(Function &F);

private:

bool HasDomTree;

/// DeadInsts - Keep track of instructions we have made dead, so that

/// we can remove them after we are done working.

SmallVector<Value*, 32> DeadInsts;

/// AllocaInfo - When analyzing uses of an alloca instruction, this captures

/// information about the uses. All these fields are initialized to false

100

/// and set to true when something is learned.

101

struct AllocaInfo {

102

/// The alloca to promote.

103

AllocaInst *AI;

104

105

/// CheckedPHIs - This is a set of verified PHI nodes, to prevent infinite

106

/// looping and avoid redundant work.

107

SmallPtrSet<PHINode*, 8> CheckedPHIs;

108

109

/// isUnsafe - This is set to true if the alloca cannot be SROA'd.

110

bool isUnsafe : 1;

111

112

/// isMemCpySrc - This is true if this aggregate is memcpy'd from.

113

bool isMemCpySrc : 1;

114

115

/// isMemCpyDst - This is true if this aggregate is memcpy'd into.

116

bool isMemCpyDst : 1;

117

118

/// hasSubelementAccess - This is true if a subelement of the alloca is

119

/// ever accessed, or false if the alloca is only accessed with mem

120

/// intrinsics or load/store that only access the entire alloca at once.

121

bool hasSubelementAccess : 1;

122

123

/// hasALoadOrStore - This is true if there are any loads or stores to it.

124

/// The alloca may just be accessed with memcpy, for example, which would

125

/// not set this.

126

bool hasALoadOrStore : 1;

127

128

explicit AllocaInfo(AllocaInst *ai)

129

: AI(ai), isUnsafe(false), isMemCpySrc(false), isMemCpyDst(false),

130

hasSubelementAccess(false), hasALoadOrStore(false) {}

131

};

132

133

/// SRThreshold - The maximum alloca size to considered for SROA.

134

unsigned SRThreshold;

135

136

/// StructMemberThreshold - The maximum number of members a struct can

137

/// contain to be considered for SROA.

138

unsigned StructMemberThreshold;

139

140

/// ArrayElementThreshold - The maximum number of elements an array can

141

/// have to be considered for SROA.

142

unsigned ArrayElementThreshold;

143

144

/// ScalarLoadThreshold - The maximum size in bits of scalars to load when

145

/// converting to scalar

146

unsigned ScalarLoadThreshold;

147

148

void MarkUnsafe(AllocaInfo &I, Instruction *User) {

149

I.isUnsafe = true;

150

DEBUG(dbgs() << " Transformation preventing inst: " << *User << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("scalarrepl")) { dbgs() << " Transformation preventing inst: "
<< *User << '\n'; } } while (0);

151

}

152

153

bool isSafeAllocaToScalarRepl(AllocaInst *AI);

154

155

void isSafeForScalarRepl(Instruction *I, uint64_t Offset, AllocaInfo &Info);

156

void isSafePHISelectUseForScalarRepl(Instruction *User, uint64_t Offset,

157

AllocaInfo &Info);

158

void isSafeGEP(GetElementPtrInst *GEPI, uint64_t &Offset, AllocaInfo &Info);

159

void isSafeMemAccess(uint64_t Offset, uint64_t MemSize,

160

Type *MemOpType, bool isStore, AllocaInfo &Info,

161

Instruction *TheAccess, bool AllowWholeAccess);

162

bool TypeHasComponent(Type *T, uint64_t Offset, uint64_t Size,

163

const DataLayout &DL);

164

uint64_t FindElementAndOffset(Type *&T, uint64_t &Offset, Type *&IdxTy,

165

const DataLayout &DL);

166

167

void DoScalarReplacement(AllocaInst *AI,

168

std::vector<AllocaInst*> &WorkList);

169

void DeleteDeadInstructions();

170

171

void RewriteForScalarRepl(Instruction *I, AllocaInst *AI, uint64_t Offset,

172