Use std::map::insert instead of emplace for libstdc++ 4.7

[rnk]

Summary

Rename WinCodeViewLineTables to CodeViewDebug, similar to DwarfDebug

Soon it will be responsible for more than line tables.

[majnemer]

LGTM

[rnk]

Silly phab, got the wrong title.

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 // This file implements the AsmPrinter class.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "DwarfDebug.h"
 #include "DwarfException.h"
 #include "WinException.h"
-#include "WinCodeViewLineTables.h"
+#include "CodeViewDebug.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/ConstantFolding.h"
 #include "llvm/CodeGen/Analysis.h"
 #include "llvm/CodeGen/GCMetadataPrinter.h"
 #include "llvm/CodeGen/MachineConstantPool.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineFunction.h"
EmitInlineAsm(M.getModuleInlineAsm()+"\n",
                   OutContext.getSubtargetCopy(*STI), TM.Options.MCOptions);
     OutStreamer->AddComment("End of file scope inline assembly");
     OutStreamer->AddBlankLine();
   }
 
   if (MAI->doesSupportDebugInformation()) {
     bool EmitCodeView = MMI->getModule()->getCodeViewFlag();
     if (EmitCodeView && TM.getTargetTriple().isKnownWindowsMSVCEnvironment()) {
-      Handlers.push_back(HandlerInfo(new WinCodeViewLineTables(this),
+      Handlers.push_back(HandlerInfo(new CodeViewDebug(this),
                                      DbgTimerName,
                                      CodeViewLineTablesGroupName));
     }
     if (!EmitCodeView || MMI->getModule()->getDwarfVersion()) {
       DD = new DwarfDebug(this, &M);
       Handlers.push_back(HandlerInfo(DD, DbgTimerName, DWARFGroupName));
     }
   }

lib/CodeGen/AsmPrinter/CMakeLists.txt

add_llvm_library(LLVMAsmPrinter
   DwarfExpression.cpp
   DwarfFile.cpp
   DwarfStringPool.cpp
   DwarfUnit.cpp
   EHStreamer.cpp
   ErlangGCPrinter.cpp
   OcamlGCPrinter.cpp
   WinException.cpp
-  WinCodeViewLineTables.cpp
+  CodeViewDebug.cpp
   )
 
 add_dependencies(LLVMAsmPrinter intrinsics_gen)

lib/CodeGen/AsmPrinter/CodeViewDebug.h

-//===-- llvm/lib/CodeGen/AsmPrinter/WinCodeViewLineTables.h ----*- C++ -*--===//
+//===-- llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.h ----*- C++ -*--===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
-// This file contains support for writing line tables info into COFF files.
+// This file contains support for writing Microsoft CodeView debug info.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIB_CODEGEN_ASMPRINTER_WINCODEVIEWLINETABLES_H
-#define LLVM_LIB_CODEGEN_ASMPRINTER_WINCODEVIEWLINETABLES_H
+#ifndef LLVM_LIB_CODEGEN_ASMPRINTER_CODEVIEWDEBUG_H
+#define LLVM_LIB_CODEGEN_ASMPRINTER_CODEVIEWDEBUG_H
 
 #include "AsmPrinterHandler.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/LexicalScopes.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 
 namespace llvm {
 /// \brief Collects and handles line tables information in a CodeView format.
-class LLVM_LIBRARY_VISIBILITY WinCodeViewLineTables : public AsmPrinterHandler {
+class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public AsmPrinterHandler {
   AsmPrinter *Asm;
   DebugLoc PrevInstLoc;
 
   // For each function, store a vector of labels to its instructions, as well as
   // to the end of the function.
   struct FunctionInfo {
     SmallVector<MCSymbol *, 10> Instrs;
     MCSymbol *End;
void clear() {
     assert(CurFn == nullptr);
     FileNameRegistry.clear();
     InstrInfo.clear();
   }
 
   void emitDebugInfoForFunction(const Function *GV);
 
 public:
-  WinCodeViewLineTables(AsmPrinter *Asm);
+  CodeViewDebug(AsmPrinter *Asm);
 
   void setSymbolSize(const llvm::MCSymbol *, uint64_t) override {}
 
   /// \brief Emit the COFF section that holds the line table information.
   void endModule() override;
 
   /// \brief Gather pre-function debug information.
   void beginFunction(const MachineFunction *MF) override;

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

-//===-- llvm/lib/CodeGen/AsmPrinter/WinCodeViewLineTables.cpp --*- C++ -*--===//
+//===-- llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp --*- C++ -*--===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
-// This file contains support for writing line tables info into COFF files.
+// This file contains support for writing Microsoft CodeView debug info.
 //
 //===----------------------------------------------------------------------===//
 
-#include "WinCodeViewLineTables.h"
+#include "CodeViewDebug.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/Support/COFF.h"
 
 using namespace llvm::codeview;
 
 namespace llvm {
 
-StringRef WinCodeViewLineTables::getFullFilepath(const MDNode *S) {
+StringRef CodeViewDebug::getFullFilepath(const MDNode *S) {
   assert(S);
   assert((isa<DICompileUnit>(S) || isa<DIFile>(S) || isa<DISubprogram>(S) ||
           isa<DILexicalBlockBase>(S)) &&
          "Unexpected scope info");
 
   auto *Scope = cast<DIScope>(S);
   StringRef Dir = Scope->getDirectory(),
             Filename = Scope->getFilename();
StringRef CodeViewDebug::getFullFilepath(const MDNode *S) {
   // Remove all duplicate backslashes.
   Cursor = 0;
   while ((Cursor = Filepath.find("\\\\", Cursor)) != std::string::npos)
     Filepath.erase(Cursor, 1);
 
   return Filepath;
 }
 
-void WinCodeViewLineTables::maybeRecordLocation(DebugLoc DL,
+void CodeViewDebug::maybeRecordLocation(DebugLoc DL,
                                                 const MachineFunction *MF) {
   const MDNode *Scope = DL.getScope();
   if (!Scope)
     return;
   unsigned LineNumber = DL.getLine();
   // Skip this line if it is longer than the maximum we can record.
   if (LineNumber > COFF::CVL_MaxLineNumber)
     return;
void CodeViewDebug::maybeRecordLocation(DebugLoc DL,
   FileNameRegistry.add(Filename);
 
   MCSymbol *MCL = Asm->MMI->getContext().createTempSymbol();
   Asm->OutStreamer->EmitLabel(MCL);
   CurFn->Instrs.push_back(MCL);
   InstrInfo[MCL] = InstrInfoTy(Filename, LineNumber, ColumnNumber);
 }
 
-WinCodeViewLineTables::WinCodeViewLineTables(AsmPrinter *AP)
+CodeViewDebug::CodeViewDebug(AsmPrinter *AP)
     : Asm(nullptr), CurFn(nullptr) {
   MachineModuleInfo *MMI = AP->MMI;
 
   // If module doesn't have named metadata anchors or COFF debug section
   // is not available, skip any debug info related stuff.
   if (!MMI->getModule()->getNamedMetadata("llvm.dbg.cu") ||
       !AP->getObjFileLowering().getCOFFDebugSymbolsSection())
     return;
 
   // Tell MMI that we have debug info.
   MMI->setDebugInfoAvailability(true);
   Asm = AP;
 }
 
-void WinCodeViewLineTables::endModule() {
+void CodeViewDebug::endModule() {
   if (FnDebugInfo.empty())
     return;
 
   // FIXME: For functions that are comdat, we should emit separate .debug$S
   // sections that are comdat associative with the main function instead of
   // having one big .debug$S section.
   assert(Asm != nullptr);
   Asm->OutStreamer->SwitchSection(
static void EmitLabelDiff(MCStreamer &Streamer,
   MCContext &Context = Streamer.getContext();
   const MCExpr *FromRef = MCSymbolRefExpr::create(From, Variant, Context),
                *ToRef   = MCSymbolRefExpr::create(To, Variant, Context);
   const MCExpr *AddrDelta =
       MCBinaryExpr::create(MCBinaryExpr::Sub, ToRef, FromRef, Context);
   Streamer.EmitValue(AddrDelta, Size);
 }
 
-void WinCodeViewLineTables::emitDebugInfoForFunction(const Function *GV) {
+void CodeViewDebug::emitDebugInfoForFunction(const Function *GV) {
   // For each function there is a separate subsection
   // which holds the PC to file:line table.
   const MCSymbol *Fn = Asm->getSymbol(GV);
   assert(Fn);
 
   const FunctionInfo &FI = FnDebugInfo[GV];
   if (FI.Instrs.empty())
     return;
for (size_t J = 0, F = FI.Instrs.size(); J != F; ++J) {
     uint32_t LineData = LineNumber | COFF::CVL_IsStatement;
     Asm->EmitInt32(LineData);
   }
 
   FinishPreviousChunk();
   Asm->OutStreamer->EmitLabel(LineTableEnd);
 }
 
-void WinCodeViewLineTables::beginFunction(const MachineFunction *MF) {
+void CodeViewDebug::beginFunction(const MachineFunction *MF) {
   assert(!CurFn && "Can't process two functions at once!");
 
   if (!Asm || !Asm->MMI->hasDebugInfo())
     return;
 
   const Function *GV = MF->getFunction();
   assert(FnDebugInfo.count(GV) == false);
   VisitedFunctions.push_back(GV);
void CodeViewDebug::beginFunction(const MachineFunction *MF) {
   }
   // Record beginning of function if we have a non-empty prologue.
   if (PrologEndLoc && !EmptyPrologue) {
     DebugLoc FnStartDL = PrologEndLoc.getFnDebugLoc();
     maybeRecordLocation(FnStartDL, MF);
   }
 }
 
-void WinCodeViewLineTables::endFunction(const MachineFunction *MF) {
+void CodeViewDebug::endFunction(const MachineFunction *MF) {
   if (!Asm || !CurFn)  // We haven't created any debug info for this function.
     return;
 
   const Function *GV = MF->getFunction();
   assert(FnDebugInfo.count(GV));
   assert(CurFn == &FnDebugInfo[GV]);
 
   if (CurFn->Instrs.empty()) {
     FnDebugInfo.erase(GV);
     VisitedFunctions.pop_back();
   } else {
     CurFn->End = Asm->getFunctionEnd();
   }
   CurFn = nullptr;
 }
 
-void WinCodeViewLineTables::beginInstruction(const MachineInstr *MI) {
+void CodeViewDebug::beginInstruction(const MachineInstr *MI) {
   // Ignore DBG_VALUE locations and function prologue.
   if (!Asm || MI->isDebugValue() || MI->getFlag(MachineInstr::FrameSetup))
     return;
   DebugLoc DL = MI->getDebugLoc();
   if (DL == PrevInstLoc || !DL)
     return;
   maybeRecordLocation(DL, Asm->MF);
 }
 }

tools/llvm-readobj/COFFDumper.cpp

case ModuleSubstreamKind::FrameData: {
       }
 
       const auto *FD = reinterpret_cast<const FrameData *>(
           Contents.drop_front(RelocationSize).data());
 
       StringRef LinkageName;
       error(resolveSymbolName(Obj->getCOFFSection(Section), SectionOffset,
                               LinkageName));
-      if (!FunctionFrameData.emplace(LinkageName, FD).second) {
+      if (!FunctionFrameData.insert(std::make_pair(LinkageName, FD)).second) {
         error(object_error::parse_failed);
         return;
       }
       break;
     }
 
     // Do nothing for unrecognized subsections.
     default: