[AliasAnalysis] Initialize a member variable that may be used by unit test.

[peter.smith]

Summary

The unit tests in BasicAliasAnalysisTest use the alias analysis API directly and do not call setAAResults to initalize AAR. This gives a valgrind error "Conditional Jump depends on unitialized variable". On most buildbots the variable is nullptr, but in some cases it can be non nullptr leading to seemingly random failures.

In this particular case it looks like initializing to nullptr is sound as results should be standalone unless they've been explicitly aggregated.

These tests were disabled in r366986 as some unrelated changes to the unittests changed the memory allocation and caused the two tests to start failing. With the initialization they can be enabled again.

Fixes PR42719

I know very little about AA myself, there may be a way of rewriting the UnitTests so that it doesn't hit an unitialized variable, or a better fix, I'd need to hand over to an expert for that. I've picked some reviewers from the history of the file.

[asbirlea]

LGTM, thanks for the patch!

[george.burgess.iv]

Thanks!

llvm/trunk/include/llvm/Analysis/AliasAnalysis.h

 template <typename DerivedT> class AAResultBase {
   // Expose some parts of the interface only to the AAResults::Model
   // for wrapping. Specifically, this allows the model to call our
   // setAAResults method without exposing it as a fully public API.
   friend class AAResults::Model<DerivedT>;
 
   /// A pointer to the AAResults object that this AAResult is
   /// aggregated within. May be null if not aggregated.
-  AAResults *AAR;
+  AAResults *AAR = nullptr;
 
   /// Helper to dispatch calls back through the derived type.
   DerivedT &derived() { return static_cast<DerivedT &>(*this); }
 
   /// A setter for the AAResults pointer, which is used to satisfy the
   /// AAResults::Model contract.
   void setAAResults(AAResults *NewAAR) { AAR = NewAAR; }
 

llvm/trunk/unittests/Analysis/BasicAliasAnalysisTest.cpp

TestAnalyses &setupAnalyses() {
     return Analyses.getValue();
   }
 
 public:
   BasicAATest()
       : M("BasicAATest", C), B(C), DL(DLString), TLI(TLII), F(nullptr) {}
 };
 
-// FIXME: Both of these are disabled at the moment due to strange buildbot
-// failures. Please see https://bugs.llvm.org/show_bug.cgi?id=42719
-
 // Check that a function arg can't trivially alias a global when we're accessing
 // >sizeof(global) bytes through that arg, unless the access size is just an
 // upper-bound.
-TEST_F(BasicAATest, DISABLED_AliasInstWithObjectOfImpreciseSize) {
+TEST_F(BasicAATest, AliasInstWithObjectOfImpreciseSize) {
   F = Function::Create(
       FunctionType::get(B.getVoidTy(), {B.getInt32Ty()->getPointerTo()}, false),
       GlobalValue::ExternalLinkage, "F", &M);
 
   BasicBlock *Entry(BasicBlock::Create(C, "", F));
   B.SetInsertPoint(Entry);
 
   Value *IncomingI32Ptr = F->arg_begin();
TEST_F(BasicAATest, AliasInstWithObjectOfImpreciseSize) {
   ASSERT_EQ(
       BasicAA.alias(MemoryLocation(IncomingI32Ptr, LocationSize::upperBound(4)),
                     MemoryLocation(GlobalPtr, LocationSize::precise(1)), AAQI),
       AliasResult::MayAlias);
 }
 
 // Check that we fall back to MayAlias if we see an access of an entire object
 // that's just an upper-bound.
-TEST_F(BasicAATest, DISABLED_AliasInstWithFullObjectOfImpreciseSize) {
+TEST_F(BasicAATest, AliasInstWithFullObjectOfImpreciseSize) {
   F = Function::Create(
       FunctionType::get(B.getVoidTy(), {B.getInt64Ty()}, false),
       GlobalValue::ExternalLinkage, "F", &M);
 
   BasicBlock *Entry(BasicBlock::Create(C, "", F));
   B.SetInsertPoint(Entry);
 
   Value *ArbitraryI32 = F->arg_begin();