Commit b288f7d6 authored by Amy Huang's avatar Amy Huang
Browse files

[codeview] Fix for PR43479 

Summary:
Add instruction marker to MachineInstr ExtraInfo. This does almost the
same thing as Pre/PostInstrSymbols, except that it doesn't create a label until
printing instructions. This allows for labels to be put around instructions that
are deleted/duplicated somewhere.
Use this marker to track heap alloc site call instructions.

Reviewers: rnk

Subscribers: MatzeB, hiraditya, llvm-commits

Tags: #llvm

Differential Revision: https://reviews.llvm.org/D69536

cherry picked from 74204304 with some
modifications.
parent bc6d0f15

llvm/include/llvm/CodeGen/MachineFunction.h

+3 −12
Original line number Diff line number Diff line
@@ -787,10 +787,9 @@ public: 
  ///

  /// This is allocated on the function's allocator and so lives the life of

  /// the function.

  MachineInstr::ExtraInfo *

  createMIExtraInfo(ArrayRef<MachineMemOperand *> MMOs,

                    MCSymbol *PreInstrSymbol = nullptr,

                    MCSymbol *PostInstrSymbol = nullptr);

  MachineInstr::ExtraInfo *createMIExtraInfo(

      ArrayRef<MachineMemOperand *> MMOs, MCSymbol *PreInstrSymbol = nullptr,

      MCSymbol *PostInstrSymbol = nullptr, MDNode *HeapAllocMarker = nullptr);



  /// Allocate a string and populate it with the given external symbol name.

  const char *createExternalSymbolName(StringRef Name);
