From 745e864eab681bc24ada2032b31d3b411c123763 Mon Sep 17 00:00:00 2001 From: Anton Korobeynikov Date: Sat, 19 Jul 2008 13:14:46 +0000 Subject: [PATCH] Add TargetAsmInfo stuff for all darwin-based targets git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@53787 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Target/DarwinTargetAsmInfo.h | 43 ++++++++ lib/Target/DarwinTargetAsmInfo.cpp | 129 ++++++++++++++++++++++ 2 files changed, 172 insertions(+) create mode 100644 include/llvm/Target/DarwinTargetAsmInfo.h create mode 100644 lib/Target/DarwinTargetAsmInfo.cpp diff --git a/include/llvm/Target/DarwinTargetAsmInfo.h b/include/llvm/Target/DarwinTargetAsmInfo.h new file mode 100644 index 00000000000..769273d6185 --- /dev/null +++ b/include/llvm/Target/DarwinTargetAsmInfo.h @@ -0,0 +1,43 @@ +//===---- DarwinTargetAsmInfo.h - Darwin asm properties ---------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines target asm properties related what form asm statements +// should take in general on Darwin-based targets +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_ELF_TARGET_ASM_INFO_H +#define LLVM_ELF_TARGET_ASM_INFO_H + +#include "llvm/Target/TargetAsmInfo.h" +#include "llvm/Target/TargetMachine.h" + +namespace llvm { + class GlobalValue; + class GlobalVariable; + + class DarwinTargetAsmInfo: public TargetAsmInfo { + const Section* TextCoalSection; + const Section* ConstDataCoalSection; + const Section* ConstDataSection; + const Section* DataCoalSection; + + explicit DarwinTargetAsmInfo(const TargetMachine &TM); + virtual const Section* SelectSectionForGlobal(const GlobalValue *GV) const; + virtual std::string UniqueSectionForGlobal(const GlobalValue* GV, + SectionKind::Kind kind) const; + const Section* MergeableConstSection(const GlobalVariable *GV) const; + const Section* MergeableStringSection(const GlobalVariable *GV) const; + protected: + const TargetMachine* ETM; + }; +} + + +#endif // LLVM_ELF_TARGET_ASM_INFO_H diff --git a/lib/Target/DarwinTargetAsmInfo.cpp b/lib/Target/DarwinTargetAsmInfo.cpp new file mode 100644 index 00000000000..67959a7f9db --- /dev/null +++ b/lib/Target/DarwinTargetAsmInfo.cpp @@ -0,0 +1,129 @@ +//===-- DarwinTargetAsmInfo.cpp - Darwin asm properties ---------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines target asm properties related what form asm statements +// should take in general on Darwin-based targets +// +//===----------------------------------------------------------------------===// + +#include "llvm/Constants.h" +#include "llvm/DerivedTypes.h" +#include "llvm/Function.h" +#include "llvm/GlobalVariable.h" +#include "llvm/ADT/StringExtras.h" +#include "llvm/Target/DarwinTargetAsmInfo.h" +#include "llvm/Target/TargetMachine.h" +#include "llvm/Target/TargetData.h" + +using namespace llvm; + +DarwinTargetAsmInfo::DarwinTargetAsmInfo(const TargetMachine &TM) { + ETM = &TM; + + CStringSection_ = getUnnamedSection("\t.cstring", + SectionFlags::Mergeable | SectionFlags::Strings); + FourByteConstantSection_ = getUnnamedSection("\t.literal4\n", + SectionFlags::Mergeable); + EightByteConstantSection_ = getUnnamedSection("\t.literal8\n", + SectionFlags::Mergeable); + // FIXME: Check for 64 bit + SixteenByteConstantSection_ = getUnnamedSection("\t.literal16\n", + SectionFlags::Mergeable); + ReadOnlySection_ = getUnnamedSection("\t.const\n", SectionFlags::None); + + // FIXME: These should be named sections, really. + TextCoalSection = + getUnnamedSection(".section __TEXT,__textcoal_nt,coalesced,pure_instructions", + SectionFlags::Code); + ConstDataCoalSection = + getUnnamedSection(".section __DATA,__const_coal,coalesced", + SectionFlags::None); + ConstDataSection = getUnnamedSection(".const_data", SectionFlags::None); + DataCoalSection = getUnnamedSection(".section __DATA,__datacoal_nt,coalesced", + SectionFlags::Writeable); +} + +const Section* +DarwinTargetAsmInfo::SelectSectionForGlobal(const GlobalValue *GV) const { + SectionKind::Kind Kind = SectionKindForGlobal(GV); + bool isWeak = GV->isWeakForLinker(); + bool isNonStatic = (ETM->getRelocationModel() != Reloc::Static); + + switch (Kind) { + case SectionKind::Text: + if (isWeak) + return TextCoalSection; + else + return getTextSection_(); + case SectionKind::Data: + case SectionKind::ThreadData: + case SectionKind::BSS: + case SectionKind::ThreadBSS: + if (cast(GV)->isConstant()) + return (isWeak ? ConstDataCoalSection : ConstDataSection); + else + return (isWeak ? DataCoalSection : getDataSection_()); + case SectionKind::ROData: + return (isWeak ? ConstDataCoalSection : + (isNonStatic ? ConstDataSection : getReadOnlySection_())); + case SectionKind::RODataMergeStr: + return (isWeak ? + ConstDataCoalSection : + MergeableStringSection(cast(GV))); + case SectionKind::RODataMergeConst: + return (isWeak ? + ConstDataCoalSection: + MergeableConstSection(cast(GV))); + default: + assert(0 && "Unsuported section kind for global"); + } + + // FIXME: Do we have any extra special weird cases? +} + +const Section* +DarwinTargetAsmInfo::MergeableStringSection(const GlobalVariable *GV) const { + const TargetData *TD = ETM->getTargetData(); + Constant *C = cast(GV)->getInitializer(); + const Type *Type = cast(C)->getType()->getElementType(); + + unsigned Size = TD->getABITypeSize(Type); + if (Size) { + const TargetData *TD = ETM->getTargetData(); + unsigned Align = TD->getPreferredAlignment(GV); + if (Align <= 32) + return getCStringSection_(); + } + + return getReadOnlySection_(); +} + +const Section* +DarwinTargetAsmInfo::MergeableConstSection(const GlobalVariable *GV) const { + const TargetData *TD = ETM->getTargetData(); + Constant *C = cast(GV)->getInitializer(); + + unsigned Size = TD->getABITypeSize(C->getType()); + if (Size == 4) + return FourByteConstantSection_; + else if (Size == 8) + return EightByteConstantSection_; + // FIXME: 64 bit + /*else if (Size == 16 && ETM->getSubtarget().is64Bit()) + return SixteenByteConstantSection_;*/ + + return getReadOnlySection_(); +} + +std::string +DarwinTargetAsmInfo::UniqueSectionForGlobal(const GlobalValue* GV, + SectionKind::Kind kind) const { + assert(0 && "Darwin does not use unique sections"); + return ""; +}