mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-07-05 13:29:22 +00:00
c2966a3ac7
Originally added in r139314. Back then it didn't actually get the address, it got whatever value the relocation used: address or offset. The values in different object formats are: * MachO: Always an offset. * COFF: Always an address, but when talking about the virtual address of sections it says: "for simplicity, compilers should set this to zero". * ELF: An offset for .o files and and address for .so files. In the case of the .so, the relocation in not linked to any section (sh_info is 0). We can't really compute an offset. Some API mappings would be: * Use getAddress for everything. It would be quite cumbersome. To compute the address elf has to follow sh_info, which can be corrupted and therefore the method has to return an ErrorOr. The address of the section is also the same for every relocation in a section, so we shouldn't have to check the error and fetch the value for every relocation. * Use a getValue and make it up to the user to know what it is getting. * Use a getOffset and: * Assert for dynamic ELF objects. That is a very peculiar case and it is probably fair to ask any tool that wants to support it to use ELF.h. The only tool we have that reads those (llvm-readobj) already does that. The only other use case I can think of is a dynamic linker. * Check that COFF .obj files have sections with zero virtual address spaces. If it turns out that some assembler/compiler produces these, we can change COFFObjectFile::getRelocationOffset to subtract it. Given COFF format, this can be done without the need for ErrorOr. The getRelocationAddress method was never implemented for COFF. It also had exactly one use in a very peculiar case: a shortcut for adding the section value to a pcrel reloc on MachO. Given that, I don't expect that there is any use out there of the C API. If that is not the case, let me know and I will add it back with the implementation inlined and do a proper deprecation. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@241450 91177308-0d34-0410-b5e6-96231b3b80d8
101 lines
4.3 KiB
C++
101 lines
4.3 KiB
C++
/*===-- llvm-c/Object.h - Object Lib C Iface --------------------*- C++ -*-===*/
|
|
/* */
|
|
/* The LLVM Compiler Infrastructure */
|
|
/* */
|
|
/* This file is distributed under the University of Illinois Open Source */
|
|
/* License. See LICENSE.TXT for details. */
|
|
/* */
|
|
/*===----------------------------------------------------------------------===*/
|
|
/* */
|
|
/* This header declares the C interface to libLLVMObject.a, which */
|
|
/* implements object file reading and writing. */
|
|
/* */
|
|
/* Many exotic languages can interoperate with C code but have a harder time */
|
|
/* with C++ due to name mangling. So in addition to C, this interface enables */
|
|
/* tools written in such languages. */
|
|
/* */
|
|
/*===----------------------------------------------------------------------===*/
|
|
|
|
#ifndef LLVM_C_OBJECT_H
|
|
#define LLVM_C_OBJECT_H
|
|
|
|
#include "llvm-c/Core.h"
|
|
#include "llvm/Config/llvm-config.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/**
|
|
* @defgroup LLVMCObject Object file reading and writing
|
|
* @ingroup LLVMC
|
|
*
|
|
* @{
|
|
*/
|
|
|
|
// Opaque type wrappers
|
|
typedef struct LLVMOpaqueObjectFile *LLVMObjectFileRef;
|
|
typedef struct LLVMOpaqueSectionIterator *LLVMSectionIteratorRef;
|
|
typedef struct LLVMOpaqueSymbolIterator *LLVMSymbolIteratorRef;
|
|
typedef struct LLVMOpaqueRelocationIterator *LLVMRelocationIteratorRef;
|
|
|
|
// ObjectFile creation
|
|
LLVMObjectFileRef LLVMCreateObjectFile(LLVMMemoryBufferRef MemBuf);
|
|
void LLVMDisposeObjectFile(LLVMObjectFileRef ObjectFile);
|
|
|
|
// ObjectFile Section iterators
|
|
LLVMSectionIteratorRef LLVMGetSections(LLVMObjectFileRef ObjectFile);
|
|
void LLVMDisposeSectionIterator(LLVMSectionIteratorRef SI);
|
|
LLVMBool LLVMIsSectionIteratorAtEnd(LLVMObjectFileRef ObjectFile,
|
|
LLVMSectionIteratorRef SI);
|
|
void LLVMMoveToNextSection(LLVMSectionIteratorRef SI);
|
|
void LLVMMoveToContainingSection(LLVMSectionIteratorRef Sect,
|
|
LLVMSymbolIteratorRef Sym);
|
|
|
|
// ObjectFile Symbol iterators
|
|
LLVMSymbolIteratorRef LLVMGetSymbols(LLVMObjectFileRef ObjectFile);
|
|
void LLVMDisposeSymbolIterator(LLVMSymbolIteratorRef SI);
|
|
LLVMBool LLVMIsSymbolIteratorAtEnd(LLVMObjectFileRef ObjectFile,
|
|
LLVMSymbolIteratorRef SI);
|
|
void LLVMMoveToNextSymbol(LLVMSymbolIteratorRef SI);
|
|
|
|
// SectionRef accessors
|
|
const char *LLVMGetSectionName(LLVMSectionIteratorRef SI);
|
|
uint64_t LLVMGetSectionSize(LLVMSectionIteratorRef SI);
|
|
const char *LLVMGetSectionContents(LLVMSectionIteratorRef SI);
|
|
uint64_t LLVMGetSectionAddress(LLVMSectionIteratorRef SI);
|
|
LLVMBool LLVMGetSectionContainsSymbol(LLVMSectionIteratorRef SI,
|
|
LLVMSymbolIteratorRef Sym);
|
|
|
|
// Section Relocation iterators
|
|
LLVMRelocationIteratorRef LLVMGetRelocations(LLVMSectionIteratorRef Section);
|
|
void LLVMDisposeRelocationIterator(LLVMRelocationIteratorRef RI);
|
|
LLVMBool LLVMIsRelocationIteratorAtEnd(LLVMSectionIteratorRef Section,
|
|
LLVMRelocationIteratorRef RI);
|
|
void LLVMMoveToNextRelocation(LLVMRelocationIteratorRef RI);
|
|
|
|
|
|
// SymbolRef accessors
|
|
const char *LLVMGetSymbolName(LLVMSymbolIteratorRef SI);
|
|
uint64_t LLVMGetSymbolAddress(LLVMSymbolIteratorRef SI);
|
|
uint64_t LLVMGetSymbolSize(LLVMSymbolIteratorRef SI);
|
|
|
|
// RelocationRef accessors
|
|
uint64_t LLVMGetRelocationOffset(LLVMRelocationIteratorRef RI);
|
|
LLVMSymbolIteratorRef LLVMGetRelocationSymbol(LLVMRelocationIteratorRef RI);
|
|
uint64_t LLVMGetRelocationType(LLVMRelocationIteratorRef RI);
|
|
// NOTE: Caller takes ownership of returned string of the two
|
|
// following functions.
|
|
const char *LLVMGetRelocationTypeName(LLVMRelocationIteratorRef RI);
|
|
const char *LLVMGetRelocationValueString(LLVMRelocationIteratorRef RI);
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif /* defined(__cplusplus) */
|
|
|
|
#endif
|