diff --git a/lib/Analysis/AliasAnalysis.cpp b/lib/Analysis/AliasAnalysis.cpp
index 12ea937..fe3f41a 100644
--- a/lib/Analysis/AliasAnalysis.cpp
+++ b/lib/Analysis/AliasAnalysis.cpp
@@ -116,13 +116,17 @@
 AliasAnalysis::ModRefBehavior
 AliasAnalysis::getModRefBehavior(CallSite CS,
                                  std::vector<PointerAccessInfo> *Info) {
-  if (CS.doesNotAccessMemory())
+  if (CS.doesNotAccessMemory() &&
+      // FIXME: workaround gcc bootstrap breakage
+      CS.getCalledFunction() && CS.getCalledFunction()->isDeclaration())
     // Can't do better than this.
     return DoesNotAccessMemory;
   ModRefBehavior MRB = UnknownModRefBehavior;
   if (Function *F = CS.getCalledFunction())
     MRB = getModRefBehavior(F, CS, Info);
-  if (MRB != DoesNotAccessMemory && CS.onlyReadsMemory())
+  if (MRB != DoesNotAccessMemory && CS.onlyReadsMemory() &&
+      // FIXME: workaround gcc bootstrap breakage
+      CS.getCalledFunction() && CS.getCalledFunction()->isDeclaration())
     return OnlyReadsMemory;
   return MRB;
 }
@@ -130,11 +134,15 @@
 AliasAnalysis::ModRefBehavior
 AliasAnalysis::getModRefBehavior(Function *F,
                                  std::vector<PointerAccessInfo> *Info) {
-  if (F->doesNotAccessMemory())
+  if (F->doesNotAccessMemory() &&
+      // FIXME: workaround gcc bootstrap breakage
+      F->isDeclaration())
     // Can't do better than this.
     return DoesNotAccessMemory;
   ModRefBehavior MRB = getModRefBehavior(F, CallSite(), Info);
-  if (MRB != DoesNotAccessMemory && F->onlyReadsMemory())
+  if (MRB != DoesNotAccessMemory && F->onlyReadsMemory() &&
+      // FIXME: workaround gcc bootstrap breakage
+      F->isDeclaration())
     return OnlyReadsMemory;
   return MRB;
 }
diff --git a/lib/VMCore/Instruction.cpp b/lib/VMCore/Instruction.cpp
index 9b20885..7fc6245 100644
--- a/lib/VMCore/Instruction.cpp
+++ b/lib/VMCore/Instruction.cpp
@@ -13,6 +13,7 @@
 
 #include "llvm/Type.h"
 #include "llvm/Instructions.h"
+#include "llvm/IntrinsicInst.h" // FIXME: remove
 #include "llvm/Function.h"
 #include "llvm/Support/CallSite.h"
 #include "llvm/Support/LeakDetector.h"
@@ -208,6 +209,8 @@
   case Instruction::VAArg:
     return true;
   case Instruction::Call:
+    if (!isa<IntrinsicInst>(this))
+      return true; // FIXME: workaround gcc bootstrap breakage
     return !cast<CallInst>(this)->onlyReadsMemory();
   case Instruction::Load:
     return cast<LoadInst>(this)->isVolatile();
