Cache LSDA label for future use (NFC)

[aheejin]

Summary

This adds setLSDALabel and getLSDALabel to EHStreamer, to cache
per-function LSDA starting label for future use. Currently no EH schemes
need this, but wasm EH scheme needs to this in a follow-up patch, and
because this LSDA label is emitted in a target-independent part of code,
it is not easy to make it as a wasm-only function.

[aheejin]

I couldn't add setLSDALabel to [[ https://github.com/llvm-mirror/llvm/blob/993ef0ca960f8ffd107c33bfbf1fd603bcf5c66c/lib/CodeGen/AsmPrinter/WinException.cpp#L1063 | emitCLRExceptionTable ]], because to me it was unclear which symbol is the per-function LSDA symbol. Please let me know if there is one.

[aheejin]

Hmm, this does not look like a good approach anyway. Sorry!

lib/CodeGen/AsmPrinter/EHStreamer.h

 class LLVM_LIBRARY_VISIBILITY EHStreamer : public AsmPrinterHandler {
 protected:
   /// Target of directive emission.
   AsmPrinter *Asm;
 
   /// Collected machine module information.
   MachineModuleInfo *MMI;
 
+  // Starting symbol of an per-function exception table.
+  MCSymbol *LSDALabel = nullptr;
+
   /// How many leading type ids two landing pads have in common.
   static unsigned sharedTypeIDs(const LandingPadInfo *L,
                                 const LandingPadInfo *R);
 
   /// Structure holding a try-range and the associated landing pad.
   struct PadRange {
     // The index of the landing pad.
     unsigned PadIndex;
protected:
 
   // Helpers for identifying what kind of clause an EH typeid or selector
   // corresponds to. Negative selectors are for filter clauses, the zero
   // selector is for cleanups, and positive selectors are for catch clauses.
   static bool isFilterEHSelector(int Selector) { return Selector < 0; }
   static bool isCleanupEHSelector(int Selector) { return Selector == 0; }
   static bool isCatchEHSelector(int Selector) { return Selector > 0; }
 
+  // Set and get the starting symbol of an per-function exception table.
+  void setLSDALabel(MCSymbol *Sym) { LSDALabel = Sym; }
+  MCSymbol *getLSDALabel() { return LSDALabel; }
+
 public:
   EHStreamer(AsmPrinter *A);
   ~EHStreamer() override;
 
   // Unused.
   void setSymbolSize(const MCSymbol *Sym, uint64_t Size) override {}
   void beginInstruction(const MachineInstr *MI) override {}
   void endInstruction() override {}

lib/CodeGen/AsmPrinter/EHStreamer.cpp

void EHStreamer::emitExceptionTable() {
   if (LSDASection)
     Asm->OutStreamer->SwitchSection(LSDASection);
   Asm->EmitAlignment(2);
 
   // Emit the LSDA.
   MCSymbol *GCCETSym =
     Asm->OutContext.getOrCreateSymbol(Twine("GCC_except_table")+
                                       Twine(Asm->getFunctionNumber()));
+  setLSDALabel(GCCETSym);
   Asm->OutStreamer->EmitLabel(GCCETSym);
   Asm->OutStreamer->EmitLabel(Asm->getCurExceptionSym());
 
   // Emit the LSDA header.
   Asm->EmitEncodingByte(dwarf::DW_EH_PE_omit, "@LPStart");
   Asm->EmitEncodingByte(TTypeEncoding, "@TType");
 
   MCSymbol *TTBaseLabel = nullptr;

lib/CodeGen/AsmPrinter/WinException.cpp

void WinException::emitCSpecificHandlerTable(const MachineFunction *MF) {
   const MCExpr *MCOffset =
       MCConstantExpr::create(FuncInfo.SEHSetFrameOffset, Ctx);
   Asm->OutStreamer->EmitAssignment(ParentFrameOffset, MCOffset);
 
   // Use the assembler to compute the number of table entries through label
   // difference and division.
   MCSymbol *TableBegin =
       Ctx.createTempSymbol("lsda_begin", /*AlwaysAddSuffix=*/true);
+  setLSDALabel(TableBegin);
   MCSymbol *TableEnd =
       Ctx.createTempSymbol("lsda_end", /*AlwaysAddSuffix=*/true);
   const MCExpr *LabelDiff = getOffset(TableEnd, TableBegin);
   const MCExpr *EntrySize = MCConstantExpr::create(16, Ctx);
   const MCExpr *EntryCount = MCBinaryExpr::createDiv(LabelDiff, EntrySize, Ctx);
   AddComment("Number of call sites");
   OS.EmitValue(EntryCount, 4);
 
if (shouldEmitPersonality) {
     // If we're 64-bit, emit a pointer to the C++ EH data, and build a map from
     // IPs to state numbers.
     FuncInfoXData =
         Asm->OutContext.getOrCreateSymbol(Twine("$cppxdata$", FuncLinkageName));
     computeIP2StateTable(MF, FuncInfo, IPToStateTable);
   } else {
     FuncInfoXData = Asm->OutContext.getOrCreateLSDASymbol(FuncLinkageName);
   }
+  setLSDALabel(FuncInfoXData);
 
   int UnwindHelpOffset = 0;
   if (Asm->MAI->usesWindowsCFI())
     UnwindHelpOffset =
         getFrameIndexOffset(FuncInfo.UnwindHelpFrameIdx, FuncInfo);
 
   MCSymbol *UnwindMapXData = nullptr;
   MCSymbol *TryBlockMapXData = nullptr;
if (VerboseAsm)
       OS.AddComment(Comment);
   };
 
   const WinEHFuncInfo &FuncInfo = *MF->getWinEHFuncInfo();
   emitEHRegistrationOffsetLabel(FuncInfo, FLinkageName);
 
   // Emit the __ehtable label that we use for llvm.x86.seh.lsda.
   MCSymbol *LSDALabel = Asm->OutContext.getOrCreateLSDASymbol(FLinkageName);
+  setLSDALabel(LSDALabel);
   OS.EmitValueToAlignment(4);
   OS.EmitLabel(LSDALabel);
 
   const Function *Per =
       dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts());
   StringRef PerName = Per->getName();
   int BaseState = -1;
   if (PerName == "_except_handler4") {