//===------- CStdLib.h - CStdLib transform pass runtime helper functions -------===//
// 
//                          The SAFECode Compiler
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
// 
//===----------------------------------------------------------------------===//
//
// This file provides all external functions included by the CStdLib pass.
//
//===--------------------------------------------------------------------------===//

#ifndef _CSTDLIB_H
#define _CSTDLIB_H

#include "DebugReport.h"
#include "PoolAllocator.h"

#include <iostream>

#define TAG unsigned tag
#define SRC_INFO const char *SourceFile, unsigned lineNo

// Default versions of arguments to debug functions
#define DEFAULT_TAG 0
#define DEFAULT_SRC_INFO "<Unknown>", 0
#define SRC_INFO_ARGS SourceFile, lineNo

using namespace NAMESPACE_SC;

namespace {

  // Various violation types

  inline void
  OOB_VIOLATION(const void *fault_ptr,
                DebugPoolTy *handle,
                const void *start,
                size_t len,
                SRC_INFO) {
    OutOfBoundsViolation v;
    v.type        = ViolationInfo::FAULT_OUT_OF_BOUNDS;
    v.faultPC     = __builtin_return_address(0);
    v.faultPtr    = fault_ptr;
    v.SourceFile  = SourceFile;
    v.lineNo      = lineNo;
    v.PoolHandle  = handle;
    v.objStart    = start;
    v.objLen      = len;
    v.dbgMetaData = NULL;
    ReportMemoryViolation(&v);
  }

  inline void
  WRITE_VIOLATION(const void *fault_ptr,
                  DebugPoolTy *handle,
                  size_t dst_sz,
                  size_t src_sz,
                  SRC_INFO) {
    WriteOOBViolation v;
    v.type = ViolationInfo::FAULT_WRITE_OUT_OF_BOUNDS;
    v.faultPC = __builtin_return_address(0); 
    v.faultPtr = fault_ptr;
    v.SourceFile = SourceFile;
    v.lineNo =     lineNo;
    v.PoolHandle = handle;
    v.dstSize =    dst_sz;
    v.srcSize =    src_sz;
    v.dbgMetaData = NULL;
    ReportMemoryViolation(&v);
  }

  inline void
  LOAD_STORE_VIOLATION(const void *fault_ptr,
                       DebugPoolTy *handle,
                       SRC_INFO) {
    DebugViolationInfo v;
    v.faultPC = __builtin_return_address(0);
    v.faultPtr = fault_ptr;
    v.dbgMetaData = NULL;
    v.PoolHandle = handle;
    v.SourceFile = SourceFile;
    v.lineNo = lineNo;
    ReportMemoryViolation(&v);
  }

  inline void
  C_LIBRARY_VIOLATION(const void *fault_ptr,
                      DebugPoolTy *handle,
                      const char *function,
                      SRC_INFO) {
    CStdLibViolation v;
    v.type = ViolationInfo::FAULT_CSTDLIB;
    v.faultPC = __builtin_return_address(0);
    v.faultPtr = fault_ptr;
    v.SourceFile = SourceFile;
    v.lineNo     = lineNo;
    v.PoolHandle = handle;
    v.function   = function;
    v.dbgMetaData = NULL;
    ReportMemoryViolation(&v);
  }


  extern "C" {
    inline size_t strnlen(const char *s, size_t maxlen) {
      size_t i;
      for (i = 0; i < maxlen && s[i]; ++i)
        ;
      return i;
    }

    inline size_t strnlen_opt(const char *s, size_t maxlen) {
      const char *end = (const char *)memchr(s, '\0', maxlen);
      return (end ? ((size_t) (end - s)) : maxlen);
    }
  }

  /**
   * Optimized inline assembly implementation of strncpy that returns the number
   * of characters copied (including \0)
   *
   * @param   dst      Destination string pointer
   * @param   src      Source string pointer
   * @param   size     Number of characters to copy
   * @return  Number of characters copied (including \0)
   */
  inline size_t
  strncpy_asm(char *dst, const char *src, size_t size) {
    long copied;

  /*#if defined(i386) || defined(__i386__) || defined(__x86__)
    __asm__ __volatile__(
      "0: xorl      %%ecx, %%ecx      \n"
      "   cmpl      %%edi, %%ecx      \n"
      "   adcl      $0, %%ecx         \n"
      "   decl      %%edi             \n"
      "   testl     %%ecx, %%ecx      \n"
      "   je        1f                \n"
      "   movsbl    (%%edx), %%ecx    \n"
      "   movb      %%cl, (%%eax)     \n"
      "   incl      %%eax             \n"
      "   incl      %%edx             \n"
      "   testl     %%ecx, %%ecx      \n"
      "   jne       0b                \n"
      "1: subl      %%esi, %%eax      \n"
      : "=a"(copied)
      : "a"(dst), "S"(dst), "d"(src), "D"(size)
      : "%ecx", "memory"
    );
  #else*/
    strncpy(dst, src, size);
    copied = strnlen(dst, size - 1);
  //#endif

    return copied;
  }

