Asm Printer

// llvm/lib/Target/Mips/MipsAsmPrinter.cpp

extern "C" void LLVMInitializeMipsAsmPrinter() {
  RegisterAsmPrinter<MipsAsmPrinter> X(getTheMipsTarget());
  RegisterAsmPrinter<MipsAsmPrinter> Y(getTheMipselTarget());
  RegisterAsmPrinter<MipsAsmPrinter> A(getTheMips64Target());
  RegisterAsmPrinter<MipsAsmPrinter> B(getTheMips64elTarget());
  RegisterAsmPrinter<MipsAsmPrinter> C(getTheMipsCheriTarget());
}

// llvm/lib/CodeGen/LLVMTargetMachine.cpp

bool LLVMTargetMachine::addAsmPrinter(PassManagerBase &PM,
                                      raw_pwrite_stream &Out,
                                      raw_pwrite_stream *DwoOut,
                                      CodeGenFileType FileType,
                                      MCContext &Context) {

  // ...

  // Create the AsmPrinter, which takes ownership of AsmStreamer if successful.
  FunctionPass *Printer =
      getTarget().createAsmPrinter(*this, std::move(AsmStreamer));

  errs()<<"Lele: asm printer pass added\n";
  
  if (!Printer)
    return true;

  PM.add(Printer);
  return false;
}

// The call path for this function is:

clang::EmitBackendOutput()
 -> EmitAssemblyHelper::EmitAssembly()
    -> EmitAssemblyHelper::AddEmitPasses()
       -> LLVMTargetMachine::addPassesToEmitFile()
          -> LLVMTargetMachine::addAsmPrinter()

// llvm/lib/Target/Mips/MipsAsmPrinter.cpp

bool MipsAsmPrinter::runOnMachineFunction(MachineFunction &MF) {
  Subtarget = &MF.getSubtarget<MipsSubtarget>();

  MipsFI = MF.getInfo<MipsFunctionInfo>();
  if (Subtarget->inMips16Mode())
    for (std::map<
             const char *,
             const Mips16HardFloatInfo::FuncSignature *>::const_iterator
             it = MipsFI->StubsNeeded.begin();
         it != MipsFI->StubsNeeded.end(); ++it) {
      const char *Symbol = it->first;
      const Mips16HardFloatInfo::FuncSignature *Signature = it->second;
      if (StubsNeeded.find(Symbol) == StubsNeeded.end())
        StubsNeeded[Symbol] = Signature;
    }
  MCP = MF.getConstantPool();

  // In NaCl, all indirect jump targets must be aligned to bundle size.
  if (Subtarget->isTargetNaCl())
    NaClAlignIndirectJumpTargets(MF);

  AsmPrinter::runOnMachineFunction(MF);

  emitXRayTable();

  return true;
}

// llvm/include/llvm/CodeGen/AsmPrinter.h

  /// Emit the specified function out to the OutStreamer.
  bool runOnMachineFunction(MachineFunction &MF) override {
    SetupMachineFunction(MF);
    EmitFunctionBody();
    return false;
  }

// llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

/// EmitFunctionBody - This method emits the body and trailer for a
/// function.
void AsmPrinter::EmitFunctionBody() {
  EmitFunctionHeader();
  EmitFunctionBodyStart();
  ...
  // Print out code for the function.
  bool HasAnyRealCode = false;
  int NumInstsInFunction = 0;
  for (auto &MBB : *MF) {
    // Print a label for the basic block.
    EmitBasicBlockStart(MBB);
    for (auto &MI : MBB) {
      // Print the assembly for the instruction.

      // If there is a pre-instruction symbol, emit a label for it here.
      if (MCSymbol *S = MI.getPreInstrSymbol())
        OutStreamer->EmitLabel(S);
      ...
      switch (MI.getOpcode()) {
      ...
      case TargetOpcode::INLINEASM:
      case TargetOpcode::INLINEASM_BR:
        EmitInlineAsm(&MI);
        break;
      ...
      default:
        EmitInstruction(&MI);
        break;
      }
      ...
    }

    EmitBasicBlockEnd(MBB);
  }

  // Emit target-specific gunk after the function body.
  EmitFunctionBodyEnd();
  // Print out jump tables referenced by the function.
  EmitJumpTableInfo();
  // Emit section containing stack size metadata.
  emitStackSizeSection(*MF);
  ...
}

// llvm/lib/Target/Mips/MipsAsmPrinter.cpp
void MipsAsmPrinter::EmitInstruction(const MachineInstr *MI) {
  MipsTargetStreamer &TS = getTargetStreamer();
  unsigned Opc = MI->getOpcode();
  TS.forbidModuleDirective();

  ...

  MachineBasicBlock::const_instr_iterator I = MI->getIterator();
  MachineBasicBlock::const_instr_iterator E = MI->getParent()->instr_end();

  do {
    ...

    MCInst TmpInst0;
    MCInstLowering.Lower(&*I, TmpInst0);
    EmitToStreamer(*OutStreamer, TmpInst0);
  } while ((++I != E) && I->isInsideBundle()); // Delay slot check
}

// Inheritance relations

MCStreamer (contain an instance of `MCTargetStreamer` as member `TargetStreamer`)
 -> MCAsmStreamer (final)
 -> MCObjectStreamer
    -> MCELFStreamer
       -> MipsELFStreamer
    -> MCWasmStreamer

// MCTargetStreamer for directives.

// llvm/include/llvm/MCStreamer.h
MCTargetStreamer (contain an instance `MCStreamer` as member `Streamer`)
 -> ARMTargetStreamer // include/llvm/MCStreamer.h
 -> MipsTargetStreamer // lib/Target/Mips/MipsTargetStreamer.h
    -> MipsTargetAsmStreamer
    -> MipsTargetELFStreamer
 -> RISCVTargetStreamer // lib/Target/RISCV/MCTargetDesc/RISCVTargetStreamer.h

AsmPrinter::doFinalization(Module &M)
=> AsmPrinter::emitGlobalVariable(const GlobalVariable *GV)
   => MCSymbol *GVSym = getSymbol(GV); MCSymbol *EmittedSym = GVSym;
   => emitVisibility(EmittedSym, GV->getVisitbility(), !GV->isDeclaration());
      => OutStreamer->emitSymbolAttribute(Sym, Attr);
   => if (GVKind.isCommon()) OutStreamer->emitCommonSymbol(GVSym, Size,...);
      // Determine to which section this global should be emitted.
   => MCSection *TheSection = getObjFileLowering().SectionForGlobal(GV, GVKind, TM);
   => MCSymbol *EmittedInitSym = GVSym;
   => OutStreamer->SwitchSection(TheSection);
   => emitLinkage(GV, EmittedInitSym);
   => emitAlignment(Alignment, GV);
   => OutStreamer->emitLabel(EmittedInitSym);
   => emitGlobalConstant(GV->getParent()->getDataLayout(), GV->getInitializer(),
                     static_cast<uint64_t>(TailPadding));
      => if (Size) emitGlobalConstantImpl(DL, CV, *this);
          => if 1/2/4/8 OutStreamer->emitIntValue(CI->getZExtValue(), Size);
          => if larger: emitGlobalConstantLargeInt(...)
             ==> OutStreamer->emitIntValue(Val, 8)
             ==> OutStreamer->emitIntValue(ExtraBits, Size)
   => OutStreamer->AddBlankLine()

=> AsmPrinter::emitGlobalGOTEquivs()
  => AsmPrinter::emitGlobalVariable(..);