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

1 files changed, 129 insertions, 0 deletions

diff --git a/lib/Target/DarwinTargetAsmInfo.cpp b/lib/Target/DarwinTargetAsmInfo.cpp
new file mode 100644
index 0000000000..67959a7f9d
--- /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<GlobalVariable>(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<GlobalVariable>(GV)));
+   case SectionKind::RODataMergeConst:
+    return (isWeak ?
+            ConstDataCoalSection:
+            MergeableConstSection(cast<GlobalVariable>(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<GlobalVariable>(GV)->getInitializer();
+  const Type *Type = cast<ConstantArray>(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<GlobalVariable>(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<X86Subtarget>().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 "";
+}