TargetLoweringObjectFile.cpp revision 36b56886974eae4f9c5ebc96befd3e7bfe5de338 
1//===-- llvm/Target/TargetLoweringObjectFile.cpp - Object File Info -------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements classes used to handle lowerings specific to common
11// object file formats.
12//
13//===----------------------------------------------------------------------===//
14
15#include "llvm/Target/TargetLoweringObjectFile.h"
16#include "llvm/IR/Constants.h"
17#include "llvm/IR/DataLayout.h"
18#include "llvm/IR/DerivedTypes.h"
19#include "llvm/IR/Function.h"
20#include "llvm/IR/GlobalVariable.h"
21#include "llvm/IR/Mangler.h"
22#include "llvm/MC/MCAsmInfo.h"
23#include "llvm/MC/MCContext.h"
24#include "llvm/MC/MCExpr.h"
25#include "llvm/MC/MCStreamer.h"
26#include "llvm/MC/MCSymbol.h"
27#include "llvm/Support/Dwarf.h"
28#include "llvm/Support/ErrorHandling.h"
29#include "llvm/Support/raw_ostream.h"
30#include "llvm/Target/TargetLowering.h"
31#include "llvm/Target/TargetMachine.h"
32#include "llvm/Target/TargetOptions.h"
33using namespace llvm;
34
35//===----------------------------------------------------------------------===//
36//                              Generic Code
37//===----------------------------------------------------------------------===//
38
39/// Initialize - this method must be called before any actual lowering is
40/// done.  This specifies the current context for codegen, and gives the
41/// lowering implementations a chance to set up their default sections.
42void TargetLoweringObjectFile::Initialize(MCContext &ctx,
43                                          const TargetMachine &TM) {
44  Ctx = &ctx;
45  DL = TM.getDataLayout();
46  InitMCObjectFileInfo(TM.getTargetTriple(),
47                       TM.getRelocationModel(), TM.getCodeModel(), *Ctx);
48}
49
50TargetLoweringObjectFile::~TargetLoweringObjectFile() {
51}
52
53static bool isSuitableForBSS(const GlobalVariable *GV, bool NoZerosInBSS) {
54  const Constant *C = GV->getInitializer();
55
56  // Must have zero initializer.
57  if (!C->isNullValue())
58    return false;
59
60  // Leave constant zeros in readonly constant sections, so they can be shared.
61  if (GV->isConstant())
62    return false;
63
64  // If the global has an explicit section specified, don't put it in BSS.
65  if (!GV->getSection().empty())
66    return false;
67
68  // If -nozero-initialized-in-bss is specified, don't ever use BSS.
69  if (NoZerosInBSS)
70    return false;
71
72  // Otherwise, put it in BSS!
73  return true;
74}
75
76/// IsNullTerminatedString - Return true if the specified constant (which is
77/// known to have a type that is an array of 1/2/4 byte elements) ends with a
78/// nul value and contains no other nuls in it.  Note that this is more general
79/// than ConstantDataSequential::isString because we allow 2 & 4 byte strings.
80static bool IsNullTerminatedString(const Constant *C) {
81  // First check: is we have constant array terminated with zero
82  if (const ConstantDataSequential *CDS = dyn_cast<ConstantDataSequential>(C)) {
83    unsigned NumElts = CDS->getNumElements();
84    assert(NumElts != 0 && "Can't have an empty CDS");
85
86    if (CDS->getElementAsInteger(NumElts-1) != 0)
87      return false; // Not null terminated.
88
89    // Verify that the null doesn't occur anywhere else in the string.
90    for (unsigned i = 0; i != NumElts-1; ++i)
91      if (CDS->getElementAsInteger(i) == 0)
92        return false;
93    return true;
94  }
95
96  // Another possibility: [1 x i8] zeroinitializer
97  if (isa<ConstantAggregateZero>(C))
98    return cast<ArrayType>(C->getType())->getNumElements() == 1;
99
100  return false;
101}
102
103MCSymbol *TargetLoweringObjectFile::getSymbolWithGlobalValueBase(
104    const GlobalValue *GV, StringRef Suffix, Mangler &Mang,
105    const TargetMachine &TM) const {
106  assert(!Suffix.empty());
107
108  SmallString<60> NameStr;
109  NameStr += DL->getPrivateGlobalPrefix();
110  TM.getNameWithPrefix(NameStr, GV, Mang);
111  NameStr.append(Suffix.begin(), Suffix.end());
112  return Ctx->GetOrCreateSymbol(NameStr.str());
113}
114
115MCSymbol *TargetLoweringObjectFile::getCFIPersonalitySymbol(
116    const GlobalValue *GV, Mangler &Mang, const TargetMachine &TM,
117    MachineModuleInfo *MMI) const {
118  return TM.getSymbol(GV, Mang);
119}
120
121void TargetLoweringObjectFile::emitPersonalityValue(MCStreamer &Streamer,
122                                                    const TargetMachine &TM,
123                                                    const MCSymbol *Sym) const {
124}
125
126
127/// getKindForGlobal - This is a top-level target-independent classifier for
128/// a global variable.  Given an global variable and information from TM, it
129/// classifies the global in a variety of ways that make various target
130/// implementations simpler.  The target implementation is free to ignore this
131/// extra info of course.
132SectionKind TargetLoweringObjectFile::getKindForGlobal(const GlobalValue *GV,
133                                                       const TargetMachine &TM){
134  assert(!GV->isDeclaration() && !GV->hasAvailableExternallyLinkage() &&
135         "Can only be used for global definitions");
136
137  Reloc::Model ReloModel = TM.getRelocationModel();
138
139  // Early exit - functions should be always in text sections.
140  const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV);
141  if (GVar == 0)
142    return SectionKind::getText();
143
144  // Handle thread-local data first.
145  if (GVar->isThreadLocal()) {
146    if (isSuitableForBSS(GVar, TM.Options.NoZerosInBSS))
147      return SectionKind::getThreadBSS();
148    return SectionKind::getThreadData();
149  }
150
151  // Variables with common linkage always get classified as common.
152  if (GVar->hasCommonLinkage())
153    return SectionKind::getCommon();
154
155  // Variable can be easily put to BSS section.
156  if (isSuitableForBSS(GVar, TM.Options.NoZerosInBSS)) {
157    if (GVar->hasLocalLinkage())
158      return SectionKind::getBSSLocal();
159    else if (GVar->hasExternalLinkage())
160      return SectionKind::getBSSExtern();
161    return SectionKind::getBSS();
162  }
163
164  const Constant *C = GVar->getInitializer();
165
166  // If the global is marked constant, we can put it into a mergable section,
167  // a mergable string section, or general .data if it contains relocations.
168  if (GVar->isConstant()) {
169    // If the initializer for the global contains something that requires a
170    // relocation, then we may have to drop this into a writable data section
171    // even though it is marked const.
172    switch (C->getRelocationInfo()) {
173    case Constant::NoRelocation:
174      // If the global is required to have a unique address, it can't be put
175      // into a mergable section: just drop it into the general read-only
176      // section instead.
177      if (!GVar->hasUnnamedAddr())
178        return SectionKind::getReadOnly();
179
180      // If initializer is a null-terminated string, put it in a "cstring"
181      // section of the right width.
182      if (ArrayType *ATy = dyn_cast<ArrayType>(C->getType())) {
183        if (IntegerType *ITy =
184              dyn_cast<IntegerType>(ATy->getElementType())) {
185          if ((ITy->getBitWidth() == 8 || ITy->getBitWidth() == 16 ||
186               ITy->getBitWidth() == 32) &&
187              IsNullTerminatedString(C)) {
188            if (ITy->getBitWidth() == 8)
189              return SectionKind::getMergeable1ByteCString();
190            if (ITy->getBitWidth() == 16)
191              return SectionKind::getMergeable2ByteCString();
192
193            assert(ITy->getBitWidth() == 32 && "Unknown width");
194            return SectionKind::getMergeable4ByteCString();
195          }
196        }
197      }
198
199      // Otherwise, just drop it into a mergable constant section.  If we have
200      // a section for this size, use it, otherwise use the arbitrary sized
201      // mergable section.
202      switch (TM.getDataLayout()->getTypeAllocSize(C->getType())) {
203      case 4:  return SectionKind::getMergeableConst4();
204      case 8:  return SectionKind::getMergeableConst8();
205      case 16: return SectionKind::getMergeableConst16();
206      default: return SectionKind::getMergeableConst();
207      }
208
209    case Constant::LocalRelocation:
210      // In static relocation model, the linker will resolve all addresses, so
211      // the relocation entries will actually be constants by the time the app
212      // starts up.  However, we can't put this into a mergable section, because
213      // the linker doesn't take relocations into consideration when it tries to
214      // merge entries in the section.
215      if (ReloModel == Reloc::Static)
216        return SectionKind::getReadOnly();
217
218      // Otherwise, the dynamic linker needs to fix it up, put it in the
219      // writable data.rel.local section.
220      return SectionKind::getReadOnlyWithRelLocal();
221
222    case Constant::GlobalRelocations:
223      // In static relocation model, the linker will resolve all addresses, so
224      // the relocation entries will actually be constants by the time the app
225      // starts up.  However, we can't put this into a mergable section, because
226      // the linker doesn't take relocations into consideration when it tries to
227      // merge entries in the section.
228      if (ReloModel == Reloc::Static)
229        return SectionKind::getReadOnly();
230
231      // Otherwise, the dynamic linker needs to fix it up, put it in the
232      // writable data.rel section.
233      return SectionKind::getReadOnlyWithRel();
234    }
235  }
236
237  // Okay, this isn't a constant.  If the initializer for the global is going
238  // to require a runtime relocation by the dynamic linker, put it into a more
239  // specific section to improve startup time of the app.  This coalesces these
240  // globals together onto fewer pages, improving the locality of the dynamic
241  // linker.
242  if (ReloModel == Reloc::Static)
243    return SectionKind::getDataNoRel();
244
245  switch (C->getRelocationInfo()) {
246  case Constant::NoRelocation:
247    return SectionKind::getDataNoRel();
248  case Constant::LocalRelocation:
249    return SectionKind::getDataRelLocal();
250  case Constant::GlobalRelocations:
251    return SectionKind::getDataRel();
252  }
253  llvm_unreachable("Invalid relocation");
254}
255
256/// SectionForGlobal - This method computes the appropriate section to emit
257/// the specified global variable or function definition.  This should not
258/// be passed external (or available externally) globals.
259const MCSection *TargetLoweringObjectFile::
260SectionForGlobal(const GlobalValue *GV, SectionKind Kind, Mangler &Mang,
261                 const TargetMachine &TM) const {
262  // Select section name.
263  if (GV->hasSection())
264    return getExplicitSectionGlobal(GV, Kind, Mang, TM);
265
266
267  // Use default section depending on the 'type' of global
268  return SelectSectionForGlobal(GV, Kind, Mang, TM);
269}
270
271bool TargetLoweringObjectFile::isSectionAtomizableBySymbols(
272    const MCSection &Section) const {
273  return false;
274}
275
276// Lame default implementation. Calculate the section name for global.
277const MCSection *
278TargetLoweringObjectFile::SelectSectionForGlobal(const GlobalValue *GV,
279                                                 SectionKind Kind,
280                                                 Mangler &Mang,
281                                                 const TargetMachine &TM) const{
282  assert(!Kind.isThreadLocal() && "Doesn't support TLS");
283
284  if (Kind.isText())
285    return getTextSection();
286
287  if (Kind.isBSS() && BSSSection != 0)
288    return BSSSection;
289
290  if (Kind.isReadOnly() && ReadOnlySection != 0)
291    return ReadOnlySection;
292
293  return getDataSection();
294}
295
296/// getSectionForConstant - Given a mergable constant with the
297/// specified size and relocation information, return a section that it
298/// should be placed in.
299const MCSection *
300TargetLoweringObjectFile::getSectionForConstant(SectionKind Kind) const {
301  if (Kind.isReadOnly() && ReadOnlySection != 0)
302    return ReadOnlySection;
303
304  return DataSection;
305}
306
307/// getTTypeGlobalReference - Return an MCExpr to use for a
308/// reference to the specified global variable from exception
309/// handling information.
310const MCExpr *TargetLoweringObjectFile::getTTypeGlobalReference(
311    const GlobalValue *GV, unsigned Encoding, Mangler &Mang,
312    const TargetMachine &TM, MachineModuleInfo *MMI,
313    MCStreamer &Streamer) const {
314  const MCSymbolRefExpr *Ref =
315      MCSymbolRefExpr::Create(TM.getSymbol(GV, Mang), getContext());
316
317  return getTTypeReference(Ref, Encoding, Streamer);
318}
319
320const MCExpr *TargetLoweringObjectFile::
321getTTypeReference(const MCSymbolRefExpr *Sym, unsigned Encoding,
322                  MCStreamer &Streamer) const {
323  switch (Encoding & 0x70) {
324  default:
325    report_fatal_error("We do not support this DWARF encoding yet!");
326  case dwarf::DW_EH_PE_absptr:
327    // Do nothing special
328    return Sym;
329  case dwarf::DW_EH_PE_pcrel: {
330    // Emit a label to the streamer for the current position.  This gives us
331    // .-foo addressing.
332    MCSymbol *PCSym = getContext().CreateTempSymbol();
333    Streamer.EmitLabel(PCSym);
334    const MCExpr *PC = MCSymbolRefExpr::Create(PCSym, getContext());
335    return MCBinaryExpr::CreateSub(Sym, PC, getContext());
336  }
337  }
338}
339
340const MCExpr *TargetLoweringObjectFile::getDebugThreadLocalSymbol(const MCSymbol *Sym) const {
341  // FIXME: It's not clear what, if any, default this should have - perhaps a
342  // null return could mean 'no location' & we should just do that here.
343  return MCSymbolRefExpr::Create(Sym, *Ctx);
344}
345