1 //===- ELFYAML.cpp - ELF YAMLIO implementation ----------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines classes for handling the YAML representation of ELF.
12 //===----------------------------------------------------------------------===//
14 #include "llvm/Object/ELFYAML.h"
20 ScalarEnumerationTraits<ELFYAML::ELF_ET>::enumeration(IO &IO,
21 ELFYAML::ELF_ET &Value) {
22 #define ECase(X) IO.enumCase(Value, #X, ELF::X);
32 ScalarEnumerationTraits<ELFYAML::ELF_EM>::enumeration(IO &IO,
33 ELFYAML::ELF_EM &Value) {
34 #define ECase(X) IO.enumCase(Value, #X, ELF::X);
111 ECase(EM_ARC_COMPACT)
131 ECase(EM_ALTERA_NIOS2)
146 ECase(EM_LATTICEMICO32)
152 ECase(EM_CYPRESS_M8C)
167 ECase(EM_MCST_ELBRUS)
181 ECase(EM_CLOUDSHIELD)
184 ECase(EM_ARC_COMPACT2)
193 void ScalarEnumerationTraits<ELFYAML::ELF_ELFCLASS>::enumeration(
194 IO &IO, ELFYAML::ELF_ELFCLASS &Value) {
195 #define ECase(X) IO.enumCase(Value, #X, ELF::X);
196 // Since the semantics of ELFCLASSNONE is "invalid", just don't accept it
203 void ScalarEnumerationTraits<ELFYAML::ELF_ELFDATA>::enumeration(
204 IO &IO, ELFYAML::ELF_ELFDATA &Value) {
205 #define ECase(X) IO.enumCase(Value, #X, ELF::X);
206 // Since the semantics of ELFDATANONE is "invalid", just don't accept it
213 void ScalarEnumerationTraits<ELFYAML::ELF_ELFOSABI>::enumeration(
214 IO &IO, ELFYAML::ELF_ELFOSABI &Value) {
215 #define ECase(X) IO.enumCase(Value, #X, ELF::X);
218 ECase(ELFOSABI_NETBSD)
222 ECase(ELFOSABI_SOLARIS)
225 ECase(ELFOSABI_FREEBSD)
226 ECase(ELFOSABI_TRU64)
227 ECase(ELFOSABI_MODESTO)
228 ECase(ELFOSABI_OPENBSD)
229 ECase(ELFOSABI_OPENVMS)
232 ECase(ELFOSABI_FENIXOS)
233 ECase(ELFOSABI_C6000_ELFABI)
234 ECase(ELFOSABI_C6000_LINUX)
236 ECase(ELFOSABI_STANDALONE)
240 void ScalarBitSetTraits<ELFYAML::ELF_EF>::bitset(IO &IO,
241 ELFYAML::ELF_EF &Value) {
242 #define BCase(X) IO.bitSetCase(Value, #X, ELF::X);
243 BCase(EF_ARM_SOFT_FLOAT)
244 BCase(EF_ARM_VFP_FLOAT)
245 BCase(EF_ARM_EABI_UNKNOWN)
246 BCase(EF_ARM_EABI_VER1)
247 BCase(EF_ARM_EABI_VER2)
248 BCase(EF_ARM_EABI_VER3)
249 BCase(EF_ARM_EABI_VER4)
250 BCase(EF_ARM_EABI_VER5)
251 BCase(EF_ARM_EABIMASK)
252 BCase(EF_MIPS_NOREORDER)
256 BCase(EF_MIPS_32BITMODE)
257 BCase(EF_MIPS_ABI_O32)
258 BCase(EF_MIPS_MICROMIPS)
259 BCase(EF_MIPS_ARCH_ASE_M16)
260 BCase(EF_MIPS_ARCH_1)
261 BCase(EF_MIPS_ARCH_2)
262 BCase(EF_MIPS_ARCH_3)
263 BCase(EF_MIPS_ARCH_4)
264 BCase(EF_MIPS_ARCH_5)
265 BCase(EF_MIPS_ARCH_32)
266 BCase(EF_MIPS_ARCH_64)
267 BCase(EF_MIPS_ARCH_32R2)
268 BCase(EF_MIPS_ARCH_64R2)
270 BCase(EF_HEXAGON_MACH_V2)
271 BCase(EF_HEXAGON_MACH_V3)
272 BCase(EF_HEXAGON_MACH_V4)
273 BCase(EF_HEXAGON_MACH_V5)
274 BCase(EF_HEXAGON_ISA_MACH)
275 BCase(EF_HEXAGON_ISA_V2)
276 BCase(EF_HEXAGON_ISA_V3)
277 BCase(EF_HEXAGON_ISA_V4)
278 BCase(EF_HEXAGON_ISA_V5)
282 void ScalarEnumerationTraits<ELFYAML::ELF_SHT>::enumeration(
283 IO &IO, ELFYAML::ELF_SHT &Value) {
284 #define ECase(X) IO.enumCase(Value, #X, ELF::X);
287 // No SHT_SYMTAB. Use the top-level `Symbols` key instead.
288 // FIXME: Issue a diagnostic with this information.
298 ECase(SHT_INIT_ARRAY)
299 ECase(SHT_FINI_ARRAY)
300 ECase(SHT_PREINIT_ARRAY)
302 ECase(SHT_SYMTAB_SHNDX)
306 void ScalarBitSetTraits<ELFYAML::ELF_SHF>::bitset(IO &IO,
307 ELFYAML::ELF_SHF &Value) {
308 #define BCase(X) IO.bitSetCase(Value, #X, ELF::X);
316 BCase(SHF_LINK_ORDER)
317 BCase(SHF_OS_NONCONFORMING)
323 void ScalarEnumerationTraits<ELFYAML::ELF_STT>::enumeration(
324 IO &IO, ELFYAML::ELF_STT &Value) {
325 #define ECase(X) IO.enumCase(Value, #X, ELF::X);
337 void MappingTraits<ELFYAML::FileHeader>::mapping(IO &IO,
338 ELFYAML::FileHeader &FileHdr) {
339 IO.mapRequired("Class", FileHdr.Class);
340 IO.mapRequired("Data", FileHdr.Data);
341 IO.mapOptional("OSABI", FileHdr.OSABI, ELFYAML::ELF_ELFOSABI(0));
342 IO.mapRequired("Type", FileHdr.Type);
343 IO.mapRequired("Machine", FileHdr.Machine);
344 IO.mapOptional("Flags", FileHdr.Flags, ELFYAML::ELF_EF(0));
345 IO.mapOptional("Entry", FileHdr.Entry, Hex64(0));
348 void MappingTraits<ELFYAML::Symbol>::mapping(IO &IO, ELFYAML::Symbol &Symbol) {
349 IO.mapOptional("Name", Symbol.Name, StringRef());
350 IO.mapOptional("Type", Symbol.Type, ELFYAML::ELF_STT(0));
351 IO.mapOptional("Section", Symbol.Section, StringRef());
352 IO.mapOptional("Value", Symbol.Value, Hex64(0));
353 IO.mapOptional("Size", Symbol.Size, Hex64(0));
356 void MappingTraits<ELFYAML::LocalGlobalWeakSymbols>::mapping(
357 IO &IO, ELFYAML::LocalGlobalWeakSymbols &Symbols) {
358 IO.mapOptional("Local", Symbols.Local);
359 IO.mapOptional("Global", Symbols.Global);
360 IO.mapOptional("Weak", Symbols.Weak);
363 void MappingTraits<ELFYAML::Section>::mapping(IO &IO,
364 ELFYAML::Section &Section) {
365 IO.mapOptional("Name", Section.Name, StringRef());
366 IO.mapRequired("Type", Section.Type);
367 IO.mapOptional("Flags", Section.Flags, ELFYAML::ELF_SHF(0));
368 IO.mapOptional("Address", Section.Address, Hex64(0));
369 IO.mapOptional("Content", Section.Content);
370 IO.mapOptional("Link", Section.Link);
371 IO.mapOptional("AddressAlign", Section.AddressAlign, Hex64(0));
374 void MappingTraits<ELFYAML::Object>::mapping(IO &IO, ELFYAML::Object &Object) {
375 IO.mapRequired("FileHeader", Object.Header);
376 IO.mapOptional("Sections", Object.Sections);
377 IO.mapOptional("Symbols", Object.Symbols);
380 } // end namespace yaml
381 } // end namespace llvm