[PowerPC] Fix downcast from nullptr

[ngzhian]

Summary

getTargetStreamer() might return null (e.g. when running
inlined-strings.ll test), downcasting to a reference will be wrong. This
is detectable with -fsanitize=null.

[steven.zhang]

Missing test. And PPCAIXAsmPrinter::emitEndOfAsmFile also has issues if it could be null. And it seems that, we miss this check also in:

./AsmParser/PPCAsmParser.cpp:           getParser().getStreamer().getTargetStreamer());
./AsmParser/PPCAsmParser.cpp:           getParser().getStreamer().getTargetStreamer());
./AsmParser/PPCAsmParser.cpp:           getParser().getStreamer().getTargetStreamer());

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1415–1416

null check ?

[ngzhian]

Add null check

[ngzhian]

I don't have a good idea how to add test for this. With an ASAN build with -fsanitize=null, we get an error when running inlined-strings.ll.

[steven.zhang]

It is better to have some tests. You can get it by adding assertion for TS and then, running the test to see if any test trigger this assertion. And please also fix this for PPCAIXAsmPrinter and PPCAsmParser together. Thank you.

[ngzhian]

Add some tests for null streamer. Fix more instances of downcast from nullptr.

[ngzhian]

Thanks for the advice, Steven. I found some existing tests that exercised the particular downcasting logic, and found that if I set -filetype=null in those RUN: directives, I could trigger a crash. So I added a line to those tests. Also made the same fix to PPCAsmParser and PPCAIXAsmPrinter.

[steven.zhang]

LGTM, thank you for the fixing.

[ngzhian]

Thanks Steven, I do not have commit access, can you please help me commit this?

[steven.zhang]

In D78686#2005604, @ngzhian wrote:

Thanks Steven, I do not have commit access, can you please help me commit this?

Sure.

llvm/lib/Target/PowerPC/AsmParser/PPCAsmParser.cpp

