[PowerPC][NFC] Split PPCELFStreamer::emitInstruction

[stefanp]

Summary

Split off PPCELFStreamer::emitPrefixInstruction from PPCELFStreamer::emitInstruction.

[amyk]

This makes sense and LGTM.

[NeHuang]

LGTM except one nit: Is it better to change the function name from emitPrefixInstruction to emitPrefixedInstruction? (referred to Emitter->isPrefixedInstruction)

llvm/lib/Target/PowerPC/MCTargetDesc/PPCELFStreamer.h

public:
   PPCELFStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> MAB,
                  std::unique_ptr<MCObjectWriter> OW,
                  std::unique_ptr<MCCodeEmitter> Emitter);
 
   void emitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) override;
 
   // EmitLabel updates LastLabel and LastLabelLoc when a new label is emitted.
   void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
+private:
+  void emitPrefixedInstruction(const MCInst &Inst, const MCSubtargetInfo &STI);
 };
 
 MCELFStreamer *createPPCELFStreamer(MCContext &Context,
                                     std::unique_ptr<MCAsmBackend> MAB,
                                     std::unique_ptr<MCObjectWriter> OW,
                                     std::unique_ptr<MCCodeEmitter> Emitter);
 } // end namespace llvm
 
 #endif // LLVM_LIB_TARGET_PPC_MCELFSTREAMER_PPCELFSTREAMER_H

llvm/lib/Target/PowerPC/MCTargetDesc/PPCELFStreamer.cpp

 PPCELFStreamer::PPCELFStreamer(MCContext &Context,
                                std::unique_ptr<MCAsmBackend> MAB,
                                std::unique_ptr<MCObjectWriter> OW,
                                std::unique_ptr<MCCodeEmitter> Emitter)
     : MCELFStreamer(Context, std::move(MAB), std::move(OW),
                     std::move(Emitter)), LastLabel(NULL) {
 }
 
-void PPCELFStreamer::emitInstruction(const MCInst &Inst,
+void PPCELFStreamer::emitPrefixedInstruction(const MCInst &Inst,
                                              const MCSubtargetInfo &STI) {
-  PPCMCCodeEmitter *Emitter =
-      static_cast<PPCMCCodeEmitter*>(getAssembler().getEmitterPtr());
-
-  // Special handling is only for prefixed instructions.
-  if (!Emitter->isPrefixedInstruction(Inst)) {
-    MCELFStreamer::emitInstruction(Inst, STI);
-    return;
-  }
-
   // Prefixed instructions must not cross a 64-byte boundary (i.e. prefix is
   // before the boundary and the remaining 4-bytes are after the boundary). In
   // order to achieve this, a nop is added prior to any such boundary-crossing
   // prefixed instruction. Align to 64 bytes if possible but add a maximum of 4
   // bytes when trying to do that. If alignment requires adding more than 4
   // bytes then the instruction won't be aligned. When emitting a code alignment
   // a new fragment is created for this alignment. This fragment will contain
   // all of the nops required as part of the alignment operation. In the cases
if (LastLabel && !LastLabel->isUnset() && LastLabelLoc.isValid() &&
     // was just added.
     if (InstLine == LabelLine) {
       AssignFragment(LastLabel, InstructionFragment);
       LastLabel->setOffset(0);
     }
   }
 }
 
+void PPCELFStreamer::emitInstruction(const MCInst &Inst,
+                                     const MCSubtargetInfo &STI) {
+  PPCMCCodeEmitter *Emitter =
+      static_cast<PPCMCCodeEmitter*>(getAssembler().getEmitterPtr());
+
+  // Special handling is only for prefixed instructions.
+  if (!Emitter->isPrefixedInstruction(Inst)) {
+    MCELFStreamer::emitInstruction(Inst, STI);
+    return;
+  }
+  emitPrefixedInstruction(Inst, STI);
+}
+
 void PPCELFStreamer::emitLabel(MCSymbol *Symbol, SMLoc Loc) {
   LastLabel = Symbol;
   LastLabelLoc = Loc;
   MCELFStreamer::emitLabel(Symbol);
 }
 
 MCELFStreamer *llvm::createPPCELFStreamer(
     MCContext &Context, std::unique_ptr<MCAsmBackend> MAB,
     std::unique_ptr<MCObjectWriter> OW,
     std::unique_ptr<MCCodeEmitter> Emitter) {
   return new PPCELFStreamer(Context, std::move(MAB), std::move(OW),
                             std::move(Emitter));
 }