updated .ARM.attributes work

lib/Target/ARM/ARMAsmPrinter.cpp

 //===-- ARMAsmPrinter.cpp - Print machine code to an ARM .s file ----------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains a printer that converts from our internal representation
@@ skipping 20 matching lines @@
 #include "llvm/CodeGen/MachineModuleInfoImpls.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/MachineJumpTableInfo.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
+#include "llvm/MC/MCAssembler.h"
 #include "llvm/Target/Mangler.h"
 #include "llvm/Target/TargetData.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetOptions.h"
 #include "llvm/Target/TargetRegistry.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
+#include "llvm/Support/ELF.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cctype>
 using namespace llvm;
 
 namespace llvm {
   namespace ARM {
     enum DW_ISA {
       DW_ISA_ARM_thumb = 1,
       DW_ISA_ARM_arm = 2
@@ skipping 11 matching lines @@
     /// AFI - Keep a pointer to ARMFunctionInfo for the current
     /// MachineFunction.
     ARMFunctionInfo *AFI;
 
     /// MCP - Keep a pointer to constantpool entries of the current
     /// MachineFunction.
     const MachineConstantPool *MCP;
 
   public:
     explicit ARMAsmPrinter(TargetMachine &TM, MCStreamer &Streamer)
-      : AsmPrinter(TM, Streamer), AFI(NULL), MCP(NULL) {
+      : AsmPrinter(TM, Streamer), AFI(NULL), MCP(NULL),
+        headFragment(NULL), currFileFragment(NULL),
+        currSectionFragment(NULL), currSymbolFragment(NULL) {
       Subtarget = &TM.getSubtarget<ARMSubtarget>();
     }
 
     virtual const char *getPassName() const {
       return "ARM Assembly Printer";
     }
 
     void printOperand(const MachineInstr *MI, int OpNum, raw_ostream &O,
                       const char *Modifier = 0);
 
     virtual bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNum,
                                  unsigned AsmVariant, const char *ExtraCode,
                                  raw_ostream &O);
     virtual bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNum,
                                        unsigned AsmVariant,
                                        const char *ExtraCode, raw_ostream &O);
 
     void EmitJumpTable(const MachineInstr *MI);
     void EmitJump2Table(const MachineInstr *MI);
     virtual void EmitInstruction(const MachineInstr *MI);
     bool runOnMachineFunction(MachineFunction &F);
 
     virtual void EmitConstantPool() {} // we emit constant pools customly!
     virtual void EmitFunctionEntryLabel();
     void EmitStartOfAsmFile(Module &M);
     void EmitEndOfAsmFile(Module &M);
 
   private:
+
     // Helpers for EmitStartOfAsmFile() and EmitEndOfAsmFile()
+    // Helper for ELF .s/.o only
     void emitAttributes();
     void emitTextAttribute(ARMBuildAttrs::SpecialAttr attr, StringRef v);
     void emitAttribute(ARMBuildAttrs::AttrType attr, int v);
 
-    // Helper for ELF .o only
     void emitARMAttributeSection();
 
+    // Slots for keeping state for above member funcs.
+    MCDataFragment *headFragment;
+
+    // Fixme: do we ever need more than one of each?
+    MCDataFragment *currFileFragment,
+      *currSectionFragment, *currSymbolFragment;
+
+    // Section-global offset counters
+    int currOffset;
+    int attrDataStartOffset;
+
+    // Helper routine for the emit*() functions above
+    MCDataFragment *addAttrSubsec(MCSectionData *AttrSecData,
+                                  ARMBuildAttrs::AttrType attr,
+                                  int SecOrSym=0);
+
+    int fixupAttrSizes();
+    int fixupAttrSize(MCDataFragment *F, int secLenOffset, int lenAdjust);
   public:
     void PrintDebugValueComment(const MachineInstr *MI, raw_ostream &OS);
 
     MachineLocation getDebugValueLocation(const MachineInstr *MI) const {
       MachineLocation Location;
       assert (MI->getNumOperands() == 4 && "Invalid no. of machine operands!");
       // Frame address.  Currently handles register +- offset only.
       if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm())
         Location.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
       else {
@@ skipping 394 matching lines @@
   // 8-bytes alignment stuff.
   emitAttribute(ARMBuildAttrs::ABI_align8_needed, 1);
   emitAttribute(ARMBuildAttrs::ABI_align8_preserved, 1);
 
   // Hard float.  Use both S and D registers and conform to AAPCS-VFP.
   if (Subtarget->isAAPCS_ABI() && FloatABIType == FloatABI::Hard) {
     emitAttribute(ARMBuildAttrs::ABI_HardFP_use, 3);
     emitAttribute(ARMBuildAttrs::ABI_VFP_args, 1);
   }
   // FIXME: Should we signal R9 usage?
+
+  // FIXME: This is just a freebie set by GNU/ARM as for ELF/.o only.
+  // LLVM never emitted this explicitly for .s
+  if (!OutStreamer.hasRawTextSupport()) {
+    emitAttribute(ARMBuildAttrs::DIV_use, 1);
+  }
+
+  (void) fixupAttrSizes();
 }
 
 void ARMAsmPrinter::emitARMAttributeSection() {
   // <format-version>
   // [ <section-length> "vendor-name"
   // [ <file-tag> <size> <attribute>*
   //   | <section-tag> <size> <section-number>* 0 <attribute>*
   //   | <symbol-tag> <size> <symbol-number>* 0 <attribute>*
   //   ]+
   // ]*
 
   if (OutStreamer.hasRawTextSupport())
     return;
 
   const ARMElfTargetObjectFile &TLOFELF =
     static_cast<const ARMElfTargetObjectFile &>
     (getObjFileLowering());
 
   OutStreamer.SwitchSection(TLOFELF.getAttributesSection());
-  // Fixme: Still more to do here.
+
+  MCObjectStreamer *ELFStreamer = static_cast<MCObjectStreamer*>(&OutStreamer);
+  MCAssembler *Asm = &ELFStreamer->getAssembler();
+
+  bool newSec = false;
+  MCSectionData *AttrSecData = 
+    &(Asm->getOrCreateSectionData(*TLOFELF.getAttributesSection(), &newSec));
+
+  headFragment = new MCDataFragment(AttrSecData);
+  SmallString<32> *FC = &headFragment->getContents();
+
+  (*FC) += ((char)ARMBuildAttrs::Format_Version);
+
+  FC->append(sizeof(ELF::Elf32_Word), 0);
+
+  FC->append(ARMBuildAttrs::Vendor_Name, 
+             ARMBuildAttrs::Vendor_Name_End);
+
+  currFileFragment =
+    addAttrSubsec(AttrSecData, ARMBuildAttrs::File);
 }
 
 void ARMAsmPrinter::emitAttribute(ARMBuildAttrs::AttrType attr, int v) {
   if (OutStreamer.hasRawTextSupport()) {
     OutStreamer.EmitRawText("\t.eabi_attribute " +
                             Twine(attr) + ", " + Twine(v));
-
+    
   } else {
-    assert(0 && "ELF .ARM.attributes unimplemented");
+    switch (attr) {
+    // These all go into the File subsection
+    case ARMBuildAttrs::VFP_arch:
+    case ARMBuildAttrs::ABI_FP_denormal:
+    case ARMBuildAttrs::ABI_FP_exceptions:
+    case ARMBuildAttrs::ABI_FP_number_model:
+    case ARMBuildAttrs::ABI_align8_needed:
+    case ARMBuildAttrs::ABI_align8_preserved:
+    case ARMBuildAttrs::ABI_HardFP_use:
+    case ARMBuildAttrs::ABI_VFP_args: 
+    case ARMBuildAttrs::DIV_use: {
+      assert(currFileFragment && "No File subsection found");
+      SmallString<32> *FC = &currFileFragment->getContents();
+      (*FC) += static_cast<char>(attr);
+      (*FC) += static_cast<char>(0xFF & v);
+    }; break;
+    default: assert(0 && "Unsupported ARMBuildAttrs::AttrType"); break;
+    }
   }
 }
 
 void ARMAsmPrinter::emitTextAttribute(ARMBuildAttrs::SpecialAttr attr,
                                       StringRef val) {
   switch (attr) {
   default: assert(0 && "Unimplemented ARMBuildAttrs::SpecialAttr"); break;
   case ARMBuildAttrs::SEL_CPU:
     if (OutStreamer.hasRawTextSupport()) {
       if (val != "generic") {
         OutStreamer.EmitRawText("\t.cpu " + val);
       }
     } else {
-      // FIXME: ELF
+      // .o
+      if (val == "generic") {
+        assert(currFileFragment && "No File subsection found");
+        SmallString<32> *FC = &currFileFragment->getContents();
+        (*FC) += static_cast<char>(ARMBuildAttrs::CPU_arch);
+        (*FC) += static_cast<char>(ARMBuildAttrs::v4T);
+
+        (*FC) += static_cast<char>(ARMBuildAttrs::ARM_ISA_use);
+        (*FC) += static_cast<char>(1);
+
+        (*FC) += static_cast<char>(ARMBuildAttrs::THUMB_ISA_use);
+        (*FC) += static_cast<char>(1);
+      } else {
+        assert(0 && "unsupported .cpu attribute for ELF/.o");
+      }
     }
   }
 }
 
+MCDataFragment *ARMAsmPrinter::addAttrSubsec(MCSectionData *AttrSecData,
+                                             ARMBuildAttrs::AttrType attr,
+                                             int SecOrSym) {
+  MCDataFragment *rtn = new MCDataFragment(AttrSecData);
+  SmallString<32> *FC = &rtn->getContents();
+
+  (*FC) += static_cast<char>(ARMBuildAttrs::File);  
+  FC->append(sizeof(ELF::Elf32_Word), 0);
+
+  switch (attr) {
+  case ARMBuildAttrs::File: break;
+  case ARMBuildAttrs::Section:
+  case ARMBuildAttrs::Symbol: {
+    (*FC) += (0xFF & SecOrSym);
+    (*FC) += (0xFF & (SecOrSym >> 8));
+    (*FC) += (0xFF & (SecOrSym >> 16));
+    (*FC) += (0xFF & (SecOrSym >> 24));
+
+    (*FC) += 0;
+  } break;
+  default: assert(0 && "Unknown .ARM.attributes subsection"); break;
+  }
+
+  return rtn;
+}
+
+int ARMAsmPrinter::fixupAttrSizes() {
+  int SFileAttr = fixupAttrSize(currFileFragment, 1, 0);
+  int SSecAttr = fixupAttrSize(currSectionFragment, 1, 0);
+  int SSymAttr = fixupAttrSize(currSymbolFragment, 1, 0);
+  int Shead = fixupAttrSize(headFragment, 1,
+                            (SFileAttr + SSecAttr + SSymAttr - 1));
+  return Shead;
+}
+
+int ARMAsmPrinter::fixupAttrSize(MCDataFragment *F,
+                                 int secLenOffset, int lenAdjust) {
+  if (F) {
+    SmallString<32> *FC = &F->getContents();
+    
+    int S = (int)(FC->size() + lenAdjust);
+    (*FC)[secLenOffset+0] = 0xFF & S;
+    (*FC)[secLenOffset+1] = 0xFF & (S>>8);
+    (*FC)[secLenOffset+2] = 0xFF & (S>>16);
+    (*FC)[secLenOffset+3] = 0xFF & (S>>24);
+    return S + lenAdjust;
+  }
+  return 0;
+}
+
 //===----------------------------------------------------------------------===//
 
 static MCSymbol *getPICLabel(const char *Prefix, unsigned FunctionNumber,
                              unsigned LabelId, MCContext &Ctx) {
 
   MCSymbol *Label = Ctx.GetOrCreateSymbol(Twine(Prefix)
                        + "PC" + Twine(FunctionNumber) + "_" + Twine(LabelId));
   return Label;
 }
 
@@ skipping 682 matching lines @@
 
 // Force static initialization.
 extern "C" void LLVMInitializeARMAsmPrinter() {
   RegisterAsmPrinter<ARMAsmPrinter> X(TheARMTarget);
   RegisterAsmPrinter<ARMAsmPrinter> Y(TheThumbTarget);
 
   TargetRegistry::RegisterMCInstPrinter(TheARMTarget, createARMMCInstPrinter);
   TargetRegistry::RegisterMCInstPrinter(TheThumbTarget, createARMMCInstPrinter);
 }