bool PPCAsmParser::ParseDirectiveMachine(SMLoc L) {
   if (CPU != "any" && CPU != "push" && CPU != "pop")
     return TokError("unrecognized machine type");
 
   Parser.Lex();
 
   if (parseToken(AsmToken::EndOfStatement))
     return addErrorSuffix(" in '.machine' directive");
 
-  PPCTargetStreamer &TStreamer =
-      *static_cast<PPCTargetStreamer *>(
-           getParser().getStreamer().getTargetStreamer());
-  TStreamer.emitMachine(CPU);
+  PPCTargetStreamer *TStreamer = static_cast<PPCTargetStreamer *>(
+  if (TStreamer != nullptr)
+    TStreamer->emitMachine(CPU);
 
   return false;
 }
 
 /// ParseDarwinDirectiveMachine (Mach-o platforms)
 ///  ::= .machine cpu-identifier
 bool PPCAsmParser::ParseDarwinDirectiveMachine(SMLoc L) {
   MCAsmParser &Parser = getParser();

 ///  ::= .abiversion constant-expression
 bool PPCAsmParser::ParseDirectiveAbiVersion(SMLoc L) {
   int64_t AbiVersion;
   if (check(getParser().parseAbsoluteExpression(AbiVersion), L,
             "expected constant expression") ||
       parseToken(AsmToken::EndOfStatement))
     return addErrorSuffix(" in '.abiversion' directive");
 
-  PPCTargetStreamer &TStreamer =
-      *static_cast<PPCTargetStreamer *>(
-           getParser().getStreamer().getTargetStreamer());
-  TStreamer.emitAbiVersion(AbiVersion);
+  PPCTargetStreamer *TStreamer = static_cast<PPCTargetStreamer *>(
+  if (TStreamer != nullptr)
+    TStreamer->emitAbiVersion(AbiVersion);
 
   return false;
 }
 
 /// ParseDirectiveLocalEntry
 ///  ::= .localentry symbol, expression
 bool PPCAsmParser::ParseDirectiveLocalEntry(SMLoc L) {
   StringRef Name;
   if (getParser().parseIdentifier(Name))
     return Error(L, "expected identifier in '.localentry' directive");
 
   MCSymbolELF *Sym = cast<MCSymbolELF>(getContext().getOrCreateSymbol(Name));
   const MCExpr *Expr;
 
   if (parseToken(AsmToken::Comma) ||
       check(getParser().parseExpression(Expr), L, "expected expression") ||
       parseToken(AsmToken::EndOfStatement))
     return addErrorSuffix(" in '.localentry' directive");
 
-  PPCTargetStreamer &TStreamer =
-      *static_cast<PPCTargetStreamer *>(
-           getParser().getStreamer().getTargetStreamer());
-  TStreamer.emitLocalEntry(Sym, Expr);
+  PPCTargetStreamer *TStreamer = static_cast<PPCTargetStreamer *>(
+  if (TStreamer != nullptr)
+    TStreamer->emitLocalEntry(Sym, Expr);
 
   return false;
 }
 
 
 
 /// Force static initialization.
 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializePowerPCAsmParser() {

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

void PPCLinuxAsmPrinter::emitFunctionEntryLabel() {
   OutStreamer->SwitchSection(Current.first, Current.second);
 }
 
 void PPCLinuxAsmPrinter::emitEndOfAsmFile(Module &M) {
   const DataLayout &DL = getDataLayout();
 
   bool isPPC64 = DL.getPointerSizeInBits() == 64;
 
-  PPCTargetStreamer &TS =
-      static_cast<PPCTargetStreamer &>(*OutStreamer->getTargetStreamer());
+  PPCTargetStreamer *TS =
+      static_cast<PPCTargetStreamer *>(OutStreamer->getTargetStreamer());
 
   if (!TOC.empty()) {
     const char *Name = isPPC64 ? ".toc" : ".got2";
     MCSectionELF *Section = OutContext.getELFSection(
         Name, ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC);
     OutStreamer->SwitchSection(Section);
     if (!isPPC64)
       OutStreamer->emitValueToAlignment(4);
 
     for (const auto &TOCMapPair : TOC) {
       const MCSymbol *const TOCEntryTarget = TOCMapPair.first;
       MCSymbol *const TOCEntryLabel = TOCMapPair.second;
 
       OutStreamer->emitLabel(TOCEntryLabel);
-      if (isPPC64)
-        TS.emitTCEntry(*TOCEntryTarget);
+      if (isPPC64 && TS != nullptr)
+        TS->emitTCEntry(*TOCEntryTarget);
       else
         OutStreamer->emitSymbolValue(TOCEntryTarget, 4);
     }
   }
 
   PPCAsmPrinter::emitEndOfAsmFile(M);
 }
 
void PPCAIXAsmPrinter::emitEndOfAsmFile(Module &M) {
   // If there are no functions in this module, we will never need to reference
   // the TOC base.
   if (M.empty())
     return;
 
   // Switch to section to emit TOC base.
   OutStreamer->SwitchSection(getObjFileLowering().getTOCBaseSection());
 
-  PPCTargetStreamer &TS =
-      static_cast<PPCTargetStreamer &>(*OutStreamer->getTargetStreamer());
+  PPCTargetStreamer *TS =
+      static_cast<PPCTargetStreamer *>(OutStreamer->getTargetStreamer());
 
   const unsigned EntryByteSize = Subtarget->isPPC64() ? 8 : 4;
   const unsigned TOCEntriesByteSize = TOC.size() * EntryByteSize;
   // TODO: If TOC entries' size is larger than 32768, then we run out of
   // positive displacement to reach the TOC entry. We need to decide how to
   // handle entries' size larger than that later.
   if (TOCEntriesByteSize > 32767) {
     report_fatal_error("Handling of TOC entry displacement larger than 32767 "
                        "is not yet implemented.");
   }
 
   for (auto &I : TOC) {
     // Setup the csect for the current TC entry.
     MCSectionXCOFF *TCEntry = cast<MCSectionXCOFF>(
         getObjFileLowering().getSectionForTOCEntry(I.first));
     OutStreamer->SwitchSection(TCEntry);
 
     OutStreamer->emitLabel(I.second);
-    TS.emitTCEntry(*I.first);
+    if (TS != nullptr)
+      TS->emitTCEntry(*I.first);
   }
 }
 
 /// createPPCAsmPrinterPass - Returns a pass that prints the PPC assembly code
 /// for a MachineFunction to the given output stream, in a format that the
 /// Darwin assembler can deal with.
 ///
 static AsmPrinter *

llvm/test/CodeGen/PowerPC/ppc64-toc.ll

 ; RUN: llc -verify-machineinstrs -code-model=small < %s | FileCheck %s
+; Test with null streamer.
+; RUN: llc -O0 -filetype=null < %s
 target datalayout = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64"
 target triple = "powerpc64-unknown-linux-gnu"
 
 @double_array = global [32 x double] zeroinitializer, align 8
 @number64 = global i64 10, align 8
 @internal_static_var.x = internal unnamed_addr global i64 0, align 8
 
 define i64 @access_int64(i64 %a) nounwind readonly {

llvm/test/MC/PowerPC/ppc-machine.s

 # RUN: llvm-mc -triple powerpc-unknown-unknown %s
 # RUN: llvm-mc -triple powerpc64-unknown-unknown %s
 # RUN: llvm-mc -triple powerpc64le-unknown-unknown %s
+# RUN: llvm-mc -triple powerpc64le-unknown-unknown -filetype=null %s
 
 # For now, the only thing we check is that the .machine directive
 # is accepted without syntax error.
 
   .machine push
   .machine any
   .machine pop
 
   .machine "push"
   .machine "any"
   .machine "pop"
 

llvm/test/MC/PowerPC/ppc64-abiversion.s

 
 # RUN: llvm-mc -triple powerpc64-unknown-unknown -filetype=obj %s | \
 # RUN: llvm-readobj -h | FileCheck %s
 # RUN: llvm-mc -triple powerpc64le-unknown-unknown -filetype=obj %s | \
 # RUN: llvm-readobj -h | FileCheck %s
+# RUN: llvm-mc -triple powerpc64le-unknown-unknown -filetype=null %s
 
   .abiversion 2
 # CHECK: Flags [ (0x2)