/// is "l" on Darwin, currently used for some ObjC metadata.
const char *LinkerPrivateGlobalPrefix; // Defaults to ""
- /// PersonalityPrefix/Suffix - If these are nonempty, these strings will
- /// enclose any personality function in the common frame section.
- ///
- const char *PersonalityPrefix; // Defaults to ""
- const char *PersonalitySuffix; // Defaults to ""
-
- /// NeedsIndirectEncoding - If set, we need to set the indirect encoding bit
- /// for EH in Dwarf.
- ///
- bool NeedsIndirectEncoding; // Defaults to false
-
/// InlineAsmStart/End - If these are nonempty, they contain a directive to
/// emit before and after an inline assembly statement.
const char *InlineAsmStart; // Defaults to "#APP\n"
const char *getLinkerPrivateGlobalPrefix() const {
return LinkerPrivateGlobalPrefix;
}
- const char *getPersonalityPrefix() const {
- return PersonalityPrefix;
- }
- const char *getPersonalitySuffix() const {
- return PersonalitySuffix;
- }
- bool getNeedsIndirectEncoding() const {
- return NeedsIndirectEncoding;
- }
const char *getInlineAsmStart() const {
return InlineAsmStart;
}
class StringRef;
class TargetMachine;
class MCAsmInfo;
+ class MCExpr;
class TargetLoweringObjectFile {
MCContext *Ctx;
return 0;
}
+ /// getSymbolForDwarfGlobalReference - Return an MCExpr to use for a
+ /// pc-relative reference to the specified global variable from exception
+ /// handling information. In addition to the symbol, this returns
+ /// by-reference:
+ ///
+ /// IsIndirect - True if the returned symbol is actually a stub that contains
+ /// the address of the symbol, false if the symbol is the global itself.
+ ///
+ /// IsPCRel - True if the symbol reference is already pc-relative, false if
+ /// the caller needs to subtract off the address of the reference from the
+ /// symbol.
+ ///
+ virtual const MCExpr *
+ getSymbolForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
+ bool &IsIndirect, bool &IsPCRel) const;
+
protected:
virtual const MCSection *
SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
const MCSection *getNonLazySymbolPointerSection() const {
return NonLazySymbolPointerSection;
}
+
+ /// getSymbolForDwarfGlobalReference - The mach-o version of this method
+ /// defaults to returning a stub reference.
+ virtual const MCExpr *
+ getSymbolForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
+ bool &IsIndirect, bool &IsPCRel) const;
};
#include "llvm/CodeGen/MachineFrameInfo.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/MachineLocation.h"
+#include "llvm/MC/MCAsmInfo.h"
+#include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCExpr.h"
#include "llvm/MC/MCSection.h"
#include "llvm/MC/MCStreamer.h"
-#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetFrameInfo.h"
#include "llvm/Target/TargetLoweringObjectFile.h"
/// EmitCIE - Emit a Common Information Entry (CIE). This holds information that
/// is shared among many Frame Description Entries. There is at least one CIE
/// in every non-empty .debug_frame section.
-void DwarfException::EmitCIE(const Function *Personality, unsigned Index) {
+void DwarfException::EmitCIE(const Function *PersonalityFn, unsigned Index) {
// Size and sign of stack growth.
int stackGrowth =
Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
TargetFrameInfo::StackGrowsUp ?
TD->getPointerSize() : -TD->getPointerSize();
+ const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
+
// Begin eh frame section.
- Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getEHFrameSection());
+ Asm->OutStreamer.SwitchSection(TLOF.getEHFrameSection());
if (MAI->is_EHSymbolPrivate())
O << MAI->getPrivateGlobalPrefix();
-
O << "EH_frame" << Index << ":\n";
+
EmitLabel("section_eh_frame", Index);
// Define base labels.
Asm->EOL("CIE Version");
// The personality presence indicates that language specific information will
- // show up in the eh frame.
-
- // FIXME: Don't hardcode these encodings.
+ // show up in the eh frame. Find out how we are supposed to lower the
+ // personality function reference:
+ const MCExpr *PersonalityRef = 0;
+ bool IsPersonalityIndirect = false, IsPersonalityPCRel = false;
+ if (PersonalityFn) {
+ // FIXME: HANDLE STATIC CODEGEN MODEL HERE.
+
+ // In non-static mode, ask the object file how to represent this reference.
+ PersonalityRef =
+ TLOF.getSymbolForDwarfGlobalReference(PersonalityFn, Asm->Mang,
+ IsPersonalityIndirect,
+ IsPersonalityPCRel);
+ }
+
unsigned PerEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
- if (Personality && MAI->getNeedsIndirectEncoding())
+ if (IsPersonalityIndirect)
PerEncoding |= dwarf::DW_EH_PE_indirect;
unsigned LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
unsigned FDEEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
unsigned AugmentationSize = 0;
char *APtr = Augmentation + 1;
- if (Personality) {
+ if (PersonalityRef) {
// There is a personality function.
*APtr++ = 'P';
AugmentationSize += 1 + SizeOfEncodedValue(PerEncoding);
Asm->EOL("Personality", PerEncoding);
// If there is a personality, we need to indicate the function's location.
- if (Personality) {
- O << MAI->getData32bitsDirective();
-
- O << MAI->getPersonalityPrefix();
- O << Asm->Mang->getMangledName(Personality);
- O << MAI->getPersonalitySuffix();
+ if (PersonalityRef) {
+ // If the reference to the personality function symbol is not already
+ // pc-relative, then we need to subtract our current address from it. Do
+ // this by emitting a label and subtracting it from the expression we
+ // already have. This is equivalent to emitting "foo - .", but we have to
+ // emit the label for "." directly.
+ if (!IsPersonalityPCRel) {
+ SmallString<64> Name;
+ raw_svector_ostream(Name) << MAI->getPrivateGlobalPrefix()
+ << "personalityref_addr" << Asm->getFunctionNumber() << "_" << Index;
+ MCSymbol *DotSym = Asm->OutContext.GetOrCreateSymbol(Name.str());
+ Asm->OutStreamer.EmitLabel(DotSym);
+
+ PersonalityRef =
+ MCBinaryExpr::CreateSub(PersonalityRef,
+ MCSymbolRefExpr::Create(DotSym,Asm->OutContext),
+ Asm->OutContext);
+ }
- if (strcmp(MAI->getPersonalitySuffix(), "+4@GOTPCREL"))
- O << "-" << MAI->getPCSymbol();
+ O << MAI->getData32bitsDirective();
+ PersonalityRef->print(O, MAI);
Asm->EOL("Personality");
Asm->EmitInt8(LSDAEncoding);
// On Darwin the linker honors the alignment of eh_frame, which means it must
// be 8-byte on 64-bit targets to match what gcc does. Otherwise you get
// holes which confuse readers of eh_frame.
- Asm->EmitAlignment(TD->getPointerSize() == sizeof(int32_t) ? 2 : 3,
- 0, 0, false);
+ Asm->EmitAlignment(TD->getPointerSize() == 4 ? 2 : 3, 0, 0, false);
EmitLabel("eh_frame_common_end", Index);
Asm->EOL();
GlobalPrefix = "";
PrivateGlobalPrefix = ".";
LinkerPrivateGlobalPrefix = "";
- PersonalityPrefix = "";
- PersonalitySuffix = "";
- NeedsIndirectEncoding = false;
InlineAsmStart = "APP";
InlineAsmEnd = "NO_APP";
AssemblerDialect = 0;
// Syntax:
GlobalPrefix = "_";
PrivateGlobalPrefix = "L";
- LinkerPrivateGlobalPrefix = "l"; // Marker for some ObjC metadata
+ LinkerPrivateGlobalPrefix = "l";
NeedsSet = true;
- NeedsIndirectEncoding = true;
AllowQuotesInName = true;
HasSingleParameterDotFile = false;
if (!is64Bit)
Data64bitsDirective = 0; // We can't emit a 64-bit unit in PPC32 mode.
AssemblerDialect = 1; // New-Style mnemonics.
-
- PersonalityPrefix = "L";
- PersonalitySuffix = "$non_lazy_ptr";
}
PPCLinuxMCAsmInfo::PPCLinuxMCAsmInfo(bool is64Bit) {
#include "llvm/Function.h"
#include "llvm/GlobalVariable.h"
#include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCExpr.h"
#include "llvm/MC/MCSectionMachO.h"
#include "llvm/MC/MCSectionELF.h"
#include "llvm/Target/TargetData.h"
return DataSection;
}
+/// getSymbolForDwarfGlobalReference - Return an MCExpr to use for a
+/// pc-relative reference to the specified global variable from exception
+/// handling information. In addition to the symbol, this returns
+/// by-reference:
+///
+/// IsIndirect - True if the returned symbol is actually a stub that contains
+/// the address of the symbol, false if the symbol is the global itself.
+///
+/// IsPCRel - True if the symbol reference is already pc-relative, false if
+/// the caller needs to subtract off the address of the reference from the
+/// symbol.
+///
+const MCExpr *TargetLoweringObjectFile::
+getSymbolForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
+ bool &IsIndirect, bool &IsPCRel) const {
+ // The generic implementation of this just returns a direct reference to the
+ // symbol.
+ IsIndirect = false;
+ IsPCRel = false;
+
+ SmallString<128> Name;
+ Mang->getNameWithPrefix(Name, GV, false);
+ return MCSymbolRefExpr::Create(Name.str(), getContext());
+}
//===----------------------------------------------------------------------===//
return true;
}
+const MCExpr *TargetLoweringObjectFileMachO::
+getSymbolForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
+ bool &IsIndirect, bool &IsPCRel) const {
+ // The mach-o version of this method defaults to returning a stub reference.
+ IsIndirect = true;
+ IsPCRel = false;
+
+ SmallString<128> Name;
+ Mang->getNameWithPrefix(Name, GV, true);
+ Name += "$non_lazy_ptr";
+ return MCSymbolRefExpr::Create(Name.str(), getContext());
+}
+
//===----------------------------------------------------------------------===//
// COFF
return getDataSection();
}
+
#include "X86InstrBuilder.h"
#include "X86ISelLowering.h"
#include "X86TargetMachine.h"
+#include "X86TargetObjectFile.h"
#include "llvm/CallingConv.h"
#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h"
-#include "llvm/Target/TargetLoweringObjectFile.h"
#include "llvm/Target/TargetOptions.h"
#include "llvm/ADT/SmallSet.h"
#include "llvm/ADT/StringExtras.h"
switch (TM.getSubtarget<X86Subtarget>().TargetType) {
default: llvm_unreachable("unknown subtarget type");
case X86Subtarget::isDarwin:
+ if (TM.getSubtarget<X86Subtarget>().is64Bit())
+ return new X8664_MachoTargetObjectFile();
return new TargetLoweringObjectFileMachO();
case X86Subtarget::isELF:
return new TargetLoweringObjectFileELF();
// Leopard and above support aligned common symbols.
COMMDirectiveTakesAlignment = Triple.getDarwinMajorNumber() >= 9;
- if (is64Bit) {
- PersonalityPrefix = "";
- PersonalitySuffix = "+4@GOTPCREL";
- } else {
- PersonalityPrefix = "L";
- PersonalitySuffix = "$non_lazy_ptr";
- }
-
CommentString = "##";
PCSymbol = ".";
--- /dev/null
+//===-- llvm/Target/X86/X86TargetObjectFile.cpp - X86 Object Info ---------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "X86TargetObjectFile.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/Support/Mangler.h"
+#include "llvm/MC/MCExpr.h"
+using namespace llvm;
+
+const MCExpr *X8664_MachoTargetObjectFile::
+getSymbolForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
+ bool &IsIndirect, bool &IsPCRel) const {
+
+ // On Darwin/X86-64, we can reference dwarf symbols with foo@GOTPCREL+4, which
+ // is an indirect pc-relative reference.
+ IsIndirect = true;
+ IsPCRel = true;
+
+ SmallString<128> Name;
+ Mang->getNameWithPrefix(Name, GV, false);
+ Name += "@GOTPCREL";
+ const MCExpr *Res =
+ MCSymbolRefExpr::Create(Name.str(), getContext());
+ const MCExpr *Four = MCConstantExpr::Create(4, getContext());
+ return MCBinaryExpr::CreateAdd(Res, Four, getContext());
+}
+
--- /dev/null
+//===-- llvm/Target/X86/X86TargetObjectFile.h - X86 Object Info -*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TARGET_X86_TARGETOBJECTFILE_H
+#define LLVM_TARGET_X86_TARGETOBJECTFILE_H
+
+#include "llvm/Target/TargetLoweringObjectFile.h"
+
+namespace llvm {
+
+ /// X8664_MachoTargetObjectFile - This TLOF implementation is used for
+ /// Darwin/x86-64.
+ class X8664_MachoTargetObjectFile : public TargetLoweringObjectFileMachO {
+ public:
+
+ virtual const MCExpr *
+ getSymbolForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
+ bool &IsIndirect, bool &IsPCRel) const;
+ };
+} // end namespace llvm
+
+#endif
projects / oota-llvm.git / commitdiff