  /**
   * Check for string termination.
   *
   * @param start  This is a pointer to the start of the string.
   * @param end    The end of the object. String is not scanned farther than here.
   * @param p      Reference to size object. Filled with the length of the string if
   *               string is terminated, otherwised filled with the size of the object.
   * @return       Returns true if the string is terminated within bounds (ie., 
   *               if the nul terminator occurs between string and end, inclusive).
   *               Returns false if no nul terminator was found.
   *
   * Note that start and end should be valid boundaries for a valid object.
   */
  inline bool
  isTerminated(const char *start, void *end, size_t &p) {
    size_t max = 1 + ((char *)end - (char *)start), len;
    len = strnlen((char *)start, max);
    p = len;
    if (len == max)
      return false;
    else
      return true;
  }

  /**
   * Check for object overlap.
   *
   * @param ptr1Start  The start of the first memory object
   * @param ptr1End    The end of the first memory object or the bound that writing
   *                   operation actually touch.
   * @param ptr2Start  The start of the second memory object
   * @param ptr2End    The end of the second memory object or the bound that writing
   *                   operation actually touch.
   *
   * @return           Whether these 2 memory object overlaps
   */
  inline bool
  isOverlapped(const void* ptr1Start, 
                           const void* ptr1End, 
                           const void* ptr2Start, 
                           const void* ptr2End){
    if( ((long int)ptr1Start>(long int)ptr2End && (long int)ptr1End>(long int)ptr2Start) || 
        ((long int)ptr1Start<(long int)ptr2End && (long int)ptr1End<(long int)ptr2Start)  )
      return false;
    return true;
  }

  /**
   * Searches inside the given pool for the memory object associated with the
   * the given address. If the memory object is found, it sets the poolBegin
   * and poolEnd pointers to point to the first and last valid positions of
   * the memory object, and returns true. If the memory object is not found in
   * the pool, or the pool is NULL, it attemps to find the object in the external
   * objects pool. When the object is not found in either pool, the function
   * returns false.
   *
   * @param   pool       The pool handle which is expected to contain the object.
   * @param   address    The address for which the bounding object is sought.
   * @param   poolBegin  Reference to a pointer to set to the beginning of
   *                     the memory object.
   * @param   poolEnd    Reference to a pointer to set to the last valid address
   *                     the memory object.
   * @return  Returns true if the object was found, false otherwise.
   */
  inline bool
  pool_find(DebugPoolTy *pool, void *address, void *&poolBegin, void *&poolEnd) {

    if (address == NULL)
      return false;

    // Retrieve memory area's bounds from pool handle.
    if ((pool && pool->Objects.find(address, poolBegin, poolEnd)) || 
        ExternalObjects.find(address, poolBegin, poolEnd))
      return true;

    return false;
  }

  /* Macros for determining the completeness of pointer arguments using the
     completeness bitwise vector. */
  #define ARG1_COMPLETE(c) ((bool) (c & 0x1))
  #define ARG2_COMPLETE(c) ((bool) (c & 0x2))

  /**
   * This function attempts to verify that given string pointer points to
   * a valid string that is terminated within its memory object's boundaries.
   * For strings that are marked complete, if the string is discovered to be
   * not in its pool, or unterminated within memory object boundaries,
   * the function reports a violation and returns false.
   * For strings not marked complete, the function attempts to do the same
   * checks as for complete pointers, except that it assumes the string was
   * valid if the string's memory object is not found in the pool.
   *
   * The function returns true if no memory violations were discovered, and
   * false when there was a violation.
   *
   * @param   string     The pointer to the string to be checked.
   * @param   pool       The pool that should be searched for the memory object
   *                     that contains the string.
   * @param   complete   This is a boolean value which is true if the string
   *                     pointer was reported complete by DSA, and false if not.
   *                     If the string is incomplete, no errors are reported
   *                     if it does not exist in the pool and is non-NULL.
   * @param   function   The name of the C library function for debug reporting
   *                     purposes.
   * @param   SRC_INFO   Source and line info debug information.
   * @return             Returns true if no violations were discoverd, and false
   *                     if the pointer does not point to a valid string and a 
   *                     memory violation was reported.
   *                     Note that if the function returns true, the pointer may
   *                     still not point to a valid string if the pointer was
   *                     incomplete.
   *
   */
  inline bool
  validStringCheck(const char *string,
                   DebugPoolTy *pool,
                   bool complete,
                   const char *function,
                   SRC_INFO) {
    void *objStart, *objEnd;
    size_t len;

    // Check if the string is NULL. If it is, report this as an error.
    if (string == NULL) {
      std::cout << "String pointer is NULL!\n";
      C_LIBRARY_VIOLATION(string, pool, function, SRC_INFO_ARGS);
      return false;
    }

    // Retrieve the string from the pool. If no string is found and the pointer
    // is not complete, return true. Otherwise report an error and return false.
    if (!pool_find(pool, (void *)string, objStart, objEnd)) {
      if (complete) {
        std::cout << "String not found in pool!\n";
        LOAD_STORE_VIOLATION(string, pool, SRC_INFO_ARGS);
        return false;
      }
      else
        return true;
    }

    // Do a termination check.
    if (!isTerminated(string, objEnd, len)) {
      std::cout << "String is not terminated within object bounds!\n";
      C_LIBRARY_VIOLATION(string, pool, function, SRC_INFO_ARGS);
      return false;
    }

    return true;
  }

}

#endif // _CSTDLIB_H