[MC] Add MCSubtargetInfo to MCPaddingFragment [NFC]

[peter.smith]

Summary

In preparation for passing the MCSubtargetInfo (STI) through to writeNops so that it can use the STI in operation at the time, we need to record the STI in operation when a MCPaddingFragment is created. The STI is currently unused, a further patch will pass it through to writeNops.

This is part 2 of 4 of a patch series to pass MCSubtargetInfo to writeNops so that the ARM and X86 AsmBackends can remove the per-module STI that is used to decide which nop encodings can be used.
1 [MC] Move bundling and MCSubtargetInfo to MCEncodedFragment [NFC]
2 [MC] Add MCSubtargetInfo to MCPaddingFragment [NFC]
3 [MC] Add MCSubtargetInfo to MCAlignFragment [NFC]
4 [MC] Use local MCSubtargetInfo in writeNops

This patch depends on D44928.

[peter.smith]

Rebased [NFC]

[asb]

Other than two tiny formatting issues, this looks good to me.

include/llvm/MC/MCFragment.h

382

Normal LLVM style would be const MCSubtargetInfo &STI

include/llvm/MC/MCObjectStreamer.h

79

Normal LLVM style would be const MCSubtargetInfo &STI

[asb]

Just a ping on landing this. Are you awaiting additional reviews?

[peter.smith]

Yes, my apologies for not following up.
This is an enabling patch for allowing writeNops() to use a passed in Subtarget. There are 3 parts:

• Add STI to MCPaddingFragment (This review)
• Add STI to MCAlignFragment D45961
• Actually use the STI in the fragments to pass to writeNops() D45962

This and D45961 have no users without D45962 . I'm happy to rebase and work on D45961, D45962 but it would probably be worth committing all or none of them.

[asb]

Ah - I was waiting for this to be committed before returning to review the rest!

I'll circle back to reviewing the remaining two patches this week.

include/llvm/MC/MCAsmBackend.h

public:
   }
 
   /// Handles all target related code padding when starting to write a new
   /// basic block to an object file.
   ///
   /// \param OS The streamer used for writing the padding data and function.
   /// \param Context the context of the padding, Embeds the basic block's
   /// parameters.
+  /// \param STI the subtarget in effect when the basic block was created.
   void handleCodePaddingBasicBlockStart(MCObjectStreamer *OS,
-                                        const MCCodePaddingContext &Context);
+                                        const MCCodePaddingContext &Context,
+                                        const MCSubtargetInfo &STI);
   /// Handles all target related code padding after writing a block to an object
   /// file.
   ///
   /// \param Context the context of the padding, Embeds the basic block's
   /// parameters.
   void handleCodePaddingBasicBlockEnd(const MCCodePaddingContext &Context);
   /// Handles all target related code padding before writing a new instruction
   /// to an object file.
   ///
   /// \param Inst the instruction.
-  void handleCodePaddingInstructionBegin(const MCInst &Inst);
+  /// \param STI the subtarget in effect when the instruction was encoded.
+  void handleCodePaddingInstructionBegin(const MCInst &Inst,
+                                         const MCSubtargetInfo &STI);
   /// Handles all target related code padding after writing an instruction to an
   /// object file.
   ///
   /// \param Inst the instruction.
   void handleCodePaddingInstructionEnd(const MCInst &Inst);
 
   /// Relaxes a fragment (changes the size of the padding) according to target
   /// requirements. The new size computation is done w.r.t a layout.

include/llvm/MC/MCCodePadder.h

public:
   virtual ~MCCodePadder();
 
   /// Handles all target related code padding when starting to write a new
   /// basic block to an object file.
   ///
   /// \param OS The streamer used for writing the padding data and function.
   /// \param Context the context of the padding, Embeds the basic block's
   /// parameters.
+  /// \param STI The MCSubtargetInfo in operation when basic block is emitted.
   void handleBasicBlockStart(MCObjectStreamer *OS,
-                             const MCCodePaddingContext &Context);
+                             const MCCodePaddingContext &Context,
+                             const MCSubtargetInfo &STI);
   /// Handles all target related code padding when done writing a block to an
   /// object file.
   ///
   /// \param Context the context of the padding, Embeds the basic block's
   /// parameters.
   void handleBasicBlockEnd(const MCCodePaddingContext &Context);
   /// Handles all target related code padding before writing a new instruction
   /// to an object file.
   ///
   /// \param Inst the instruction.
-  void handleInstructionBegin(const MCInst &Inst);
+  /// \param STI the MCSubtargetInfo in operation when the instruction was
+  /// encoded.
+  void handleInstructionBegin(const MCInst &Inst, const MCSubtargetInfo &STI);
   /// Handles all target related code padding after writing an instruction to an
   /// object file.
   ///
   /// \param Inst the instruction.
   void handleInstructionEnd(const MCInst &Inst);
 
   /// Relaxes a fragment (changes the size of the padding) according to target
   /// requirements. The new size computation is done w.r.t a layout.

