blob: 07931cba6b90348102a505fff4dfcff6a20547d7 [file] [log] [blame]
//===-- go-backend.cpp - backend specific go utility routines -------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Backend-specific helper routines invoked by the go frontend.
//
//===----------------------------------------------------------------------===//
#include "llvm-includes.h"
#include <ctype.h>
#include <iostream>
#include "go-llvm-diagnostics.h"
#include "go-c.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Object/Archive.h"
#include "llvm/Object/Binary.h"
#include "llvm/Object/ObjectFile.h"
// Size of archive member header in bytes
#define ARCHIVE_MEMBER_HEADER_SIZE 60
#ifndef GO_EXPORT_SEGMENT_NAME
#define GO_EXPORT_SEGMENT_NAME "__GNU_GO"
#endif
/* The section name we use when reading and writing export data. */
#ifndef GO_EXPORT_SECTION_NAME
#define GO_EXPORT_SECTION_NAME ".go_export"
#endif
/* Return whether or not we've reported any errors. */
bool
saw_errors (void)
{
return go_be_saw_errors();
}
// Called by the Go frontend proper if the unsafe package was imported.
//
// FIXME: make a determination about whether we need to run TBAA
// in a different way based on this information.
void
go_imported_unsafe (void)
{
}
static const char *
readExportDataFromObject(llvm::object::ObjectFile *obj,
int *perr,
char **pbuf,
size_t *plen)
{
// Walk sections
for (llvm::object::section_iterator si = obj->section_begin(),
se = obj->section_end(); si != se; ++si) {
llvm::object::SectionRef sref = *si;
llvm::StringRef sname;
std::error_code error = sref.getName(sname);
if (error)
break;
if (sname == GO_EXPORT_SECTION_NAME) {
// Extract section of interest
llvm::StringRef bytes;
if (sref.getContents(bytes)) {
*perr = errno;
return "get section contents";
}
char *buf = new char[bytes.size()];
if (! buf) {
*perr = errno;
return "malloc";
}
memcpy(buf, bytes.data(), bytes.size());
*pbuf = buf;
*plen = bytes.size();
return nullptr;
}
}
return nullptr;
}
static const char *
readExportDataFromArchive(llvm::object::Archive *archive,
off_t offset,
int *perr,
char **pbuf,
size_t *plen)
{
llvm::Error err = llvm::Error::success();
// The gofrontend archive reader passes in an offset that points
// past the the archive member header, whereas the llvm::object::Archive
// code considers "child offset" to be the start of the region in the
// archive at the point of the member header. Adjust accordingly.
assert(!offset || offset > ARCHIVE_MEMBER_HEADER_SIZE);
uint64_t uoffset = static_cast<uint64_t>(offset) -
ARCHIVE_MEMBER_HEADER_SIZE;
for (auto &child : archive->children(err)) {
if (err)
return "unable to open as archive";
if (child.getChildOffset() != uoffset)
continue;
// found.
llvm::Expected<std::unique_ptr<llvm::object::Binary>> childOrErr =
child.getAsBinary();
if (auto err = childOrErr.takeError()) {
// Ignore error if this is not recognized as an object file.
// This is also what gccgo does (go-backend.c:go_read_export_data).
// In particular, cgo archive may contain _cgo_flags as a member,
// which is not an object file.
consumeError(std::move(err));
return nullptr;
}
llvm::object::ObjectFile *o =
llvm::dyn_cast<llvm::object::ObjectFile>(&*childOrErr.get());
if (o)
return readExportDataFromObject(o, perr, pbuf, plen);
}
if (err)
return "unable to open as archive";
else
return nullptr;
}
/* The go_read_export_data function is called by the Go frontend
proper to read Go export data from an object file. FD is a file
descriptor open for reading. OFFSET is the offset within the file
where the object file starts; this will be 0 except when reading an
archive. On success this returns NULL and sets *PBUF to a buffer
allocated using malloc, of size *PLEN, holding the export data. If
the data is not found, this returns NULL and sets *PBUF to NULL and
*PLEN to 0. If some error occurs, this returns an error message
and sets *PERR to an errno value or 0 if there is no relevant
errno. */
const char *
go_read_export_data (int fd, off_t offset, char **pbuf, size_t *plen,
int *perr)
{
*pbuf = NULL;
*plen = 0;
// Create memory buffer for this file descriptor
auto BuffOrErr = llvm::MemoryBuffer::getOpenFile(fd, "", -1);
if (! BuffOrErr)
return nullptr; // ignore this error
std::unique_ptr<llvm::MemoryBuffer> Buffer = std::move(BuffOrErr.get());
// Examine buffer as binary
llvm::Expected<std::unique_ptr<llvm::object::Binary>> BinOrErr =
llvm::object::createBinary(Buffer->getMemBufferRef());
if (!BinOrErr)
return nullptr; // also ignore here
std::unique_ptr<llvm::object::Binary> Binary = std::move(BinOrErr.get());
// Examine binary as archive
if (llvm::object::Archive *a =
llvm::dyn_cast<llvm::object::Archive>(Binary.get()))
return readExportDataFromArchive(a, offset, perr, pbuf, plen);
// Examine binary as object
llvm::object::ObjectFile *o =
llvm::dyn_cast<llvm::object::ObjectFile>(Binary.get());
if (o)
return readExportDataFromObject(o, perr, pbuf, plen);
return nullptr;
}
const char *lbasename(const char *path)
{
// TODO: add windows support
const char *cur, *rval = path;
for (cur = path; *cur; cur++)
if (*cur == '/')
rval = cur + 1;
return rval;
}
const char *xstrerror(int e)
{
static char unknown_ebuf[128];
const char *se = strerror(e);
if (se)
return se;
sprintf(unknown_ebuf, "unknown error #%d", e);
se = unknown_ebuf;
return se;
}
bool IS_DIR_SEPARATOR(char c)
{
// TODO: windows support
return c == '/';
}
extern bool ISXDIGIT(char c)
{
// TODO: update if better locale support added
return isxdigit(c);
}