LCOV - code coverage report
Current view: top level - include/llvm/ObjectYAML - ELFYAML.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 39 39 100.0 %
Date: 2018-05-20 00:06:23 Functions: 11 15 73.3 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- ELFYAML.h - ELF YAMLIO implementation --------------------*- 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             : /// \file
      11             : /// This file declares classes for handling the YAML representation
      12             : /// of ELF.
      13             : ///
      14             : //===----------------------------------------------------------------------===//
      15             : 
      16             : #ifndef LLVM_OBJECTYAML_ELFYAML_H
      17             : #define LLVM_OBJECTYAML_ELFYAML_H
      18             : 
      19             : #include "llvm/ADT/StringRef.h"
      20             : #include "llvm/ObjectYAML/YAML.h"
      21             : #include "llvm/Support/YAMLTraits.h"
      22             : #include <cstdint>
      23             : #include <memory>
      24             : #include <vector>
      25             : 
      26             : namespace llvm {
      27             : namespace ELFYAML {
      28             : 
      29             : // These types are invariant across 32/64-bit ELF, so for simplicity just
      30             : // directly give them their exact sizes. We don't need to worry about
      31             : // endianness because these are just the types in the YAMLIO structures,
      32             : // and are appropriately converted to the necessary endianness when
      33             : // reading/generating binary object files.
      34             : // The naming of these types is intended to be ELF_PREFIX, where PREFIX is
      35             : // the common prefix of the respective constants. E.g. ELF_EM corresponds
      36             : // to the `e_machine` constants, like `EM_X86_64`.
      37             : // In the future, these would probably be better suited by C++11 enum
      38             : // class's with appropriate fixed underlying type.
      39         566 : LLVM_YAML_STRONG_TYPEDEF(uint16_t, ELF_ET)
      40          65 : LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_PT)
      41        9565 : LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_EM)
      42         594 : LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_ELFCLASS)
      43         568 : LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_ELFDATA)
      44         656 : LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_ELFOSABI)
      45             : // Just use 64, since it can hold 32-bit values too.
      46         452 : LLVM_YAML_STRONG_TYPEDEF(uint64_t, ELF_EF)
      47          66 : LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_PF)
      48        3725 : LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_SHT)
      49        2993 : LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_REL)
      50          38 : LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_RSS)
      51             : // Just use 64, since it can hold 32-bit values too.
      52         689 : LLVM_YAML_STRONG_TYPEDEF(uint64_t, ELF_SHF)
      53          27 : LLVM_YAML_STRONG_TYPEDEF(uint16_t, ELF_SHN)
      54        1290 : LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_STT)
      55         824 : LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_STV)
      56         793 : LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_STO)
      57             : 
      58          53 : LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_AFL_REG)
      59          35 : LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_ABI_FP)
      60          31 : LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_EXT)
      61          10 : LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_ASE)
      62          10 : LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_FLAGS1)
      63          25 : LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_ISA)
      64             : 
      65             : // For now, hardcode 64 bits everywhere that 32 or 64 would be needed
      66             : // since 64-bit can hold 32-bit values too.
      67             : struct FileHeader {
      68             :   ELF_ELFCLASS Class;
      69             :   ELF_ELFDATA Data;
      70             :   ELF_ELFOSABI OSABI;
      71             :   ELF_ET Type;
      72             :   ELF_EM Machine;
      73             :   ELF_EF Flags;
      74             :   llvm::yaml::Hex64 Entry;
      75             : };
      76             : 
      77             : struct SectionName {
      78             :   StringRef Section;
      79             : };
      80             : 
      81         165 : struct ProgramHeader {
      82             :   ELF_PT Type;
      83             :   ELF_PF Flags;
      84             :   llvm::yaml::Hex64 VAddr;
      85             :   llvm::yaml::Hex64 PAddr;
      86             :   Optional<llvm::yaml::Hex64> Align;
      87             :   std::vector<SectionName> Sections;
      88             : };
      89             : 
      90         750 : struct Symbol {
      91             :   StringRef Name;
      92             :   ELF_STT Type;
      93             :   StringRef Section;
      94             :   Optional<ELF_SHN> Index;
      95             :   llvm::yaml::Hex64 Value;
      96             :   llvm::yaml::Hex64 Size;
      97             :   uint8_t Other;
      98             : };
      99             : 
     100        1120 : struct LocalGlobalWeakSymbols {
     101             :   std::vector<Symbol> Local;
     102             :   std::vector<Symbol> Global;
     103             :   std::vector<Symbol> Weak;
     104             : };
     105             : 
     106             : struct SectionOrType {
     107             :   StringRef sectionNameOrType;
     108             : };
     109             : 
     110         508 : struct Section {
     111             :   enum class SectionKind {
     112             :     Group,
     113             :     RawContent,
     114             :     Relocation,
     115             :     NoBits,
     116             :     MipsABIFlags
     117             :   };
     118             :   SectionKind Kind;
     119             :   StringRef Name;
     120             :   ELF_SHT Type;
     121             :   ELF_SHF Flags;
     122             :   llvm::yaml::Hex64 Address;
     123             :   StringRef Link;
     124             :   StringRef Info;
     125             :   llvm::yaml::Hex64 AddressAlign;
     126             : 
     127         511 :   Section(SectionKind Kind) : Kind(Kind) {}
     128             :   virtual ~Section();
     129             : };
     130         404 : struct RawContentSection : Section {
     131             :   yaml::BinaryRef Content;
     132             :   llvm::yaml::Hex64 Size;
     133             : 
     134         814 :   RawContentSection() : Section(SectionKind::RawContent) {}
     135             : 
     136             :   static bool classof(const Section *S) {
     137             :     return S->Kind == SectionKind::RawContent;
     138             :   }
     139             : };
     140             : 
     141          19 : struct NoBitsSection : Section {
     142             :   llvm::yaml::Hex64 Size;
     143             : 
     144          38 :   NoBitsSection() : Section(SectionKind::NoBits) {}
     145             : 
     146             :   static bool classof(const Section *S) {
     147             :     return S->Kind == SectionKind::NoBits;
     148             :   }
     149             : };
     150             : 
     151          39 : struct Group : Section {
     152             :   // Members of a group contain a flag and a list of section indices
     153             :   // that are part of the group.
     154             :   std::vector<SectionOrType> Members;
     155             : 
     156          26 :   Group() : Section(SectionKind::Group) {}
     157             : 
     158             :   static bool classof(const Section *S) {
     159             :     return S->Kind == SectionKind::Group;
     160             :   }
     161             : };
     162             : 
     163         120 : struct Relocation {
     164             :   llvm::yaml::Hex64 Offset;
     165             :   int64_t Addend;
     166             :   ELF_REL Type;
     167             :   Optional<StringRef> Symbol;
     168             : };
     169             : 
     170         204 : struct RelocationSection : Section {
     171             :   std::vector<Relocation> Relocations;
     172             : 
     173         136 :   RelocationSection() : Section(SectionKind::Relocation) {}
     174             : 
     175             :   static bool classof(const Section *S) {
     176             :     return S->Kind == SectionKind::Relocation;
     177             :   }
     178             : };
     179             : 
     180             : // Represents .MIPS.abiflags section
     181           4 : struct MipsABIFlags : Section {
     182             :   llvm::yaml::Hex16 Version;
     183             :   MIPS_ISA ISALevel;
     184             :   llvm::yaml::Hex8 ISARevision;
     185             :   MIPS_AFL_REG GPRSize;
     186             :   MIPS_AFL_REG CPR1Size;
     187             :   MIPS_AFL_REG CPR2Size;
     188             :   MIPS_ABI_FP FpABI;
     189             :   MIPS_AFL_EXT ISAExtension;
     190             :   MIPS_AFL_ASE ASEs;
     191             :   MIPS_AFL_FLAGS1 Flags1;
     192             :   llvm::yaml::Hex32 Flags2;
     193             : 
     194           8 :   MipsABIFlags() : Section(SectionKind::MipsABIFlags) {}
     195             : 
     196             :   static bool classof(const Section *S) {
     197             :     return S->Kind == SectionKind::MipsABIFlags;
     198             :   }
     199             : };
     200             : 
     201         280 : struct Object {
     202             :   FileHeader Header;
     203             :   std::vector<ProgramHeader> ProgramHeaders;
     204             :   std::vector<std::unique_ptr<Section>> Sections;
     205             :   // Although in reality the symbols reside in a section, it is a lot
     206             :   // cleaner and nicer if we read them from the YAML as a separate
     207             :   // top-level key, which automatically ensures that invariants like there
     208             :   // being a single SHT_SYMTAB section are upheld.
     209             :   LocalGlobalWeakSymbols Symbols;
     210             :   LocalGlobalWeakSymbols DynamicSymbols;
     211             : };
     212             : 
     213             : } // end namespace ELFYAML
     214             : } // end namespace llvm
     215             : 
     216             : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::ProgramHeader)
     217             : LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::ELFYAML::Section>)
     218             : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Symbol)
     219             : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Relocation)
     220             : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionOrType)
     221             : LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionName)
     222             : 
     223             : namespace llvm {
     224             : namespace yaml {
     225             : 
     226             : template <>
     227             : struct ScalarEnumerationTraits<ELFYAML::ELF_ET> {
     228             :   static void enumeration(IO &IO, ELFYAML::ELF_ET &Value);
     229             : };
     230             : 
     231             : template <> struct ScalarEnumerationTraits<ELFYAML::ELF_PT> {
     232             :   static void enumeration(IO &IO, ELFYAML::ELF_PT &Value);
     233             : };
     234             : 
     235             : template <>
     236             : struct ScalarEnumerationTraits<ELFYAML::ELF_EM> {
     237             :   static void enumeration(IO &IO, ELFYAML::ELF_EM &Value);
     238             : };
     239             : 
     240             : template <>
     241             : struct ScalarEnumerationTraits<ELFYAML::ELF_ELFCLASS> {
     242             :   static void enumeration(IO &IO, ELFYAML::ELF_ELFCLASS &Value);
     243             : };
     244             : 
     245             : template <>
     246             : struct ScalarEnumerationTraits<ELFYAML::ELF_ELFDATA> {
     247             :   static void enumeration(IO &IO, ELFYAML::ELF_ELFDATA &Value);
     248             : };
     249             : 
     250             : template <>
     251             : struct ScalarEnumerationTraits<ELFYAML::ELF_ELFOSABI> {
     252             :   static void enumeration(IO &IO, ELFYAML::ELF_ELFOSABI &Value);
     253             : };
     254             : 
     255             : template <>
     256             : struct ScalarBitSetTraits<ELFYAML::ELF_EF> {
     257             :   static void bitset(IO &IO, ELFYAML::ELF_EF &Value);
     258             : };
     259             : 
     260             : template <> struct ScalarBitSetTraits<ELFYAML::ELF_PF> {
     261             :   static void bitset(IO &IO, ELFYAML::ELF_PF &Value);
     262             : };
     263             : 
     264             : template <>
     265             : struct ScalarEnumerationTraits<ELFYAML::ELF_SHT> {
     266             :   static void enumeration(IO &IO, ELFYAML::ELF_SHT &Value);
     267             : };
     268             : 
     269             : template <>
     270             : struct ScalarBitSetTraits<ELFYAML::ELF_SHF> {
     271             :   static void bitset(IO &IO, ELFYAML::ELF_SHF &Value);
     272             : };
     273             : 
     274             : template <> struct ScalarEnumerationTraits<ELFYAML::ELF_SHN> {
     275             :   static void enumeration(IO &IO, ELFYAML::ELF_SHN &Value);
     276             : };
     277             : 
     278             : template <>
     279             : struct ScalarEnumerationTraits<ELFYAML::ELF_STT> {
     280             :   static void enumeration(IO &IO, ELFYAML::ELF_STT &Value);
     281             : };
     282             : 
     283             : template <>
     284             : struct ScalarEnumerationTraits<ELFYAML::ELF_STV> {
     285             :   static void enumeration(IO &IO, ELFYAML::ELF_STV &Value);
     286             : };
     287             : 
     288             : template <>
     289             : struct ScalarBitSetTraits<ELFYAML::ELF_STO> {
     290             :   static void bitset(IO &IO, ELFYAML::ELF_STO &Value);
     291             : };
     292             : 
     293             : template <>
     294             : struct ScalarEnumerationTraits<ELFYAML::ELF_REL> {
     295             :   static void enumeration(IO &IO, ELFYAML::ELF_REL &Value);
     296             : };
     297             : 
     298             : template <>
     299             : struct ScalarEnumerationTraits<ELFYAML::ELF_RSS> {
     300             :   static void enumeration(IO &IO, ELFYAML::ELF_RSS &Value);
     301             : };
     302             : 
     303             : template <>
     304             : struct ScalarEnumerationTraits<ELFYAML::MIPS_AFL_REG> {
     305             :   static void enumeration(IO &IO, ELFYAML::MIPS_AFL_REG &Value);
     306             : };
     307             : 
     308             : template <>
     309             : struct ScalarEnumerationTraits<ELFYAML::MIPS_ABI_FP> {
     310             :   static void enumeration(IO &IO, ELFYAML::MIPS_ABI_FP &Value);
     311             : };
     312             : 
     313             : template <>
     314             : struct ScalarEnumerationTraits<ELFYAML::MIPS_AFL_EXT> {
     315             :   static void enumeration(IO &IO, ELFYAML::MIPS_AFL_EXT &Value);
     316             : };
     317             : 
     318             : template <>
     319             : struct ScalarEnumerationTraits<ELFYAML::MIPS_ISA> {
     320             :   static void enumeration(IO &IO, ELFYAML::MIPS_ISA &Value);
     321             : };
     322             : 
     323             : template <>
     324             : struct ScalarBitSetTraits<ELFYAML::MIPS_AFL_ASE> {
     325             :   static void bitset(IO &IO, ELFYAML::MIPS_AFL_ASE &Value);
     326             : };
     327             : 
     328             : template <>
     329             : struct ScalarBitSetTraits<ELFYAML::MIPS_AFL_FLAGS1> {
     330             :   static void bitset(IO &IO, ELFYAML::MIPS_AFL_FLAGS1 &Value);
     331             : };
     332             : 
     333             : template <>
     334             : struct MappingTraits<ELFYAML::FileHeader> {
     335             :   static void mapping(IO &IO, ELFYAML::FileHeader &FileHdr);
     336             : };
     337             : 
     338             : template <> struct MappingTraits<ELFYAML::ProgramHeader> {
     339             :   static void mapping(IO &IO, ELFYAML::ProgramHeader &FileHdr);
     340             : };
     341             : 
     342             : template <>
     343             : struct MappingTraits<ELFYAML::Symbol> {
     344             :   static void mapping(IO &IO, ELFYAML::Symbol &Symbol);
     345             :   static StringRef validate(IO &IO, ELFYAML::Symbol &Symbol);
     346             : };
     347             : 
     348             : template <>
     349             : struct MappingTraits<ELFYAML::LocalGlobalWeakSymbols> {
     350             :   static void mapping(IO &IO, ELFYAML::LocalGlobalWeakSymbols &Symbols);
     351             : };
     352             : 
     353             : template <> struct MappingTraits<ELFYAML::Relocation> {
     354             :   static void mapping(IO &IO, ELFYAML::Relocation &Rel);
     355             : };
     356             : 
     357             : template <>
     358             : struct MappingTraits<std::unique_ptr<ELFYAML::Section>> {
     359             :   static void mapping(IO &IO, std::unique_ptr<ELFYAML::Section> &Section);
     360             :   static StringRef validate(IO &io, std::unique_ptr<ELFYAML::Section> &Section);
     361             : };
     362             : 
     363             : template <>
     364             : struct MappingTraits<ELFYAML::Object> {
     365             :   static void mapping(IO &IO, ELFYAML::Object &Object);
     366             : };
     367             : 
     368             : template <> struct MappingTraits<ELFYAML::SectionOrType> {
     369             :   static void mapping(IO &IO, ELFYAML::SectionOrType &sectionOrType);
     370             : };
     371             : 
     372             : template <> struct MappingTraits<ELFYAML::SectionName> {
     373             :   static void mapping(IO &IO, ELFYAML::SectionName &sectionName);
     374             : };
     375             : 
     376             : } // end namespace yaml
     377             : } // end namespace llvm
     378             : 
     379             : #endif // LLVM_OBJECTYAML_ELFYAML_H

Generated by: LCOV version 1.13