include/llvm/MC/MCFragment.h

class MCPaddingFragment : public MCFragment {
   uint64_t PaddingPoliciesMask;
   /// A boolean indicating if this fragment will actually hold padding. If its
   /// value is false, then this fragment serves only as a placeholder,
   /// containing data to assist other insertion point in their decision making.
   bool IsInsertionPoint;
 
   uint64_t Size;
 
+  const MCSubtargetInfo &STI;
+
   struct MCInstInfo {
     bool IsInitialized;
     MCInst Inst;
     /// A boolean indicating whether the instruction pointed by this fragment is
     /// a fixed size instruction or a relaxable instruction held by a
     /// MCRelaxableFragment.
     bool IsImmutableSizedInst;
     union {
enum MCPaddingFragmentKind {
     // values 0-7 are reserved for future target independet values.
 
     FirstTargetPerfNopFragmentKind = 8,
 
     /// Limit range of target MCPerfNopFragment kinds to fit in uint64_t
     MaxTargetPerfNopFragmentKind = 63
   };
 
-  MCPaddingFragment(MCSection *Sec = nullptr)
+  MCPaddingFragment(const MCSubtargetInfo& STI, MCSection *Sec = nullptr)
       : MCFragment(FT_Padding, false, Sec), PaddingPoliciesMask(PFK_None),
-        IsInsertionPoint(false), Size(UINT64_C(0)),
+        IsInsertionPoint(false), Size(UINT64_C(0)), STI(STI),
         InstInfo({false, MCInst(), false, {0}}) {}
 
   bool isInsertionPoint() const { return IsInsertionPoint; }
   void setAsInsertionPoint() { IsInsertionPoint = true; }
   uint64_t getPaddingPoliciesMask() const { return PaddingPoliciesMask; }
   void setPaddingPoliciesMask(uint64_t Value) { PaddingPoliciesMask = Value; }
   bool hasPaddingPolicy(uint64_t PolicyMask) const {
     assert(isPowerOf2_64(PolicyMask) &&
void setInstAndInstFragment(const MCInst &Inst,
     InstInfo.IsInitialized = true;
     InstInfo.IsImmutableSizedInst = false;
     InstInfo.Inst = Inst;
     InstInfo.InstFragment = InstFragment;
   }
   uint64_t getSize() const { return Size; }
   void setSize(uint64_t Value) { Size = Value; }
   bool isInstructionInitialized() const { return InstInfo.IsInitialized; }
-
+  const MCSubtargetInfo &getSubtargetInfo() const { return STI; }
   static bool classof(const MCFragment *F) {
     return F->getKind() == MCFragment::FT_Padding;
   }
 };
 
 class MCFillFragment : public MCFragment {
   /// Value to use for filling bytes.
   uint64_t Value;

include/llvm/MC/MCObjectStreamer.h

void insert(MCFragment *F) {
     F->setParent(CurSection);
   }
 
   /// Get a data fragment to write into, creating a new one if the current
   /// fragment is not a data fragment.
   /// Optionally a \p STI can be passed in so that a new fragment is created
   /// if the Subtarget differs from the current fragment.
   MCDataFragment *getOrCreateDataFragment(const MCSubtargetInfo* STI = nullptr);
-  MCPaddingFragment *getOrCreatePaddingFragment();
+  MCPaddingFragment *getOrCreatePaddingFragment(const MCSubtargetInfo& STI);
 
 protected:
   bool changeSectionImpl(MCSection *Section, const MCExpr *Subsection);
 
   /// If any labels have been emitted but not assigned fragments, ensure that
   /// they get assigned, either to F if possible or to a new data fragment.
   /// Optionally, it is also possible to provide an offset \p FOffset, which
   /// will be used as a symbol offset within the fragment.
public:
   void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0,
                             unsigned ValueSize = 1,
                             unsigned MaxBytesToEmit = 0) override;
   void EmitCodeAlignment(unsigned ByteAlignment,
                          unsigned MaxBytesToEmit = 0) override;
   void emitValueToOffset(const MCExpr *Offset, unsigned char Value,
                          SMLoc Loc) override;
   void
-  EmitCodePaddingBasicBlockStart(const MCCodePaddingContext &Context) override;
+  EmitCodePaddingBasicBlockStart(const MCCodePaddingContext &Context,
+                                 const MCSubtargetInfo &STI) override;
   void
   EmitCodePaddingBasicBlockEnd(const MCCodePaddingContext &Context) override;
   void EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
                              unsigned Column, unsigned Flags,
                              unsigned Isa, unsigned Discriminator,
                              StringRef FileName) override;
   void EmitDwarfAdvanceLineAddr(int64_t LineDelta, const MCSymbol *LastLabel,
                                 const MCSymbol *Label,

include/llvm/MC/MCStreamer.h

public:
   ///
   /// \param Offset - The offset to reach. This may be an expression, but the
   /// expression must be associated with the current section.
   /// \param Value - The value to use when filling bytes.
   virtual void emitValueToOffset(const MCExpr *Offset, unsigned char Value,
                                  SMLoc Loc);
 
   virtual void
-  EmitCodePaddingBasicBlockStart(const MCCodePaddingContext &Context) {}
+  EmitCodePaddingBasicBlockStart(const MCCodePaddingContext &Context,
+                                 const MCSubtargetInfo &STI) {}
 
   virtual void
   EmitCodePaddingBasicBlockEnd(const MCCodePaddingContext &Context) {}
 
   /// @}
 
   /// Switch to a new logical file.  This is used to implement the '.file
   /// "foo.c"' assembler directive.

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

if (MBB.isEHFuncletEntry()) {
     }
   }
 
