//===-- 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);
}