[MC] Add MCSubtargetInfo to MCAlignFragment

[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 MCAlignFragment may write nops as padding. The STI is currently unused, a further patch will pass it through to writeNops.

There are many places that can create an MCAlignFragment, in most cases we can find out the STI in operation at the time. In a few places this isn't possible as we are in initialisation or finalisation, or are emitting constant pools. When possible I've tried to find the most appropriate existing fragment to obtain the STI from, when none is available use the per module STI.

For constant pools we don't actually need to use EmitCodeAlign as the constant pools are data anyway so falling through into it via an executable NOP is no better than falling through into data padding.

This is part 2 of 3 of a patch series to pass MCSubtargetInfo to writeNops so that the ARM Backend can remove the per-module STI that is used to decide which nop encodings can be used.

This requires an interface change to InitSections to included a MCSubtargetInfo.

1 [MC] Move bundling and MCSubtargetInfo to MCEncodedFragment [NFC] D44928 (committed)
2 [MC] Add MCSubtargetInfo to MCAlignFragment D45961
3 [MC] Use local MCSubtargetInfo in writeNops D45962

This patch depends on D44928.

[peter.smith]

Rebased [NFC]

[asb]

You will also need to patch at least clang tools/driver/cc1as_main.cpp due to the change to InitSections.

Mechanically the changes seem fine. There's one aspect I'd appreciate further comment on: having to perform getLastSubtargetInfo seems pragmatic but feels ugly. Are there cases where this might be incorrect? Should there be a FIXME indicating that some superior solution for ensuring access to an appropate MCSubtargetInfo should be implemented?

[peter.smith]

In D45961#1200623, @asb wrote:

You will also need to patch at least clang tools/driver/cc1as_main.cpp due to the change to InitSections.

Mechanically the changes seem fine. There's one aspect I'd appreciate further comment on: having to perform getLastSubtargetInfo seems pragmatic but feels ugly. Are there cases where this might be incorrect? Should there be a FIXME indicating that some superior solution for ensuring access to an appropate MCSubtargetInfo should be implemented?

Thanks for the review. I think that in the context that it is used getLastSubtargetInfo() is at, however that doesn't mean that it could potentially be used in a different context in the future.

• For a section with ConstantPools we are guaranteed to have at least one MCFragment with a valid MCSubtarget as there must exist a fragment with an instruction that needs a constant pool entry. In theory given that constant-pools are not instructions it shouldn't actually matter what the encoding of the NOP is because there will most likely be a crash if control flow gets to the constant pool.
• For the Mips RoundSectionSizes option then if the last fragment has instructions we can use its MCSubtarget for the NOP and if not then we can use the per translation unit MCSubtarget. Moreover Mips doesn't even use the Subtarget when determining the NOP encoding anyway.

With this in mind it may be better to change the code so that getLastSubtargetInfo() is no longer required.

• In ConstantPools.cpp::emitEntries() don't use EmitCodeAlignment(), use EmitValueToAlignment() instead. As mentioned above valid code shouldn't ever fall through the padding into the constant pool.
• In Mips we can just use the global STI as there is only one NOP encoding anyway.

I don't think that there are many alternative implementations unless we make the getSubtargetInfo() return a pointer rather than a reference. I'm not sure if that would be a change worth making.

If it sounds ok to you, I can post another patch without getLastSubtargetInfo()?

One possible option might be to fix the surrounding code so that getLastSubtargetInfo() isn't needed.

[asb]

I like the idea of rejigging this so getLastSubtargetInfo isn't needed.

Using EmitValueToAlignment in constant pools seems more correct to me anyway - or at least, I can't think of a disadvantage.

[peter.smith]

I've uploaded a new version that doesn't use getLastSubtargetInfo(). Thanks for the warning about clang tools/driver/cc1as_main.cpp I've not seen anywhere else in the project that uses InitSections(). The code there will become:

Str.get()->InitSections(Opts.NoExecStack, *STI);

As the STI has been computed earlier. I'm happy to post another review if people prefer? Otherwise I could just make the change immediately after where this to be committed.

[peter.smith]

Uploaded rebased diff, no functional changes.

[efriedma]

LGTM

[peter.smith]

Rebase after patch approval from some time ago. No significant changes.

I've noticed that the MCPaddingFragment that I modified in D45960 no longer exists so I've removed that from the description. Will look at rebasing D45962 next.

[MaskRay]

llvm/include/llvm/MC/MCStreamer.h

450 ↗

(On Diff #364835)

If InitSections is going to be changed, perhaps fix the case to initSection

[peter.smith]

Rebased patch (sorry for the delay). I've added fixup code for the interface change to InitSections for clang and one of the unit tests. I've also removed the [NFC] as this will likely break a lot of downstream tools using MC.

An alternative implementation that is less disruptive would make the MCSubtargetInfo an optional parameter that could be nullptr but that would mean that we'd need to test in emitNops whether the MCSubtargetInfo is nullptr which is not ideal but it may lead to a much smaller patch for this and D45962

[peter.smith]

Rebased again. Updated DWARFExpressionCopyBytesTest.cpp to account for changes. I've checked that LLDB and flang build with it as well (I didn't need any changes).

Would like a double check on D45962 as I had to change quite a bit of code since the previous rebased patch. If that is still OK I can commit both at the same time.

[MaskRay]

llvm/include/llvm/MC/MCFragment.h

314 ↗

(On Diff #370610)

"Don’t duplicate function or class name at the beginning of the comment."

from https://llvm.org/docs/CodingStandards.html#doxygen-use-in-documentation-comments

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

278 ↗

(On Diff #370610)

This can be deleted.

284 ↗

(On Diff #370610)

llvm/unittests/DebugInfo/DWARF/DWARFExpressionCopyBytesTest.cpp

138 ↗

(On Diff #370610)

emitNops does not have the STI argument in this patch.

[MaskRay]

The diff was probably created by hand.
arc patch D45961 cannot apply this patch but curl -L 'https://reviews.llvm.org/D45961?download=1' | patch -p0 can.

https://llvm.org/docs/Phabricator.html#requesting-a-review-via-the-command-line
It's a one-time setup. One it is set, the arc diff 'HEAD^' uploaded patch should be testable by builkite.
See "Build Status" currently it cannot apply the patch https://buildkite.com/llvm-project/diff-checks/builds/62270#202c5d24-7b92-474c-aa62-b0e52e14fb56

[peter.smith]

In D45961#2983723, @MaskRay wrote:

The diff was probably created by hand.
arc patch D45961 cannot apply this patch but curl -L 'https://reviews.llvm.org/D45961?download=1' | patch -p0 can.

https://llvm.org/docs/Phabricator.html#requesting-a-review-via-the-command-line
It's a one-time setup. One it is set, the arc diff 'HEAD^' uploaded patch should be testable by builkite.
See "Build Status" currently it cannot apply the patch https://buildkite.com/llvm-project/diff-checks/builds/62270#202c5d24-7b92-474c-aa62-b0e52e14fb56

Thanks for the comments, I've fixed them up locally and will give arc diff a try.

llvm/include/llvm/MC/MCStreamer.h

450 ↗

(On Diff #364835)

Thanks for the suggestion, will do. I'll update on Friday when I'll have an update for D45962

[peter.smith]

arc diff didn't quite do what I wanted, I have two commits in my branch, one D45961, then D45962 and it only updated D45962. This patch is manually created but should be OK.

Have applied the 3 review comments.

[MaskRay]

In D45961#2985377, @peter.smith wrote:

arc diff didn't quite do what I wanted, I have two commits in my branch, one D45961, then D45962 and it only updated D45962. This patch is manually created but should be OK.

Have applied the 3 review comments.

I don't know what the best solution... I personally maintain multiple branches and ensure the tip is the Differential I want to update with arc diff 'HEAD^'.

[jrtc27]

In D45961#2985483, @MaskRay wrote:

In D45961#2985377, @peter.smith wrote:

arc diff didn't quite do what I wanted, I have two commits in my branch, one D45961, then D45962 and it only updated D45962. This patch is manually created but should be OK.

Have applied the 3 review comments.

I don't know what the best solution... I personally maintain multiple branches and ensure the tip is the Differential I want to update with arc diff 'HEAD^'.

In this case you could git rebase -i HEAD^^ and add an x arc diff HEAD^ after the first pick.

[MaskRay]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

278 ↗

(On Diff #370923)

STI can be deleted.

[peter.smith]

Thanks will apply comments prior to commit

include/llvm/MC/ConstantPools.h

 #include <map>
 
 namespace llvm {
 
 class MCContext;
 class MCExpr;
 class MCSection;
 class MCStreamer;
+class MCSubtargetInfo;
 class MCSymbol;
 class MCSymbolRefExpr;
 
 struct ConstantPoolEntry {
   ConstantPoolEntry(MCSymbol *L, const MCExpr *Val, unsigned Sz, SMLoc Loc_)
     : Label(L), Value(Val), Size(Sz), Loc(Loc_) {}
 
   MCSymbol *Label;
public:
   // \param Value is the new entry to put in the constant pool.
   // \param Size is the size in bytes of the entry
   //
   // \returns a MCExpr that references the newly inserted value
   const MCExpr *addEntry(const MCExpr *Value, MCContext &Context,
                          unsigned Size, SMLoc Loc);
 
   // Emit the contents of the constant pool using the provided streamer.
-  void emitEntries(MCStreamer &Streamer);
+  void emitEntries(MCStreamer &Streamer, const MCSubtargetInfo *STI);
 
   // Return true if the constant pool is empty
   bool empty();
 
   void clearCache();
 };
 
 class AssemblerConstantPools {

include/llvm/MC/MCELFStreamer.h

void reset() override {
     SeenIdent = false;
     BundleGroups.clear();
     MCObjectStreamer::reset();
   }
 
   /// \name MCStreamer Interface
   /// @{
 
-  void InitSections(bool NoExecStack) override;
+  void InitSections(bool NoExecStack, const MCSubtargetInfo &STI) override;
   void ChangeSection(MCSection *Section, const MCExpr *Subsection) override;
   void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
   void EmitLabel(MCSymbol *Symbol, SMLoc Loc, MCFragment *F) override;
   void EmitAssemblerFlag(MCAssemblerFlag Flag) override;
   void EmitThumbFunc(MCSymbol *Func) override;
   void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override;
   bool EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
   void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override;

include/llvm/MC/MCFragment.h

class MCAlignFragment : public MCFragment {
 
   /// ValueSize - The size of the integer (in bytes) of \p Value.
   unsigned ValueSize;
 
   /// MaxBytesToEmit - The maximum number of bytes to emit; if the alignment
   /// cannot be satisfied in this width then this fragment is ignored.
   unsigned MaxBytesToEmit;
 
+  /// MCSubtargetInfo - When emitting Nops some subtargets have specific
+  /// nop encodings.
+  const MCSubtargetInfo *STI;
+
 public:
   MCAlignFragment(unsigned Alignment, int64_t Value, unsigned ValueSize,
                   unsigned MaxBytesToEmit, MCSection *Sec = nullptr)
       : MCFragment(FT_Align, false, Sec), Alignment(Alignment),
         EmitNops(false), Value(Value),
         ValueSize(ValueSize), MaxBytesToEmit(MaxBytesToEmit) {}
 
   /// \name Accessors
   /// @{
 
   unsigned getAlignment() const { return Alignment; }
 
   int64_t getValue() const { return Value; }
 
   unsigned getValueSize() const { return ValueSize; }
 
   unsigned getMaxBytesToEmit() const { return MaxBytesToEmit; }
 
   bool hasEmitNops() const { return EmitNops; }
-  void setEmitNops(bool Value) { EmitNops = Value; }
+
+  const MCSubtargetInfo *getSubtargetInfo() const { return STI; }
 
   /// @}
 
+  void setEmitNops(const MCSubtargetInfo *STI) {
+    EmitNops = true;
+    this->STI = STI;
+  }
+
   static bool classof(const MCFragment *F) {
     return F->getKind() == MCFragment::FT_Align;
   }
 };
 
 /// Fragment for adding required padding.
 /// This fragment is always inserted before an instruction, and holds that
 /// instruction as context information (as well as a mask of kinds) for

include/llvm/MC/MCObjectStreamer.h

public:
 
   void EmitBundleAlignMode(unsigned AlignPow2) override;
   void EmitBundleLock(bool AlignToEnd) override;
   void EmitBundleUnlock() override;
   void EmitBytes(StringRef Data) override;
   void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0,
                             unsigned ValueSize = 1,
                             unsigned MaxBytesToEmit = 0) override;
-  void EmitCodeAlignment(unsigned ByteAlignment,
+  void EmitCodeAlignment(unsigned ByteAlignment, const MCSubtargetInfo *STI,
                          unsigned MaxBytesToEmit = 0) override;
   void emitValueToOffset(const MCExpr *Offset, unsigned char Value,
                          SMLoc Loc) override;
   void
   EmitCodePaddingBasicBlockStart(const MCCodePaddingContext &Context,
                                  const MCSubtargetInfo &STI) override;
   void
   EmitCodePaddingBasicBlockEnd(const MCCodePaddingContext &Context) override;

include/llvm/MC/MCSection.h

 #include <cassert>
 #include <utility>
 
 namespace llvm {
 
 class MCAsmInfo;
 class MCContext;
 class MCExpr;
+class MCSubtargetInfo;
 class MCSymbol;
 class raw_ostream;
 class Triple;
 
 template <> struct ilist_alloc_traits<MCFragment> {
   static void deleteNode(MCFragment *V);
 };
 
public:
   reverse_iterator rbegin() { return Fragments.rbegin(); }
   const_reverse_iterator rbegin() const { return Fragments.rbegin(); }
 
   reverse_iterator rend() { return Fragments.rend(); }
   const_reverse_iterator rend() const  { return Fragments.rend(); }
 
   MCSection::iterator getSubsectionInsertionPoint(unsigned Subsection);
 
+  // return the subtarget of the last fragment to have one, or nullptr
+  // if there if no fragment with a subtarget.
+  const MCSubtargetInfo *getLastSubtargetInfo() const;
+
   void dump() const;
 
   virtual void PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
                                     raw_ostream &OS,
                                     const MCExpr *Subsection) const = 0;
 
   /// Return true if a .align directive should use "optimized nops" to fill
   /// instead of 0s.

include/llvm/MC/MCStreamer.h

void SwitchSectionNoChange(MCSection *Section,
     assert(Section && "Cannot switch to a null section!");
     MCSectionSubPair curSection = SectionStack.back().first;
     SectionStack.back().second = curSection;
     if (MCSectionSubPair(Section, Subsection) != curSection)
       SectionStack.back().first = MCSectionSubPair(Section, Subsection);
   }
 
   /// Create the default sections and set the initial one.
-  virtual void InitSections(bool NoExecStack);
+  virtual void InitSections(bool NoExecStack, const MCSubtargetInfo &STI);
 
   MCSymbol *endSection(MCSection *Section);
 
   /// Sets the symbol's section.
   ///
   /// Each emitted symbol will be tracked in the ordering table,
   /// so we can sort on them later.
   void AssignFragment(MCSymbol *Symbol, MCFragment *Fragment);
public:
 
   /// Emit nops until the byte alignment \p ByteAlignment is reached.
   ///
   /// This used to align code where the alignment bytes may be executed.  This
   /// can emit different bytes for different sizes to optimize execution.
   ///
   /// \param ByteAlignment - The alignment to reach. This must be a power of
   /// two on some targets.
+  /// \param STI - The MCSubtargetInfo in operation when padding is emitted.
   /// \param MaxBytesToEmit - The maximum numbers of bytes to emit, or 0. If
   /// the alignment cannot be reached in this many bytes, no bytes are
   /// emitted.
   virtual void EmitCodeAlignment(unsigned ByteAlignment,
+                                 const MCSubtargetInfo *STI,
                                  unsigned MaxBytesToEmit = 0);
 
   /// Emit some number of copies of \p Value until the byte offset \p
   /// Offset is reached.
   ///
   /// This is used to implement assembler directives such as .org.
   ///
   /// \param Offset - The offset to reach. This may be an expression, but the

include/llvm/MC/MCWinCOFFStreamer.h

public:
   void reset() override {
     CurSymbol = nullptr;
     MCObjectStreamer::reset();
   }
 
   /// \name MCStreamer interface
   /// \{
 
-  void InitSections(bool NoExecStack) override;
+  void InitSections(bool NoExecStack, const MCSubtargetInfo &STI) override;
   void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
   void EmitAssemblerFlag(MCAssemblerFlag Flag) override;
   void EmitThumbFunc(MCSymbol *Func) override;
   bool EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
   void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override;
   void BeginCOFFSymbolDef(MCSymbol const *Symbol) override;
   void EmitCOFFSymbolStorageClass(int StorageClass) override;
   void EmitCOFFSymbolType(int Type) override;

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 
 bool AsmPrinter::doInitialization(Module &M) {
   MMI = getAnalysisIfAvailable<MachineModuleInfo>();
 
   // Initialize TargetLoweringObjectFile.
   const_cast<TargetLoweringObjectFile&>(getObjFileLowering())
     .Initialize(OutContext, TM);
 
-  OutStreamer->InitSections(false);
+  // We're at the module level. Construct MCSubtarget from the default CPU
+  // and target triple.
+  std::unique_ptr<MCSubtargetInfo> STI(TM.getTarget().createMCSubtargetInfo(
+      TM.getTargetTriple().str(), TM.getTargetCPU(),
+      TM.getTargetFeatureString()));
+
+  OutStreamer->InitSections(false, OutContext.getSubtargetCopy(*STI));
 
   // Emit the version-min deployment target directive if needed.
   //
   // FIXME: If we end up with a collection of these sorts of Darwin-specific
   // or ELF-specific things, it may make sense to have a platform helper class
   // that will work with the target helper class. For now keep it here, as the
   // alternative is duplicated code in each of the target asm printers that
   // use the directive, where it would need the same conditionalization
bool AsmPrinter::doInitialization(Module &M) {
   GCModuleInfo *MI = getAnalysisIfAvailable<GCModuleInfo>();
   assert(MI && "AsmPrinter didn't require GCModuleInfo?");
   for (auto &I : *MI)
     if (GCMetadataPrinter *MP = GetOrCreateGCPrinter(*I))
       MP->beginAssembly(M, *MI, *this);
 
   // Emit module-level inline asm if it exists.
   if (!M.getModuleInlineAsm().empty()) {
-    // We're at the module level. Construct MCSubtarget from the default CPU
-    // and target triple.
-    std::unique_ptr<MCSubtargetInfo> STI(TM.getTarget().createMCSubtargetInfo(
-        TM.getTargetTriple().str(), TM.getTargetCPU(),
-        TM.getTargetFeatureString()));
     OutStreamer->AddComment("Start of file scope inline assembly");
     OutStreamer->AddBlankLine();
     EmitInlineAsm(M.getModuleInlineAsm()+"\n",
                   OutContext.getSubtargetCopy(*STI), TM.Options.MCOptions);
     OutStreamer->AddComment("End of file scope inline assembly");
     OutStreamer->AddBlankLine();
   }
 
void AsmPrinter::EmitAlignment(unsigned NumBits, const GlobalObject *GV) const {
   if (GV)
     NumBits = getGVAlignmentLog2(GV, GV->getParent()->getDataLayout(), NumBits);
 
   if (NumBits == 0) return;   // 1-byte aligned: no need to emit alignment.
 
   assert(NumBits <
              static_cast<unsigned>(std::numeric_limits<unsigned>::digits) &&
          "undefined behavior");
-  if (getCurrentSection()->getKind().isText())
-    OutStreamer->EmitCodeAlignment(1u << NumBits);
+
+  if (getCurrentSection()->getKind().isText()) {
+    const MCSubtargetInfo *STI = nullptr;
+    if (this->MF)
+      STI = &getSubtargetInfo();
+    else
+      STI = TM.getMCSubtargetInfo();
+    OutStreamer->EmitCodeAlignment(1u << NumBits, STI);
+  }
   else
     OutStreamer->EmitValueToAlignment(1u << NumBits);
 }
 
 //===----------------------------------------------------------------------===//
 // Constant emission.
 //===----------------------------------------------------------------------===//
 
void AsmPrinter::emitXRayTable() {
   MCSymbol *SledsEnd = OutContext.createTempSymbol("xray_sleds_end", true);
   OutStreamer->EmitLabel(SledsEnd);
 
   // We then emit a single entry in the index per function. We use the symbols
   // that bound the instrumentation map as the range for a specific function.
   // Each entry here will be 2 * word size aligned, as we're writing down two
   // pointers. This should work for both 32-bit and 64-bit platforms.
   OutStreamer->SwitchSection(FnSledIndex);
-  OutStreamer->EmitCodeAlignment(2 * WordSizeBytes);
+  OutStreamer->EmitCodeAlignment(2 * WordSizeBytes, &getSubtargetInfo());
   OutStreamer->EmitSymbolValue(SledsStart, WordSizeBytes, false);
   OutStreamer->EmitSymbolValue(SledsEnd, WordSizeBytes, false);
   OutStreamer->SwitchSection(PrevSection);
   Sleds.clear();
 }
 
 void AsmPrinter::recordSled(MCSymbol *Sled, const MachineInstr &MI,
                             SledKind Kind, uint8_t Version) {

lib/MC/ConstantPools.cpp

 #include "llvm/Support/Casting.h"
 
 using namespace llvm;
 
 //
 // ConstantPool implementation
 //
 // Emit the contents of the constant pool using the provided streamer.
-void ConstantPool::emitEntries(MCStreamer &Streamer) {
+void ConstantPool::emitEntries(MCStreamer &Streamer,
+                               const MCSubtargetInfo *STI) {
   if (Entries.empty())
     return;
   Streamer.EmitDataRegion(MCDR_DataRegion);
   for (const ConstantPoolEntry &Entry : Entries) {
-    Streamer.EmitCodeAlignment(Entry.Size); // align naturally
+    Streamer.EmitCodeAlignment(Entry.Size, STI); // align naturally
     Streamer.EmitLabel(Entry.Label);
     Streamer.EmitValue(Entry.Value, Entry.Size, Entry.Loc);
   }
   Streamer.EmitDataRegion(MCDR_DataRegionEnd);
   Entries.clear();
 }
 
 const MCExpr *ConstantPool::addEntry(const MCExpr *Value, MCContext &Context,

 AssemblerConstantPools::getOrCreateConstantPool(MCSection *Section) {
   return ConstantPools[Section];
 }
 
 static void emitConstantPool(MCStreamer &Streamer, MCSection *Section,
                              ConstantPool &CP) {
   if (!CP.empty()) {
     Streamer.SwitchSection(Section);
-    CP.emitEntries(Streamer);
+    CP.emitEntries(Streamer, Section->getLastSubtargetInfo());
   }
 }
 
 void AssemblerConstantPools::emitAll(MCStreamer &Streamer) {
   // Dump contents of assembler constant pools.
   for (auto &CPI : ConstantPools) {
     MCSection *Section = CPI.first;
     ConstantPool &CP = CPI.second;

lib/MC/MCAsmStreamer.cpp

public:
 
   void emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr,
                 SMLoc Loc = SMLoc()) override;
 
   void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0,
                             unsigned ValueSize = 1,
                             unsigned MaxBytesToEmit = 0) override;
 
-  void EmitCodeAlignment(unsigned ByteAlignment,
+  void EmitCodeAlignment(unsigned ByteAlignment, const MCSubtargetInfo *STI,
                          unsigned MaxBytesToEmit = 0) override;
 
   void emitValueToOffset(const MCExpr *Offset,
                          unsigned char Value,
                          SMLoc Loc) override;
 
   void EmitFileDirective(StringRef Filename) override;
   Expected<unsigned> tryEmitDwarfFileDirective(unsigned FileNo,
void MCAsmStreamer::EmitValueToAlignment(unsigned ByteAlignment, int64_t Value,
   OS << ' ' << ByteAlignment;
   OS << ", " << truncateToSize(Value, ValueSize);
   if (MaxBytesToEmit)
     OS << ", " << MaxBytesToEmit;
   EmitEOL();
 }
 
 void MCAsmStreamer::EmitCodeAlignment(unsigned ByteAlignment,
+                                      const MCSubtargetInfo *STI,
                                       unsigned MaxBytesToEmit) {
   // Emit with a text fill value.
   EmitValueToAlignment(ByteAlignment, MAI->getTextAlignFillValue(),
                        1, MaxBytesToEmit);
 }
 
 void MCAsmStreamer::emitValueToOffset(const MCExpr *Offset,
                                       unsigned char Value,

lib/MC/MCELFStreamer.cpp

EF->getFixups()[i].setOffset(EF->getFixups()[i].getOffset() +
                                  DF->getContents().size());
     DF->getFixups().push_back(EF->getFixups()[i]);
   }
   if (DF->getSubtargetInfo() == nullptr && EF->getSubtargetInfo())
     DF->setHasInstructions(*EF->getSubtargetInfo());
   DF->getContents().append(EF->getContents().begin(), EF->getContents().end());
 }
 
-void MCELFStreamer::InitSections(bool NoExecStack) {
+void MCELFStreamer::InitSections(bool NoExecStack, const MCSubtargetInfo &STI) {
   MCContext &Ctx = getContext();
   SwitchSection(Ctx.getObjectFileInfo()->getTextSection());
-  EmitCodeAlignment(4);
+  EmitCodeAlignment(4, &STI);
 
   if (NoExecStack)
     SwitchSection(Ctx.getAsmInfo()->getNonexecutableStackSection(Ctx));
 }
 
 void MCELFStreamer::EmitLabel(MCSymbol *S, SMLoc Loc) {
   auto *Symbol = cast<MCSymbolELF>(S);
   MCObjectStreamer::EmitLabel(Symbol, Loc);

lib/MC/MCObjectStreamer.cpp

void MCObjectStreamer::EmitValueToAlignment(unsigned ByteAlignment,
 
   // Update the maximum alignment on the current section if necessary.
   MCSection *CurSec = getCurrentSectionOnly();
   if (ByteAlignment > CurSec->getAlignment())
     CurSec->setAlignment(ByteAlignment);
 }
 
 void MCObjectStreamer::EmitCodeAlignment(unsigned ByteAlignment,
+                                         const MCSubtargetInfo *STI,
                                          unsigned MaxBytesToEmit) {
   EmitValueToAlignment(ByteAlignment, 0, 1, MaxBytesToEmit);
-  cast<MCAlignFragment>(getCurrentFragment())->setEmitNops(true);
+  cast<MCAlignFragment>(getCurrentFragment())->setEmitNops(STI);
 }
 
 void MCObjectStreamer::emitValueToOffset(const MCExpr *Offset,
                                          unsigned char Value,
                                          SMLoc Loc) {
   insert(new MCOrgFragment(*Offset, Value, Loc));
 }
 

lib/MC/MCParser/AsmParser.cpp

if (getContext().getGenDwarfFileNumber() == 0)
     getContext().setGenDwarfFileNumber(getStreamer().EmitDwarfFileDirective(
         0, StringRef(), getContext().getMainFileName()));
   return true;
 }
 
 bool AsmParser::Run(bool NoInitialTextSection, bool NoFinalize) {
   // Create the initial section, if requested.
   if (!NoInitialTextSection)
-    Out.InitSections(false);
+    Out.InitSections(false, getTargetParser().getSTI());
 
   // Prime the lexer.
   Lex();
 
   HadError = false;
   AsmCond StartingCondState = TheCondState;
   SmallVector<AsmRewrite, 4> AsmStrRewrites;
 
bool AsmParser::Run(bool NoInitialTextSection, bool NoFinalize) {
   if (!HadError && !NoFinalize)
     Out.Finish();
 
   return HadError || getContext().hadError();
 }
 
 bool AsmParser::checkForValidSection() {
   if (!ParsingInlineAsm && !getStreamer().getCurrentSectionOnly()) {
-    Out.InitSections(false);
+    Out.InitSections(false, getTargetParser().getSTI());
     return Error(getTok().getLoc(),
                  "expected section directive before assembly directive");
   }
   return false;
 }
 
 /// Throw away the rest of the line for testing purposes.
 void AsmParser::eatToEndOfStatement() {
bool AsmParser::parseDirectiveAlign(bool IsPow2, unsigned ValueSize) {
 
   // Check whether we should use optimal code alignment for this .align
   // directive.
   const MCSection *Section = getStreamer().getCurrentSectionOnly();
   assert(Section && "must have section to emit alignment");
   bool UseCodeAlign = Section->UseCodeAlign();
   if ((!HasFillExpr || Lexer.getMAI().getTextAlignFillValue() == FillExpr) &&
       ValueSize == 1 && UseCodeAlign) {
-    getStreamer().EmitCodeAlignment(Alignment, MaxBytesToFill);
+    getStreamer().EmitCodeAlignment(Alignment, &getTargetParser().getSTI(),
+                                    MaxBytesToFill);
   } else {
     // FIXME: Target specific behavior about how the "extra" bytes are filled.
     getStreamer().EmitValueToAlignment(Alignment, FillExpr, ValueSize,
                                        MaxBytesToFill);
   }
 
   return ReturnVal;
 }

lib/MC/MCSection.cpp

if (!ExactMatch && Subsection != 0) {
     SubsectionFragmentMap.insert(MI, std::make_pair(Subsection, F));
     getFragmentList().insert(IP, F);
     F->setParent(this);
   }
 
   return IP;
 }
 
+const MCSubtargetInfo *MCSection::getLastSubtargetInfo() const {
+  for (auto Iter = rbegin(); Iter != rend(); ++Iter) {
+    const MCFragment &Frag = *Iter;
+    if (auto *FragWithSubtarget = dyn_cast<MCDataFragment>(&Frag)) {
+      if (FragWithSubtarget->hasInstructions())
+        return FragWithSubtarget->getSubtargetInfo();
+    } else if (auto *FragWithSubtarget = dyn_cast<MCRelaxableFragment>(&Frag))
+      return FragWithSubtarget->getSubtargetInfo();
+    else if (auto *FragWithSubtarget = dyn_cast<MCAlignFragment>(&Frag))
+      return FragWithSubtarget->getSubtargetInfo();
+    // FIXME, will need MCPaddingFragment here as well.
+  }
+  return nullptr;
+}
+
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void MCSection::dump() const {
   raw_ostream &OS = errs();
 
   OS << "<MCSection";
   OS << " Fragments:[\n      ";
   for (auto it = begin(), ie = end(); it != ie; ++it) {
     if (it != begin())
       OS << ",\n      ";
     it->dump();
   }
   OS << "]>";
 }
 #endif

lib/MC/MCStreamer.cpp

 void MCStreamer::EmitCVDefRangeDirective(
     ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
     StringRef FixedSizePortion) {}
 
 void MCStreamer::EmitEHSymAttributes(const MCSymbol *Symbol,
                                      MCSymbol *EHSymbol) {
 }
 
-void MCStreamer::InitSections(bool NoExecStack) {
+void MCStreamer::InitSections(bool NoExecStack, const MCSubtargetInfo &STI) {
   SwitchSection(getContext().getObjectFileInfo()->getTextSection());
 }
 
 void MCStreamer::AssignFragment(MCSymbol *Symbol, MCFragment *Fragment) {
   assert(Fragment);
   Symbol->setFragment(Fragment);
 
   // As we emit symbols into a section, track the order so that they can

 void MCStreamer::EmitSLEB128Value(const MCExpr *Value) {}
 void MCStreamer::emitFill(const MCExpr &NumBytes, uint64_t Value, SMLoc Loc) {}
 void MCStreamer::emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr,
                           SMLoc Loc) {}
 void MCStreamer::EmitValueToAlignment(unsigned ByteAlignment, int64_t Value,
                                       unsigned ValueSize,
                                       unsigned MaxBytesToEmit) {}
 void MCStreamer::EmitCodeAlignment(unsigned ByteAlignment,
+                                   const MCSubtargetInfo *STI,
                                    unsigned MaxBytesToEmit) {}
 void MCStreamer::emitValueToOffset(const MCExpr *Offset, unsigned char Value,
                                    SMLoc Loc) {}
 void MCStreamer::EmitBundleAlignMode(unsigned AlignPow2) {}
 void MCStreamer::EmitBundleLock(bool AlignToEnd) {}
 void MCStreamer::FinishImpl() {}
 void MCStreamer::EmitBundleUnlock() {}
 

lib/MC/MCWinCOFFStreamer.cpp

void MCWinCOFFStreamer::EmitInstToData(const MCInst &Inst,
   for (unsigned i = 0, e = Fixups.size(); i != e; ++i) {
     Fixups[i].setOffset(Fixups[i].getOffset() + DF->getContents().size());
     DF->getFixups().push_back(Fixups[i]);
   }
   DF->setHasInstructions(STI);
   DF->getContents().append(Code.begin(), Code.end());
 }
 
-void MCWinCOFFStreamer::InitSections(bool NoExecStack) {
+void MCWinCOFFStreamer::InitSections(bool NoExecStack, const MCSubtargetInfo &STI) {
   // FIXME: this is identical to the ELF one.
   // This emulates the same behavior of GNU as. This makes it easier
   // to compare the output as the major sections are in the same order.
   SwitchSection(getContext().getObjectFileInfo()->getTextSection());
-  EmitCodeAlignment(4);
+  EmitCodeAlignment(4, &STI);
 
   SwitchSection(getContext().getObjectFileInfo()->getDataSection());
-  EmitCodeAlignment(4);
+  EmitCodeAlignment(4, &STI);
 
   SwitchSection(getContext().getObjectFileInfo()->getBSSSection());
-  EmitCodeAlignment(4);
+  EmitCodeAlignment(4, &STI);
 
   SwitchSection(getContext().getObjectFileInfo()->getTextSection());
 }
 
 void MCWinCOFFStreamer::EmitLabel(MCSymbol *S, SMLoc Loc) {
   auto *Symbol = cast<MCSymbolCOFF>(S);
   MCObjectStreamer::EmitLabel(Symbol, Loc);
 }

lib/Target/AArch64/AArch64AsmPrinter.cpp

void AArch64AsmPrinter::EmitSled(const MachineInstr &MI, SledKind Kind)
   //   LDR W0, #12 ; W0 := function ID
   //   LDR X16,#12 ; X16 := addr of __xray_FunctionEntry or __xray_FunctionExit
   //   BLR X16 ; call the tracing trampoline
   //   ;DATA: 32 bits of function ID
   //   ;DATA: lower 32 bits of the address of the trampoline
   //   ;DATA: higher 32 bits of the address of the trampoline
   //   LDP X0, X30, [SP], #16 ; pop X0 and the link register from the stack
   //
-  OutStreamer->EmitCodeAlignment(4);
+  OutStreamer->EmitCodeAlignment(4, &getSubtargetInfo());
   auto CurSled = OutContext.createTempSymbol("xray_sled_", true);
   OutStreamer->EmitLabel(CurSled);
   auto Target = OutContext.createTempSymbol();
 
   // Emit "B #32" instruction, which jumps over the next 28 bytes.
   // The operand has to be the number of 4-byte instructions to jump over,
   // including the current instruction.
   EmitToStreamer(*OutStreamer, MCInstBuilder(AArch64::B).addImm(8));

lib/Target/ARM/ARMAsmPrinter.cpp

if (Base == ARM::PC) {
 
       // When using PC as the base, it's important that there is no padding
       // between the last ADDS and the start of the jump table. The jump table
       // is 4-byte aligned, so we ensure we're 4 byte aligned here too.
       //
       // FIXME: Ideally we could vary the LDRB index based on the padding
       // between the sequence and jump table, however that relies on MCExprs
       // for load indexes which are currently not supported.
-      OutStreamer->EmitCodeAlignment(4);
+      OutStreamer->EmitCodeAlignment(4, &getSubtargetInfo());
       EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::tADDhirr)
                                        .addReg(Idx)
                                        .addReg(Idx)
                                        .addReg(Base)
                                        // Add predicate operands.
                                        .addImm(ARMCC::AL)
                                        .addReg(0));
 

lib/Target/ARM/ARMMCInstLower.cpp

void ARMAsmPrinter::EmitSled(const MachineInstr &MI, SledKind Kind)
   //   PUSH{ r0, lr }
   //   MOVW r0, #<lower 16 bits of function ID>
   //   MOVT r0, #<higher 16 bits of function ID>
   //   MOVW ip, #<lower 16 bits of address of __xray_FunctionEntry/Exit>
   //   MOVT ip, #<higher 16 bits of address of __xray_FunctionEntry/Exit>
   //   BLX ip
   //   POP{ r0, lr }
   //
-  OutStreamer->EmitCodeAlignment(4);
+  OutStreamer->EmitCodeAlignment(4, &getSubtargetInfo());
   auto CurSled = OutContext.createTempSymbol("xray_sled_", true);
   OutStreamer->EmitLabel(CurSled);
   auto Target = OutContext.createTempSymbol();
 
   // Emit "B #20" instruction, which jumps over the next 24 bytes (because
   // register pc is 8 bytes ahead of the jump instruction by the moment CPU
   // is executing it).
   // By analogy to ARMAsmPrinter::emitPseudoExpansionLowering() |case ARM::B|.

lib/Target/ARM/AsmParser/ARMAsmParser.cpp

 
 bool ARMAsmParser::parseDirectiveEven(SMLoc L) {
   const MCSection *Section = getStreamer().getCurrentSectionOnly();
 
   if (parseToken(AsmToken::EndOfStatement, "unexpected token in directive"))
     return true;
 
   if (!Section) {
-    getStreamer().InitSections(false);
+    getStreamer().InitSections(false, getSTI());
     Section = getStreamer().getCurrentSectionOnly();
   }
 
   assert(Section && "must have section to emit alignment");
   if (Section->UseCodeAlign())
-    getStreamer().EmitCodeAlignment(2);
+    getStreamer().EmitCodeAlignment(2, &getSTI());
   else
     getStreamer().EmitValueToAlignment(2);
 
   return false;
 }
 
 /// parseDirectivePersonalityIndex
 ///   ::= .personalityindex index

 bool ARMAsmParser::parseDirectiveAlign(SMLoc L) {
   // NOTE: if this is not the end of the statement, fall back to the target
   // agnostic handling for this directive which will correctly handle this.
   if (parseOptionalToken(AsmToken::EndOfStatement)) {
     // '.align' is target specifically handled to mean 2**2 byte alignment.
     const MCSection *Section = getStreamer().getCurrentSectionOnly();
     assert(Section && "must have section to emit alignment");
     if (Section->UseCodeAlign())
-      getStreamer().EmitCodeAlignment(4, 0);
+      getStreamer().EmitCodeAlignment(4, &getSTI(), 0);
     else
       getStreamer().EmitValueToAlignment(4, 0, 1, 0);
     return false;
   }
   return true;
 }
 
 /// parseDirectiveThumbSet

lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp

inline void ARMELFStreamer::SwitchToEHSection(StringRef Prefix,
   MCSectionELF *EHSection = getContext().getELFSection(
       EHSecName, Type, Flags, 0, Group, FnSection.getUniqueID(),
       static_cast<const MCSymbolELF *>(&Fn));
 
   assert(EHSection && "Failed to get the required EH section");
 
   // Switch to .ARM.extab or .ARM.exidx section
   SwitchSection(EHSection);
-  EmitCodeAlignment(4);
+  EmitValueToAlignment(4, 0, 1, 0);
 }
 
 inline void ARMELFStreamer::SwitchToExTabSection(const MCSymbol &FnStart) {
   SwitchToEHSection(".ARM.extab", ELF::SHT_PROGBITS, ELF::SHF_ALLOC,
                     SectionKind::getData(), FnStart);
 }
 
 inline void ARMELFStreamer::SwitchToExIdxSection(const MCSymbol &FnStart) {

lib/Target/Hexagon/AsmParser/HexagonAsmParser.cpp

if (!Parser.getStreamer().hasRawTextSupport()) {
         myCharStr = ".lita";
         mySection = getContext().getELFSection(myCharStr, ELF::SHT_PROGBITS,
                                                ELF::SHF_ALLOC | ELF::SHF_WRITE);
       } else
         llvm_unreachable("unexpected type of machine operand!");
 
       MES->SwitchSection(mySection);
       unsigned byteSize = is32bit ? 4 : 8;
-      getStreamer().EmitCodeAlignment(byteSize, byteSize);
+      getStreamer().EmitCodeAlignment(byteSize, &getSTI(), byteSize);
 
       MCSymbol *Sym;
 
       // for symbols, get rid of prepended ".gnu.linkonce.lx."
 
       // emit symbol if needed
       if (Absolute) {
         Sym = getContext().getOrCreateSymbol(StringRef(myCharStr.c_str() + 16));

lib/Target/Hexagon/HexagonAsmPrinter.cpp

if (Offset.isImm()) {
     llvm_unreachable("Unimplemented");
   }
 
   return false;
 }
 
 static MCSymbol *smallData(AsmPrinter &AP, const MachineInstr &MI,
                            MCStreamer &OutStreamer, const MCOperand &Imm,
-                           int AlignSize) {
+                           int AlignSize, const MCSubtargetInfo& STI) {
   MCSymbol *Sym;
   int64_t Value;
   if (Imm.getExpr()->evaluateAsAbsolute(Value)) {
     StringRef sectionPrefix;
     std::string ImmString;
     StringRef Name;
     if (AlignSize == 8) {
        Name = ".CONST_0000000000000000";
MCSectionELF *Section = OutStreamer.getContext().getELFSection(
         sectionName, ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC);
     OutStreamer.SwitchSection(Section);
 
     Sym = AP.OutContext.getOrCreateSymbol(Twine(symbolName));
     if (Sym->isUndefined()) {
       OutStreamer.EmitLabel(Sym);
       OutStreamer.EmitSymbolAttribute(Sym, MCSA_Global);
       OutStreamer.EmitIntValue(Value, AlignSize);
-      OutStreamer.EmitCodeAlignment(AlignSize);
+      OutStreamer.EmitCodeAlignment(AlignSize, &STI);
     }
   } else {
     assert(Imm.isExpr() && "Expected expression and found none");
     const MachineOperand &MO = MI.getOperand(1);
     assert(MO.isGlobal() || MO.isCPI() || MO.isJTI());
     MCSymbol *MOSymbol = nullptr;
     if (MO.isGlobal())
       MOSymbol = AP.getSymbol(MO.getGlobal());
MCSectionELF *Section = OutStreamer.getContext().getELFSection(
         ".lita", ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC);
 
     OutStreamer.SwitchSection(Section);
     Sym = AP.OutContext.getOrCreateSymbol(Twine(LitaName));
     if (Sym->isUndefined()) {
       OutStreamer.EmitLabel(Sym);
       OutStreamer.EmitSymbolAttribute(Sym, MCSA_Local);
       OutStreamer.EmitValue(Imm.getExpr(), AlignSize);
-      OutStreamer.EmitCodeAlignment(AlignSize);
+      OutStreamer.EmitCodeAlignment(AlignSize, &STI);
     }
   }
   return Sym;
 }
 
 static MCInst ScaleVectorOffset(MCInst &Inst, unsigned OpNo,
                                 unsigned VectorSize, MCContext &Ctx) {
   MCInst T;
case Hexagon::A2_zxtb: {
     break;
   }
 
   // "$dst = CONST64(#$src1)",
   case Hexagon::CONST64:
     if (!OutStreamer->hasRawTextSupport()) {
       const MCOperand &Imm = MappedInst.getOperand(1);
       MCSectionSubPair Current = OutStreamer->getCurrentSection();
-
-      MCSymbol *Sym = smallData(*this, MI, *OutStreamer, Imm, 8);
+      MCSymbol *Sym = smallData(*this, MI, *OutStreamer, Imm, 8, getSubtargetInfo());
 
       OutStreamer->SwitchSection(Current.first, Current.second);
       MCInst TmpInst;
       MCOperand &Reg = MappedInst.getOperand(0);
       TmpInst.setOpcode(Hexagon::L2_loadrdgp);
       TmpInst.addOperand(Reg);
       TmpInst.addOperand(MCOperand::createExpr(
                          MCSymbolRefExpr::create(Sym, OutContext)));
       MappedInst = TmpInst;
 
     }
     break;
   case Hexagon::CONST32:
     if (!OutStreamer->hasRawTextSupport()) {
       MCOperand &Imm = MappedInst.getOperand(1);
       MCSectionSubPair Current = OutStreamer->getCurrentSection();
-      MCSymbol *Sym = smallData(*this, MI, *OutStreamer, Imm, 4);
+      MCSymbol *Sym = smallData(*this, MI, *OutStreamer, Imm, 4, getSubtargetInfo());
       OutStreamer->SwitchSection(Current.first, Current.second);
       MCInst TmpInst;
       MCOperand &Reg = MappedInst.getOperand(0);
       TmpInst.setOpcode(Hexagon::L2_loadrigp);
       TmpInst.addOperand(Reg);
       TmpInst.addOperand(MCOperand::createExpr(HexagonMCExpr::create(
           MCSymbolRefExpr::create(Sym, OutContext), OutContext)));
       MappedInst = TmpInst;

lib/Target/Mips/MCTargetDesc/MipsTargetStreamer.cpp

if (RoundSectionSizes) {
     // size.
     MCStreamer &OS = getStreamer();
     for (MCSection &S : MCA) {
       MCSectionELF &Section = static_cast<MCSectionELF &>(S);
 
       unsigned Alignment = Section.getAlignment();
       if (Alignment) {
         OS.SwitchSection(&Section);
-        if (Section.UseCodeAlign())
-          OS.EmitCodeAlignment(Alignment, Alignment);
+        if (Section.UseCodeAlign()) {
+          // Find the most appropriate SubtargetInfo for the padding.
+          const MCSubtargetInfo *LastSTI = Section.getLastSubtargetInfo();
+          if (LastSTI == nullptr)
+            // There is a global one registered in MipsTargetELFStreamer.
+            LastSTI = &STI;
+          OS.EmitCodeAlignment(Alignment, LastSTI, Alignment);
+        }
         else
           OS.EmitValueToAlignment(Alignment, 0, 1, Alignment);
       }
     }
   }
 
   const FeatureBitset &Features = STI.getFeatureBits();
 

lib/Target/Mips/MipsAsmPrinter.cpp

void MipsAsmPrinter::EmitSled(const MachineInstr &MI, SledKind Kind) {
   //   ORI      T9, T9, %lo(__xray_FunctionEntry/Exit)
   //   LUI      T0, %hi(function_id)
   //   JALR     T9
   //   ADDIU    T0, T0, %lo(function_id)
   //   LD       T9, 0(SP)
   //   LD       RA, 8(SP)
   //   DADDIU   SP, SP, 16
   //
-  OutStreamer->EmitCodeAlignment(4);
+  OutStreamer->EmitCodeAlignment(4, &getSubtargetInfo());
   auto CurSled = OutContext.createTempSymbol("xray_sled_", true);
   OutStreamer->EmitLabel(CurSled);
   auto Target = OutContext.createTempSymbol();
 
   // Emit "B .tmpN" instruction, which jumps over the nop sled to the actual
   // start of function
   const MCExpr *TargetExpr = MCSymbolRefExpr::create(
       Target, MCSymbolRefExpr::VariantKind::VK_None, OutContext);

lib/Target/PowerPC/PPCAsmPrinter.cpp

case TargetOpcode::PATCHABLE_RET: {
     //   std 0, -8(1)
     //   mflr 0
     //   bl __xray_FunctionExit
     //   mtlr 0
     //   b(lr)?
     //
     // Update compiler-rt/lib/xray/xray_powerpc64.cc accordingly when number
     // of instructions change.
-    OutStreamer->EmitCodeAlignment(8);
+    OutStreamer->EmitCodeAlignment(8, &getSubtargetInfo());
     MCSymbol *BeginOfSled = OutContext.createTempSymbol();
     OutStreamer->EmitLabel(BeginOfSled);
     EmitToStreamer(*OutStreamer, RetInst);
     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::NOP));
     EmitToStreamer(
         *OutStreamer,
         MCInstBuilder(PPC::STD).addReg(PPC::X0).addImm(-8).addReg(PPC::X1));
     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MFLR8).addReg(PPC::X0));

lib/Target/X86/AsmParser/X86AsmParser.cpp

 /// parseDirectiveEven
 ///  ::= .even
 bool X86AsmParser::parseDirectiveEven(SMLoc L) {
   if (parseToken(AsmToken::EndOfStatement, "unexpected token in directive"))
     return false;
 
   const MCSection *Section = getStreamer().getCurrentSectionOnly();
   if (!Section) {
-    getStreamer().InitSections(false);
+    getStreamer().InitSections(false, getSTI());
     Section = getStreamer().getCurrentSectionOnly();
   }
   if (Section->UseCodeAlign())
-    getStreamer().EmitCodeAlignment(2, 0);
+    getStreamer().EmitCodeAlignment(2, &getSTI(), 0);
   else
     getStreamer().EmitValueToAlignment(2, 0, 1, 0);
   return false;
 }
 /// ParseDirectiveWord
 ///  ::= .word [ expression (, expression)* ]
 bool X86AsmParser::ParseDirectiveWord(unsigned Size, SMLoc L) {
   auto parseOp = [&]() -> bool {

lib/Target/X86/X86MCInstLower.cpp

void X86AsmPrinter::LowerPATCHABLE_EVENT_CALL(const MachineInstr &MI,
   //   ...
   //   callq __xrayCustomEvent  // already lowered
   //   ...
   //
   // ---
   // First we emit the label and the jump.
   auto CurSled = OutContext.createTempSymbol("xray_event_sled_", true);
   OutStreamer->AddComment("# XRay Custom Event Log");
-  OutStreamer->EmitCodeAlignment(2);
+  OutStreamer->EmitCodeAlignment(2, &getSubtargetInfo());
   OutStreamer->EmitLabel(CurSled);
 
   // Use a two-byte `jmp`. This version of JMP takes an 8-bit relative offset as
   // an operand (computed as an offset from the jmp instruction).
   // FIXME: Find another less hacky way do force the relative jump.
   OutStreamer->EmitBinaryData("\xeb\x0f");
 
   // The default C calling convention will place two arguments into %rcx and
void X86AsmPrinter::LowerPATCHABLE_TYPED_EVENT_CALL(const MachineInstr &MI,
   //   ...
   //   callq __xrayTypedEvent  // already lowered
   //   ...
   //
   // ---
   // First we emit the label and the jump.
   auto CurSled = OutContext.createTempSymbol("xray_typed_event_sled_", true);
   OutStreamer->AddComment("# XRay Typed Event Log");
-  OutStreamer->EmitCodeAlignment(2);
+  OutStreamer->EmitCodeAlignment(2, &getSubtargetInfo());
   OutStreamer->EmitLabel(CurSled);
 
   // Use a two-byte `jmp`. This version of JMP takes an 8-bit relative offset as
   // an operand (computed as an offset from the jmp instruction).
   // FIXME: Find another less hacky way do force the relative jump.
   OutStreamer->EmitBinaryData("\xeb\x14");
 
   // An x86-64 convention may place three arguments into %rcx, %rdx, and R8,
void X86AsmPrinter::LowerPATCHABLE_FUNCTION_ENTER(const MachineInstr &MI,
   //
   // We need the 9 bytes because at runtime, we'd be patching over the full 11
   // bytes with the following pattern:
   //
   //   mov %r10, <function id, 32-bit>   // 6 bytes
   //   call <relative offset, 32-bits>   // 5 bytes
   //
   auto CurSled = OutContext.createTempSymbol("xray_sled_", true);
-  OutStreamer->EmitCodeAlignment(2);
+  OutStreamer->EmitCodeAlignment(2, &getSubtargetInfo());
   OutStreamer->EmitLabel(CurSled);
 
   // Use a two-byte `jmp`. This version of JMP takes an 8-bit relative offset as
   // an operand (computed as an offset from the jmp instruction).
   // FIXME: Find another less hacky way do force the relative jump.
   OutStreamer->EmitBytes("\xeb\x09");
   EmitNops(*OutStreamer, 9, Subtarget->is64Bit(), getSubtargetInfo());
   recordSled(CurSled, MI, SledKind::FUNCTION_ENTER);
void X86AsmPrinter::LowerPATCHABLE_RET(const MachineInstr &MI,
   //
   //   .p2align 1, ...
   // .Lxray_sled_N:
   //   ret  # or equivalent instruction
   //   # 10 bytes worth of noops
   //
   // This just makes sure that the alignment for the next instruction is 2.
   auto CurSled = OutContext.createTempSymbol("xray_sled_", true);
-  OutStreamer->EmitCodeAlignment(2);
+  OutStreamer->EmitCodeAlignment(2, &getSubtargetInfo());
   OutStreamer->EmitLabel(CurSled);
   unsigned OpCode = MI.getOperand(0).getImm();
   MCInst Ret;
   Ret.setOpcode(OpCode);
   for (auto &MO : make_range(MI.operands_begin() + 1, MI.operands_end()))
     if (auto MaybeOperand = MCIL.LowerMachineOperand(&MI, MO))
       Ret.addOperand(MaybeOperand.getValue());
   OutStreamer->EmitInstruction(Ret, getSubtargetInfo());
   EmitNops(*OutStreamer, 10, Subtarget->is64Bit(), getSubtargetInfo());
   recordSled(CurSled, MI, SledKind::FUNCTION_EXIT);
 }
 
 void X86AsmPrinter::LowerPATCHABLE_TAIL_CALL(const MachineInstr &MI,
                                              X86MCInstLower &MCIL) {
   // Like PATCHABLE_RET, we have the actual instruction in the operands to this
   // instruction so we lower that particular instruction and its operands.
   // Unlike PATCHABLE_RET though, we put the sled before the JMP, much like how
   // we do it for PATCHABLE_FUNCTION_ENTER. The sled should be very similar to
   // the PATCHABLE_FUNCTION_ENTER case, followed by the lowering of the actual
   // tail call much like how we have it in PATCHABLE_RET.
   auto CurSled = OutContext.createTempSymbol("xray_sled_", true);
-  OutStreamer->EmitCodeAlignment(2);
+  OutStreamer->EmitCodeAlignment(2, &getSubtargetInfo());
   OutStreamer->EmitLabel(CurSled);
   auto Target = OutContext.createTempSymbol();
 
   // Use a two-byte `jmp`. This version of JMP takes an 8-bit relative offset as
   // an operand (computed as an offset from the jmp instruction).
   // FIXME: Find another less hacky way do force the relative jump.
   OutStreamer->EmitBytes("\xeb\x09");
   EmitNops(*OutStreamer, 9, Subtarget->is64Bit(), getSubtargetInfo());

tools/llvm-mc/Disassembler.cpp

int Disassembler::disassemble(const Target &T,
   std::unique_ptr<const MCDisassembler> DisAsm(
     T.createMCDisassembler(STI, Ctx));
   if (!DisAsm) {
     errs() << "error: no disassembler for target " << Triple << "\n";
     return -1;
   }
 
   // Set up initial section manually here
-  Streamer.InitSections(false);
+  Streamer.InitSections(false, STI);
 
   bool ErrorOccurred = false;
 
   // Convert the input to a vector for disassembly.
   ByteArrayTy ByteArray;
   StringRef Str = Buffer.getBuffer();
   bool InAtomicBlock = false;
 

tools/llvm-mc/llvm-mc.cpp

if (FileType == OFT_AssemblyFile) {
     Str.reset(TheTarget->createMCObjectStreamer(
         TheTriple, Ctx, std::unique_ptr<MCAsmBackend>(MAB),
         DwoOut ? MAB->createDwoObjectWriter(*OS, DwoOut->os())
                : MAB->createObjectWriter(*OS),
         std::unique_ptr<MCCodeEmitter>(CE), *STI, MCOptions.MCRelaxAll,
         MCOptions.MCIncrementalLinkerCompatible,
         /*DWARFMustBeAtTheEnd*/ false));
     if (NoExecStack)
-      Str->InitSections(true);
+      Str->InitSections(true, *STI);
   }
 
   // Use Assembler information for parsing.
   Str->setUseAssemblerInfoForParsing(true);
 
   int Res = 1;
   bool disassemble = false;
   switch (Action) {