//===-- llvm/Bitcode/NaCl/NaClReaderWriter.h - ------------------*- C++ -*-===//
//      NaCl Bitcode reader/writer.
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This header defines interfaces to read and write NaCl bitcode wire format
// files.
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_BITCODE_NACL_NACLREADERWRITER_H
#define LLVM_BITCODE_NACL_NACLREADERWRITER_H

#include "llvm/IR/DiagnosticInfo.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/ErrorOr.h"
#include "llvm/Support/MemoryBuffer.h"

#include <string>

namespace llvm {
  class LLVMContext;
  class Module;
  class NaClBitcodeHeader;
  class NaClBitstreamWriter;
  class StreamingMemoryObject;
  class raw_ostream;

  /// Defines the data layout used for PNaCl bitcode files. We set the
  /// data layout of the module in the bitcode readers rather than in
  /// pnacl-llc so that 'opt' will also use the correct data layout if
  /// it is run on a pexe.
  extern const char *PNaClDataLayout;

  /// Allows (function) local symbol tables (unsupported) in PNaCl bitcode
  /// files.
  extern cl::opt<bool> PNaClAllowLocalSymbolTables;

  /// \brief Defines the integer bit size used to model pointers in PNaCl.
  static const unsigned PNaClIntPtrTypeBitSize = 32;

  /// Diagnostic handler that redirects error diagnostics to the given stream.
  DiagnosticHandlerFunction redirectNaClDiagnosticToStream(raw_ostream &Out);

  /// Read the header of the specified bitcode buffer and prepare for lazy
  /// deserialization of function bodies.  If successful, this takes ownership
  /// of 'Buffer' (extending its lifetime).  On error, this returns an error
  /// code and deletes Buffer.
  ///
  /// The AcceptSupportedOnly argument is used to decide which PNaCl versions
  /// of the PNaCl bitcode to accept. There are three forms:
  ///    1) Readable and supported.
  ///    2) Readable and unsupported. Allows testing of code before becoming
  ///       supported, as well as running experiments on the bitcode format.
  ///    3) Unreadable.
  /// When AcceptSupportedOnly is true, only form 1 is allowed. When
  /// AcceptSupportedOnly is false, forms 1 and 2 are allowed.
  ErrorOr<Module *> getNaClLazyBitcodeModule(
      std::unique_ptr<MemoryBuffer> &&Buffer, LLVMContext &Context,
      DiagnosticHandlerFunction DiagnosticHandler = nullptr,
      bool AcceptSupportedOnly = true);

  /// Read the header of the specified stream and prepare for lazy
  /// deserialization and streaming of function bodies. On error,
  /// this returns null, and fills in *ErrMsg with an error description
  /// if ErrMsg is non-null.
  ///
  /// See getNaClLazyBitcodeModule for an explanation of argument
  /// AcceptSupportedOnly.
  /// TODO(kschimpf): Refactor this and getStreamedBitcodeModule to use
  /// ErrorOr<Module *> API so that all methods have the same interface.
  Module *getNaClStreamedBitcodeModule(
      const std::string &name, StreamingMemoryObject *streamer,
      LLVMContext &Context,
      DiagnosticHandlerFunction DiagnosticHandler = nullptr,
      std::string *ErrMsg = nullptr, bool AcceptSupportedOnly = true);

  /// Read the bitcode file from a buffer, returning the module.
  ///
  /// See getNaClLazyBitcodeModule for an explanation of argument
  /// AcceptSupportedOnly.
  ErrorOr<Module *>
  NaClParseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context,
                       DiagnosticHandlerFunction DiagnosticHandler = nullptr,
                       bool AcceptSupportedOnly = true);

  /// Read the textual bitcode records in Filename, returning the module.
  /// Note: If Filename is "-", stdin will be read.
  ///
  /// TODO(kschimpf) Replace Verbose argument with a DiagnosticHandlerFunction.
  ErrorOr<Module *> parseNaClBitcodeText(const std::string &Filename,
                                         LLVMContext &Context,
                                         raw_ostream *Verbose = nullptr);

  /// Write the specified module to the specified raw output stream, using
  /// PNaCl wire format.  For streams where it matters, the given stream
  /// should be in "binary" mode.
  ///
  /// The AcceptSupportedOnly argument is used to decide which PNaCl versions
  /// of the PNaCl bitcode to generate. There are two forms:
  ///    1) Writable and supported.
  ///    2) Writable and unsupported. Allows testing of code before becoming
  ///       supported, as well as running experiments on the bitcode format.
  /// When AcceptSupportedOnly is true, only form 1 is allowed. When
  /// AcceptSupportedOnly is false, forms 1 and 2 are allowed.
  void NaClWriteBitcodeToFile(const Module *M, raw_ostream &Out,
                              bool AcceptSupportedOnly = true);

  /// isNaClBitcode - Return true if the given bytes are the magic bytes for
  /// PNaCl bitcode wire format.
  ///
  inline bool isNaClBitcode(const unsigned char *BufPtr,
                        const unsigned char *BufEnd) {
    return BufPtr+4 <= BufEnd &&
        BufPtr[0] == 'P' &&
        BufPtr[1] == 'E' &&
        BufPtr[2] == 'X' &&
        BufPtr[3] == 'E';
  }

  /// NaClWriteHeader - Generate a default header (using the version
  /// number defined by kPNaClVersion) and write to the corresponding
  /// bitcode stream.
  void NaClWriteHeader(NaClBitstreamWriter &Stream, bool AcceptSupportedOnly);

  // NaClWriteHeader - Write the contents of the bitcode header to the
  // corresponding bitcode stream.
  void NaClWriteHeader(const NaClBitcodeHeader &Header,
                       NaClBitstreamWriter &Stream);

  /// NaClObjDump - Read PNaCl bitcode file from input, and print a
  /// textual representation of its contents. NoRecords and NoAssembly
  /// define what should not be included in the dump.
  bool NaClObjDump(MemoryBufferRef Input, raw_ostream &output,
                   bool NoRecords, bool NoAssembly);

} // end llvm namespace
#endif