lib/Target/PIC16/PIC16TargetObjectFile.h

   1 //===-- PIC16TargetObjectFile.h - PIC16 Object Info -------------*- C++ -*-===//
   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 #ifndef LLVM_TARGET_PIC16_TARGETOBJECTFILE_H
  11 #define LLVM_TARGET_PIC16_TARGETOBJECTFILE_H
  12
  13 #include "PIC16.h"
  14 #include "PIC16ABINames.h"
  15 #include "llvm/Target/TargetLoweringObjectFile.h"
  16 #include "llvm/ADT/StringMap.h"
  17 #include <vector>
  18 #include <string>
  19
  20 namespace llvm {
  21   class GlobalVariable;
  22   class Module;
  23   class PIC16TargetMachine;
  24   class PIC16Section;
  25
  26   enum { DataBankSize = 80 };
  27
  28   /// PIC16 Splits the global data into mulitple udata and idata sections.
  29   /// Each udata and idata section needs to contain a list of globals that
  30   /// they contain, in order to avoid scanning over all the global values
  31   /// again and printing only those that match the current section.
  32   /// Keeping values inside the sections make printing a section much easier.
  33   ///
  34   /// FIXME: MOVE ALL THIS STUFF TO PIC16Section.
  35   ///
  36
  37   /// PIC16TargetObjectFile - PIC16 Object file. Contains data and code
  38   /// sections.
  39   // PIC16 Object File has two types of sections.
  40   // 1. Standard Sections
  41   //    1.1 un-initialized global data
  42   //    1.2 initialized global data
  43   //    1.3 program memory data
  44   //    1.4 local variables of functions.
  45   // 2. User defined sections
  46   //    2.1 Objects placed in a specific section. (By _Section() macro)
  47   //    2.2 Objects placed at a specific address. (By _Address() macro)
  48   class PIC16TargetObjectFile : public TargetLoweringObjectFile {
  49     /// SectionsByName - Bindings of names to allocated sections.
  50     mutable StringMap<PIC16Section*> SectionsByName;
  51
  52     const TargetMachine *TM;
  53
  54     /// Lists of sections.
  55     /// Standard Data Sections.
  56     mutable std::vector<PIC16Section *> UDATASections_;
  57     mutable std::vector<PIC16Section *> IDATASections_;
  58     mutable PIC16Section * ROMDATASection_;
  59     mutable PIC16Section * SHAREDUDATASection_;
  60
  61     /// Standard Auto Sections.
  62     mutable std::vector<PIC16Section *> AUTOSections_;
  63
  64     /// User specified sections.
  65     mutable std::vector<PIC16Section *> USERSections_;
  66
  67
  68     /// Find or Create a PIC16 Section, without adding it to any
  69     /// section list.
  70     PIC16Section *getPIC16Section(const std::string &Name,
  71                                    PIC16SectionType Ty,
  72                                    const std::string &Address = "",
  73                                    int Color = -1) const;
  74
  75     /// Convenience functions. These wrappers also take care of adding
  76     /// the newly created section to the appropriate sections list.
  77
  78     /// Find or Create PIC16 Standard Data Section.
  79     PIC16Section *getPIC16DataSection(const std::string &Name,
  80                                        PIC16SectionType Ty,
  81                                        const std::string &Address = "",
  82                                        int Color = -1) const;
  83
  84     /// Find or Create PIC16 Standard Auto Section.
  85     PIC16Section *getPIC16AutoSection(const std::string &Name,
  86                                        PIC16SectionType Ty = UDATA_OVR,
  87                                        const std::string &Address = "",
  88                                        int Color = -1) const;
  89
  90     /// Find or Create PIC16 Standard Auto Section.
  91     PIC16Section *getPIC16UserSection(const std::string &Name,
  92                                        PIC16SectionType Ty,
  93                                        const std::string &Address = "",
  94                                        int Color = -1) const;
  95
  96     /// Allocate Un-initialized data to a standard UDATA section.
  97     const MCSection *allocateUDATA(const GlobalVariable *GV) const;
  98
  99     /// Allocate Initialized data to a standard IDATA section.
 100     const MCSection *allocateIDATA(const GlobalVariable *GV) const;
 101
 102     /// Allocate ROM data to the standard ROMDATA section.
 103     const MCSection *allocateROMDATA(const GlobalVariable *GV) const;
 104
 105     /// Allocate an AUTO variable to an AUTO section.
 106     const MCSection *allocateAUTO(const GlobalVariable *GV) const;
 107
 108     /// Allocate DATA in user specified section.
 109     const MCSection *allocateInGivenSection(const GlobalVariable *GV) const;
 110
 111     /// Allocate DATA at user specified address.
 112     const MCSection *allocateAtGivenAddress(const GlobalVariable *GV,
 113                                             const std::string &Addr) const;
 114
 115     /// Allocate a shared variable to SHARED section.
 116     const MCSection *allocateSHARED(const GlobalVariable *GV,
 117                                     Mangler *Mang) const;
 118
 119     public:
 120     PIC16TargetObjectFile();
 121     ~PIC16TargetObjectFile();
 122     void Initialize(MCContext &Ctx, const TargetMachine &TM);
 123
 124     /// Return the section with the given Name. Null if not found.
 125     PIC16Section *findPIC16Section(const std::string &Name) const;
 126
 127     /// Override section allocations for user specified sections.
 128     virtual const MCSection *
 129     getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
 130                              Mangler *Mang, const TargetMachine &TM) const;
 131
 132     /// Select sections for Data and Auto variables(globals).
 133     virtual const MCSection *SelectSectionForGlobal(const GlobalValue *GV,
 134                                                     SectionKind Kind,
 135                                                     Mangler *Mang,
 136                                                     const TargetMachine&) const;
 137
 138
 139     /// Return a code section for a function.
 140     const PIC16Section *SectionForCode (const std::string &FnName,
 141                                         bool isISR) const;
 142
 143     /// Return a frame section for a function.
 144     const PIC16Section *SectionForFrame (const std::string &FnName) const;
 145
 146     /// Accessors for various section lists.
 147     const std::vector<PIC16Section *> &UDATASections() const {
 148       return UDATASections_;
 149     }
 150     const std::vector<PIC16Section *> &IDATASections() const {
 151       return IDATASections_;
 152     }
 153     const PIC16Section *ROMDATASection() const {
 154       return ROMDATASection_;
 155     }
 156     const PIC16Section *SHAREDUDATASection() const {
 157       return SHAREDUDATASection_;
 158     }
 159     const std::vector<PIC16Section *> &AUTOSections() const {
 160       return AUTOSections_;
 161     }
 162     const std::vector<PIC16Section *> &USERSections() const {
 163       return USERSections_;
 164     }
 165   };
 166 } // end namespace llvm
 167
 168 #endif