   // Emit an alignment directive for this block, if needed.
   if (unsigned Align = MBB.getAlignment())
     EmitAlignment(Align);
   MCCodePaddingContext Context;
   setupCodePaddingContext(MBB, Context);
-  OutStreamer->EmitCodePaddingBasicBlockStart(Context);
+  OutStreamer->EmitCodePaddingBasicBlockStart(Context, MF->getSubtarget());
 
   // If the block has its address taken, emit any labels that were used to
   // reference the block.  It is possible that there is more than one label
   // here, because multiple LLVM BB's may have been RAUW'd to this block after
   // the references were generated.
   if (MBB.hasAddressTaken()) {
     const BasicBlock *BB = MBB.getBasicBlock();
     if (isVerbose())

lib/MC/MCAsmBackend.cpp

bool MCAsmBackend::fixupNeedsRelaxationAdvanced(
     const MCRelaxableFragment *DF, const MCAsmLayout &Layout,
     const bool WasForced) const {
   if (!Resolved)
     return true;
   return fixupNeedsRelaxation(Fixup, Value, DF, Layout);
 }
 
 void MCAsmBackend::handleCodePaddingBasicBlockStart(
-    MCObjectStreamer *OS, const MCCodePaddingContext &Context) {
-  CodePadder->handleBasicBlockStart(OS, Context);
+    MCObjectStreamer *OS, const MCCodePaddingContext &Context,
+    const MCSubtargetInfo &STI) {
+  CodePadder->handleBasicBlockStart(OS, Context, STI);
 }
 
 void MCAsmBackend::handleCodePaddingBasicBlockEnd(
     const MCCodePaddingContext &Context) {
   CodePadder->handleBasicBlockEnd(Context);
 }
 
-void MCAsmBackend::handleCodePaddingInstructionBegin(const MCInst &Inst) {
-  CodePadder->handleInstructionBegin(Inst);
+void MCAsmBackend::handleCodePaddingInstructionBegin(
+    const MCInst &Inst, const MCSubtargetInfo &STI) {
+  CodePadder->handleInstructionBegin(Inst, STI);
 }
 
 void MCAsmBackend::handleCodePaddingInstructionEnd(const MCInst &Inst) {
   CodePadder->handleInstructionEnd(Inst);
 }
 
 bool MCAsmBackend::relaxFragment(MCPaddingFragment *PF, MCAsmLayout &Layout) {
   return CodePadder->relaxFragment(PF, Layout);
 }

lib/MC/MCCodePadder.cpp

 }
 
 bool MCCodePadder::addPolicy(MCCodePaddingPolicy *Policy) {
   assert(Policy && "Policy must be valid");
   return CodePaddingPolicies.insert(Policy).second;
 }
 
 void MCCodePadder::handleBasicBlockStart(MCObjectStreamer *OS,
-                                         const MCCodePaddingContext &Context) {
+                                         const MCCodePaddingContext &Context,
+                                         const MCSubtargetInfo &STI) {
   assert(OS != nullptr && "OS must be valid");
   assert(this->OS == nullptr && "Still handling another basic block");
   this->OS = OS;
 
   ArePoliciesActive = usePoliciesForBasicBlock(Context);
 
   bool InsertionPoint = basicBlockRequiresInsertionPoint(Context);
   assert((!InsertionPoint ||
PoliciesMask = std::accumulate(
                    const MCCodePaddingPolicy *Policy) -> uint64_t {
           return Policy->basicBlockRequiresPaddingFragment(Context)
                      ? (Mask | Policy->getKindMask())
                      : Mask;
         });
   }
 
   if (InsertionPoint || PoliciesMask != MCPaddingFragment::PFK_None) {
-    MCPaddingFragment *PaddingFragment = OS->getOrCreatePaddingFragment();
+    MCPaddingFragment *PaddingFragment = OS->getOrCreatePaddingFragment(STI);
     if (InsertionPoint)
       PaddingFragment->setAsInsertionPoint();
     PaddingFragment->setPaddingPoliciesMask(
         PaddingFragment->getPaddingPoliciesMask() | PoliciesMask);
   }
 }
 
 void MCCodePadder::handleBasicBlockEnd(const MCCodePaddingContext &Context) {
   assert(this->OS != nullptr && "Not handling a basic block");
   OS = nullptr;
 }
 
-void MCCodePadder::handleInstructionBegin(const MCInst &Inst) {
+void MCCodePadder::handleInstructionBegin(const MCInst &Inst,
+                                          const MCSubtargetInfo &STI) {
   if (!OS)
     return; // instruction was emitted outside a function
 
   assert(CurrHandledInstFragment == nullptr && "Can't start handling an "
                                                "instruction while still "
                                                "handling another instruction");
 
   bool InsertionPoint = instructionRequiresInsertionPoint(Inst);
void MCCodePadder::handleInstructionBegin(const MCInst &Inst,
   // should point to.
   bool needToUpdateCurrFragment =
       CurrFragment != nullptr &&
       CurrFragment->getKind() == MCFragment::FT_Padding;
   if (InsertionPoint || PoliciesMask != MCPaddingFragment::PFK_None ||
       needToUpdateCurrFragment) {
     // temporarily holding the fragment as CurrHandledInstFragment, to be
     // updated after the instruction will be written
-    CurrHandledInstFragment = OS->getOrCreatePaddingFragment();
+    CurrHandledInstFragment = OS->getOrCreatePaddingFragment(STI);
     if (InsertionPoint)
       CurrHandledInstFragment->setAsInsertionPoint();
     CurrHandledInstFragment->setPaddingPoliciesMask(
         CurrHandledInstFragment->getPaddingPoliciesMask() | PoliciesMask);
   }
 }
 
 void MCCodePadder::handleInstructionEnd(const MCInst &Inst) {

lib/MC/MCObjectStreamer.cpp

MCObjectStreamer::getOrCreateDataFragment(const MCSubtargetInfo *STI) {
   MCDataFragment *F = dyn_cast_or_null<MCDataFragment>(getCurrentFragment());
   if (!F || !CanReuseDataFragment(*F, *Assembler, STI)) {
     F = new MCDataFragment();
     insert(F);
   }
   return F;
 }
 
-MCPaddingFragment *MCObjectStreamer::getOrCreatePaddingFragment() {
+MCPaddingFragment *
+MCObjectStreamer::getOrCreatePaddingFragment(const MCSubtargetInfo &STI) {
   MCPaddingFragment *F =
       dyn_cast_or_null<MCPaddingFragment>(getCurrentFragment());
   if (!F) {
-    F = new MCPaddingFragment();
+    F = new MCPaddingFragment(STI);
     insert(F);
   }
   return F;
 }
 
 void MCObjectStreamer::visitUsedSymbol(const MCSymbol &Sym) {
   Assembler->registerSymbol(Sym);
 }

 }
 
 bool MCObjectStreamer::mayHaveInstructions(MCSection &Sec) const {
   return Sec.hasInstructions();
 }
 
 void MCObjectStreamer::EmitInstruction(const MCInst &Inst,
                                        const MCSubtargetInfo &STI, bool) {
-  getAssembler().getBackend().handleCodePaddingInstructionBegin(Inst);
+  getAssembler().getBackend().handleCodePaddingInstructionBegin(Inst, STI);
   EmitInstructionImpl(Inst, STI);
   getAssembler().getBackend().handleCodePaddingInstructionEnd(Inst);
 }
 
 void MCObjectStreamer::EmitInstructionImpl(const MCInst &Inst,
                                            const MCSubtargetInfo &STI) {
   MCStreamer::EmitInstruction(Inst, STI);
 

 
 void MCObjectStreamer::emitValueToOffset(const MCExpr *Offset,
                                          unsigned char Value,
                                          SMLoc Loc) {
   insert(new MCOrgFragment(*Offset, Value, Loc));
 }
 
 void MCObjectStreamer::EmitCodePaddingBasicBlockStart(
-    const MCCodePaddingContext &Context) {
-  getAssembler().getBackend().handleCodePaddingBasicBlockStart(this, Context);
+    const MCCodePaddingContext &Context, const MCSubtargetInfo &STI) {
+  getAssembler().getBackend().handleCodePaddingBasicBlockStart(this, Context,
+                                                               STI);
 }
 
 void MCObjectStreamer::EmitCodePaddingBasicBlockEnd(
     const MCCodePaddingContext &Context) {
   getAssembler().getBackend().handleCodePaddingBasicBlockEnd(Context);
 }
 
 // Associate DTPRel32 fixup with data and resize data area