@@ -934,14 +933,6 @@ public: 
    return CodeViewAnnotations;

  }



  /// Record heapallocsites

  void addCodeViewHeapAllocSite(MachineInstr *I, MDNode *MD);



  ArrayRef<std::tuple<MCSymbol*, MCSymbol*, DIType*>>

      getCodeViewHeapAllocSites() const {

    return CodeViewHeapAllocSites;

  }



  /// Return a reference to the C++ typeinfo for the current function.

  const std::vector<const GlobalValue *> &getTypeInfos() const {

    return TypeInfos;

llvm/include/llvm/CodeGen/MachineInstr.h

+45 −7
Original line number Diff line number Diff line
@@ -137,19 +137,23 @@ private: 
  /// This has to be defined eagerly due to the implementation constraints of

  /// `PointerSumType` where it is used.

  class ExtraInfo final

      : TrailingObjects<ExtraInfo, MachineMemOperand *, MCSymbol *> {

      : TrailingObjects<ExtraInfo, MachineMemOperand *, MCSymbol *, MDNode *> {

  public:

    static ExtraInfo *create(BumpPtrAllocator &Allocator,

                             ArrayRef<MachineMemOperand *> MMOs,

                             MCSymbol *PreInstrSymbol = nullptr,

                             MCSymbol *PostInstrSymbol = nullptr) {

                             MCSymbol *PostInstrSymbol = nullptr,

                             MDNode *HeapAllocMarker = nullptr) {

      bool HasPreInstrSymbol = PreInstrSymbol != nullptr;

      bool HasPostInstrSymbol = PostInstrSymbol != nullptr;

      bool HasHeapAllocMarker = HeapAllocMarker != nullptr;

      auto *Result = new (Allocator.Allocate(

          totalSizeToAlloc<MachineMemOperand *, MCSymbol *>(

              MMOs.size(), HasPreInstrSymbol + HasPostInstrSymbol),

          totalSizeToAlloc<MachineMemOperand *, MCSymbol *, MDNode *>(

              MMOs.size(), HasPreInstrSymbol + HasPostInstrSymbol,

              HasHeapAllocMarker),

          alignof(ExtraInfo)))

          ExtraInfo(MMOs.size(), HasPreInstrSymbol, HasPostInstrSymbol);

          ExtraInfo(MMOs.size(), HasPreInstrSymbol, HasPostInstrSymbol,

                    HasHeapAllocMarker);



      // Copy the actual data into the trailing objects.

      std::copy(MMOs.begin(), MMOs.end(),
@@ -160,6 +164,8 @@ private: 
      if (HasPostInstrSymbol)

        Result->getTrailingObjects<MCSymbol *>()[HasPreInstrSymbol] =

            PostInstrSymbol;

      if (HasHeapAllocMarker)

        Result->getTrailingObjects<MDNode *>()[0] = HeapAllocMarker;



      return Result;

    }
@@ -178,6 +184,10 @@ private: 
                 : nullptr;

    }



    MDNode *getHeapAllocMarker() const {

      return HasHeapAllocMarker ? getTrailingObjects<MDNode *>()[0] : nullptr;

    }



  private:

    friend TrailingObjects;
@@ -189,6 +199,7 @@ private: 
    const int NumMMOs;

    const bool HasPreInstrSymbol;

    const bool HasPostInstrSymbol;

    const bool HasHeapAllocMarker;



    // Implement the `TrailingObjects` internal API.

    size_t numTrailingObjects(OverloadToken<MachineMemOperand *>) const {
@@ -197,12 +208,17 @@ private: 
    size_t numTrailingObjects(OverloadToken<MCSymbol *>) const {

      return HasPreInstrSymbol + HasPostInstrSymbol;

    }

    size_t numTrailingObjects(OverloadToken<MDNode *>) const {

      return HasHeapAllocMarker;

    }



    // Just a boring constructor to allow us to initialize the sizes. Always use

    // the `create` routine above.

    ExtraInfo(int NumMMOs, bool HasPreInstrSymbol, bool HasPostInstrSymbol)

    ExtraInfo(int NumMMOs, bool HasPreInstrSymbol, bool HasPostInstrSymbol,

              bool HasHeapAllocMarker)

        : NumMMOs(NumMMOs), HasPreInstrSymbol(HasPreInstrSymbol),

          HasPostInstrSymbol(HasPostInstrSymbol) {}

          HasPostInstrSymbol(HasPostInstrSymbol),

          HasHeapAllocMarker(HasHeapAllocMarker) {}

  };



  /// Enumeration of the kinds of inline extra info available. It is important
@@ -577,6 +593,16 @@ public: 
    return nullptr;

  }



  /// Helper to extract a heap alloc marker if one has been added.

  MDNode *getHeapAllocMarker() const {

    if (!Info)

      return nullptr;

    if (ExtraInfo *EI = Info.get<EIIK_OutOfLine>())

      return EI->getHeapAllocMarker();



    return nullptr;

  }



  /// API for querying MachineInstr properties. They are the same as MCInstrDesc

  /// queries but they are bundle aware.
@@ -1578,6 +1604,12 @@ public: 
  /// replace ours with it.

  void cloneInstrSymbols(MachineFunction &MF, const MachineInstr &MI);



  /// Set a marker on instructions that denotes where we should create and emit

  /// heap alloc site labels. This waits until after instruction selection and

  /// optimizations to create the label, so it should still work if the

  /// instruction is removed or duplicated.

  void setHeapAllocMarker(MachineFunction &MF, MDNode *MD);



  /// Return the MIFlags which represent both MachineInstrs. This

  /// should be used when merging two MachineInstrs into one. This routine does

  /// not modify the MIFlags of this MachineInstr.
@@ -1632,6 +1664,12 @@ private: 
  const TargetRegisterClass *getRegClassConstraintEffectForVRegImpl(

      unsigned OpIdx, unsigned Reg, const TargetRegisterClass *CurRC,

      const TargetInstrInfo *TII, const TargetRegisterInfo *TRI) const;



  /// Stores extra instruction information inline or allocates as ExtraInfo

  /// based on the number of pointers.

  void setExtraInfo(MachineFunction &MF, ArrayRef<MachineMemOperand *> MMOs,

                    MCSymbol *PreInstrSymbol, MCSymbol *PostInstrSymbol,

                    MDNode *HeapAllocMarker);

};



/// Special DenseMapInfo traits to compare MachineInstr* by *value* of the

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

+4 −12
Original line number Diff line number Diff line
@@ -1052,12 +1052,8 @@ void AsmPrinter::EmitFunctionBody() { 
        ++NumInstsInFunction;

      }



      // If there is a pre-instruction symbol, emit a label for it here. If the

      // instruction was duplicated and the label has already been emitted,

      // don't re-emit the same label.

      // FIXME: Consider strengthening that to an assertion.

      // If there is a pre-instruction symbol, emit a label for it here.

      if (MCSymbol *S = MI.getPreInstrSymbol())

        if (S->isUndefined())

        OutStreamer->EmitLabel(S);



      if (ShouldPrintDebugScopes) {
@@ -1111,12 +1107,8 @@ void AsmPrinter::EmitFunctionBody() { 
        break;

      }



      // If there is a post-instruction symbol, emit a label for it here.  If

      // the instruction was duplicated and the label has already been emitted,

      // don't re-emit the same label.

      // FIXME: Consider strengthening that to an assertion.

      // If there is a post-instruction symbol, emit a label for it here.

      if (MCSymbol *S = MI.getPostInstrSymbol())

        if (S->isUndefined())

        OutStreamer->EmitLabel(S);



      if (ShouldPrintDebugScopes) {

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

+24 −10
Original line number Diff line number Diff line
@@ -1127,15 +1127,9 @@ void CodeViewDebug::emitDebugInfoForFunction(const Function *GV, 
    }



    for (auto HeapAllocSite : FI.HeapAllocSites) {

      MCSymbol *BeginLabel = std::get<0>(HeapAllocSite);

      MCSymbol *EndLabel = std::get<1>(HeapAllocSite);



      // The labels might not be defined if the instruction was replaced

      // somewhere in the codegen pipeline.

      if (!BeginLabel->isDefined() || !EndLabel->isDefined())

        continue;



      DIType *DITy = std::get<2>(HeapAllocSite);

      const MCSymbol *BeginLabel = std::get<0>(HeapAllocSite);

      const MCSymbol *EndLabel = std::get<1>(HeapAllocSite);

      const DIType *DITy = std::get<2>(HeapAllocSite);

      MCSymbol *HeapAllocEnd = beginSymbolRecord(SymbolKind::S_HEAPALLOCSITE);

      OS.AddComment("Call site offset");

      OS.EmitCOFFSecRel32(BeginLabel, /*Offset=*/0);
@@ -1454,6 +1448,16 @@ void CodeViewDebug::beginFunctionImpl(const MachineFunction *MF) { 
    DebugLoc FnStartDL = PrologEndLoc.getFnDebugLoc();

    maybeRecordLocation(FnStartDL, MF);

  }



  // Find heap alloc sites and emit labels around them.

  for (const auto &MBB : *MF) {

    for (const auto &MI : MBB) {

      if (MI.getHeapAllocMarker()) {

        requestLabelBeforeInsn(&MI);

        requestLabelAfterInsn(&MI);

      }

    }

  }

}



static bool shouldEmitUdt(const DIType *T) {
@@ -2888,8 +2892,18 @@ void CodeViewDebug::endFunctionImpl(const MachineFunction *MF) { 
    return;

  }



  // Find heap alloc sites and add to list.

  for (const auto &MBB : *MF) {

    for (const auto &MI : MBB) {

      if (MDNode *MD = MI.getHeapAllocMarker()) {

        CurFn->HeapAllocSites.push_back(std::make_tuple(getLabelBeforeInsn(&MI),

                                                        getLabelAfterInsn(&MI),

                                                        dyn_cast<DIType>(MD)));

      }

    }

  }



  CurFn->Annotations = MF->getCodeViewAnnotations();

  CurFn->HeapAllocSites = MF->getCodeViewHeapAllocSites();



  CurFn->End = Asm->getFunctionEnd();

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.h

+2 −1
Original line number Diff line number Diff line
@@ -148,7 +148,8 @@ class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase { 
    SmallVector<LexicalBlock *, 1> ChildBlocks;



    std::vector<std::pair<MCSymbol *, MDNode *>> Annotations;

    std::vector<std::tuple<MCSymbol *, MCSymbol *, DIType *>> HeapAllocSites;

    std::vector<std::tuple<const MCSymbol *, const MCSymbol *, const DIType *>>

        HeapAllocSites;



    const MCSymbol *Begin = nullptr;

    const MCSymbol *End = nullptr;