[MC] Rename a misnamed function. NFC.

[ikudrin]

Summary

The patch renames MakeStartMinusEndExpr() to MakeEndMinusStartExpr() to better reflect an expression it creates.

[jhenderson]

LGTM, thanks for doing this!

llvm/lib/MC/MCDwarf.cpp

MCOS->getContext()
       .getMCDwarfLineTable(MCOS->getContext().getDwarfCompileUnitID())
       .getMCLineSections()
       .addLineEntry(LineEntry, Section);
 }
 
 //
 // This helper routine returns an expression of End - Start + IntVal .
 //
-static inline const MCExpr *MakeStartMinusEndExpr(MCContext &Ctx,
+static inline const MCExpr *MakeEndMinusStartExpr(MCContext &Ctx,
                                                   const MCSymbol &Start,
                                                   const MCSymbol &End,
                                                   int IntVal) {
   MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None;
   const MCExpr *Res = MCSymbolRefExpr::create(&End, Variant, Ctx);
   const MCExpr *RHS = MCSymbolRefExpr::create(&Start, Variant, Ctx);
   const MCExpr *Res1 = MCBinaryExpr::create(MCBinaryExpr::Sub, Res, RHS, Ctx);
   const MCExpr *Res2 = MCConstantExpr::create(IntVal, Ctx);
MCDwarfLineTableHeader::Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
 
   if (context.getDwarfFormat() == dwarf::DWARF64)
     // Emit DWARF64 mark.
     MCOS->emitInt32(dwarf::DW_LENGTH_DWARF64);
 
   // The length field does not include itself and, in case of the 64-bit DWARF
   // format, the DWARF64 mark.
   emitAbsValue(*MCOS,
-               MakeStartMinusEndExpr(context, *LineStartSym, *LineEndSym,
+               MakeEndMinusStartExpr(context, *LineStartSym, *LineEndSym,
                                      UnitLengthBytes),
                OffsetSize);
 
   // Next 2 bytes is the Version.
   unsigned LineTableVersion = context.getDwarfVersion();
   MCOS->emitInt16(LineTableVersion);
 
   // Keep track of the bytes between the very start and where the header length
   // comes out.
   unsigned PreHeaderLengthBytes = UnitLengthBytes + 2;
 
   // In v5, we get address info next.
   if (LineTableVersion >= 5) {
     MCOS->emitInt8(context.getAsmInfo()->getCodePointerSize());
     MCOS->emitInt8(0); // Segment selector; same as EmitGenDwarfAranges.
     PreHeaderLengthBytes += 2;
   }
 
   // Create a symbol for the end of the prologue (to be set when we get there).
   MCSymbol *ProEndSym = context.createTempSymbol(); // Lprologue_end
 
   // Length of the prologue, is the next 4 bytes (8 bytes for DWARF64). This is
   // actually the length from after the length word, to the end of the prologue.
   emitAbsValue(*MCOS,
-               MakeStartMinusEndExpr(context, *LineStartSym, *ProEndSym,
+               MakeEndMinusStartExpr(context, *LineStartSym, *ProEndSym,
                                      (PreHeaderLengthBytes + OffsetSize)),
                OffsetSize);
 
   // Parameters of the state machine, are next.
   MCOS->emitInt8(context.getAsmInfo()->getMinInstAlignment());
   // maximum_operations_per_instruction
   // For non-VLIW architectures this field is always 1.
   // FIXME: VLIW architectures need to update this field accordingly.
for (MCSection *Sec : Sections) {
     const MCSymbol *StartSymbol = Sec->getBeginSymbol();
     MCSymbol *EndSymbol = Sec->getEndSymbol(context);
     assert(StartSymbol && "StartSymbol must not be NULL");
     assert(EndSymbol && "EndSymbol must not be NULL");
 
     const MCExpr *Addr = MCSymbolRefExpr::create(
       StartSymbol, MCSymbolRefExpr::VK_None, context);
     const MCExpr *Size =
-        MakeStartMinusEndExpr(context, *StartSymbol, *EndSymbol, 0);
+        MakeEndMinusStartExpr(context, *StartSymbol, *EndSymbol, 0);
     MCOS->emitValue(Addr, AddrSize);
     emitAbsValue(*MCOS, Size, AddrSize);
   }
 
   // And finally the pair of terminating zeros.
   MCOS->emitIntValue(0, AddrSize);
   MCOS->emitIntValue(0, AddrSize);
 }
static void EmitGenDwarfInfo(MCStreamer *MCOS,
 
   if (context.getDwarfFormat() == dwarf::DWARF64)
     // Emit DWARF64 mark.
     MCOS->emitInt32(dwarf::DW_LENGTH_DWARF64);
 
   // The 4 (8 for DWARF64) byte total length of the information for this
   // compilation unit, not including the unit length field itself.
   const MCExpr *Length =
-      MakeStartMinusEndExpr(context, *InfoStart, *InfoEnd, UnitLengthBytes);
+      MakeEndMinusStartExpr(context, *InfoStart, *InfoEnd, UnitLengthBytes);
   emitAbsValue(*MCOS, Length, OffsetSize);
 
   // The 2 byte DWARF version.
   MCOS->emitInt16(context.getDwarfVersion());
 
   // The DWARF v5 header has unit type, address size, abbrev offset.
   // Earlier versions have abbrev offset, address size.
   const MCAsmInfo &AsmInfo = *context.getAsmInfo();
if (MCOS->getContext().getDwarfVersion() >= 5) {
     RangesSymbol = context.createTempSymbol("debug_rnglist0_start", true, true);
     MCOS->emitLabel(RangesSymbol);
     for (MCSection *Sec : Sections) {
       const MCSymbol *StartSymbol = Sec->getBeginSymbol();
       const MCSymbol *EndSymbol = Sec->getEndSymbol(context);
       const MCExpr *SectionStartAddr = MCSymbolRefExpr::create(
           StartSymbol, MCSymbolRefExpr::VK_None, context);
       const MCExpr *SectionSize =
-          MakeStartMinusEndExpr(context, *StartSymbol, *EndSymbol, 0);
+          MakeEndMinusStartExpr(context, *StartSymbol, *EndSymbol, 0);
       MCOS->emitInt8(dwarf::DW_RLE_start_length);
       MCOS->emitValue(SectionStartAddr, AddrSize);
       MCOS->emitULEB128Value(SectionSize);
     }
     MCOS->emitInt8(dwarf::DW_RLE_end_of_list);
     MCOS->emitLabel(EndSymbol);
   } else {
     MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfRangesSection());
     RangesSymbol = context.createTempSymbol("debug_ranges_start", true, true);
     MCOS->emitLabel(RangesSymbol);
     for (MCSection *Sec : Sections) {
       const MCSymbol *StartSymbol = Sec->getBeginSymbol();
       const MCSymbol *EndSymbol = Sec->getEndSymbol(context);
 
       // Emit a base address selection entry for the section start.
       const MCExpr *SectionStartAddr = MCSymbolRefExpr::create(
           StartSymbol, MCSymbolRefExpr::VK_None, context);
       MCOS->emitFill(AddrSize, 0xFF);
       MCOS->emitValue(SectionStartAddr, AddrSize);
 
       // Emit a range list entry spanning this section.
       const MCExpr *SectionSize =
-          MakeStartMinusEndExpr(context, *StartSymbol, *EndSymbol, 0);
+          MakeEndMinusStartExpr(context, *StartSymbol, *EndSymbol, 0);
       MCOS->emitIntValue(0, AddrSize);
       emitAbsValue(*MCOS, SectionSize, AddrSize);
     }
 
     // Emit end of list entry
     MCOS->emitIntValue(0, AddrSize);
     MCOS->emitIntValue(0, AddrSize);
   }
void FrameEmitterImpl::EmitCompactUnwind(const MCDwarfFrameInfo &Frame) {
 
   // Range Start
   unsigned FDEEncoding = MOFI->getFDEEncoding();
   unsigned Size = getSizeForEncoding(Streamer, FDEEncoding);
   Streamer.emitSymbolValue(Frame.Begin, Size);
 
   // Range Length
   const MCExpr *Range =
-      MakeStartMinusEndExpr(Context, *Frame.Begin, *Frame.End, 0);
+      MakeEndMinusStartExpr(Context, *Frame.Begin, *Frame.End, 0);
   emitAbsValue(Streamer, Range, 4);
 
   // Compact Encoding
   Size = getSizeForEncoding(Streamer, dwarf::DW_EH_PE_udata4);
   Streamer.emitIntValue(Encoding, Size);
 
   // Personality Function
   Size = getSizeForEncoding(Streamer, dwarf::DW_EH_PE_absptr);
const MCSymbol &FrameEmitterImpl::EmitCIE(const MCDwarfFrameInfo &Frame) {
   unsigned OffsetSize = dwarf::getDwarfOffsetByteSize(Format);
   bool IsDwarf64 = Format == dwarf::DWARF64;
 
   if (IsDwarf64)
     // DWARF64 mark
     Streamer.emitInt32(dwarf::DW_LENGTH_DWARF64);
 
   // Length
-  const MCExpr *Length = MakeStartMinusEndExpr(context, *sectionStart,
+  const MCExpr *Length = MakeEndMinusStartExpr(context, *sectionStart,
                                                *sectionEnd, UnitLengthBytes);
   emitAbsValue(Streamer, Length, OffsetSize);
 
   // CIE ID
   uint64_t CIE_ID =
       IsEH ? 0 : (IsDwarf64 ? dwarf::DW64_CIE_ID : dwarf::DW_CIE_ID);
   Streamer.emitIntValue(CIE_ID, OffsetSize);
 
void FrameEmitterImpl::EmitFDE(const MCSymbol &cieStart,
   dwarf::DwarfFormat Format = IsEH ? dwarf::DWARF32 : context.getDwarfFormat();
   unsigned OffsetSize = dwarf::getDwarfOffsetByteSize(Format);
 
   if (Format == dwarf::DWARF64)
     // DWARF64 mark
     Streamer.emitInt32(dwarf::DW_LENGTH_DWARF64);
 
   // Length
-  const MCExpr *Length = MakeStartMinusEndExpr(context, *fdeStart, *fdeEnd, 0);
+  const MCExpr *Length = MakeEndMinusStartExpr(context, *fdeStart, *fdeEnd, 0);
   emitAbsValue(Streamer, Length, OffsetSize);
 
   Streamer.emitLabel(fdeStart);
 
   // CIE Pointer
   const MCAsmInfo *asmInfo = context.getAsmInfo();
   if (IsEH) {
     const MCExpr *offset =
-        MakeStartMinusEndExpr(context, cieStart, *fdeStart, 0);
+        MakeEndMinusStartExpr(context, cieStart, *fdeStart, 0);
     emitAbsValue(Streamer, offset, OffsetSize);
   } else if (!asmInfo->doesDwarfUseRelocationsAcrossSections()) {
     const MCExpr *offset =
-        MakeStartMinusEndExpr(context, SectionStart, cieStart, 0);
+        MakeEndMinusStartExpr(context, SectionStart, cieStart, 0);
     emitAbsValue(Streamer, offset, OffsetSize);
   } else {
     Streamer.emitSymbolValue(&cieStart, OffsetSize,
                              asmInfo->needsDwarfSectionOffsetDirective());
   }
 
   // PC Begin
   unsigned PCEncoding =
       IsEH ? MOFI->getFDEEncoding() : (unsigned)dwarf::DW_EH_PE_absptr;
   unsigned PCSize = getSizeForEncoding(Streamer, PCEncoding);
   emitFDESymbol(Streamer, *frame.Begin, PCEncoding, IsEH);
 
   // PC Range
   const MCExpr *Range =
-      MakeStartMinusEndExpr(context, *frame.Begin, *frame.End, 0);
+      MakeEndMinusStartExpr(context, *frame.Begin, *frame.End, 0);
   emitAbsValue(Streamer, Range, PCSize);
 
   if (IsEH) {
     // Augmentation Data Length
     unsigned augmentationLength = 0;
 
     if (frame.Lsda)
       augmentationLength += getSizeForEncoding(Streamer, frame.LsdaEncoding);