//===- SAFECodeConfig.cpp ---------------------------------------*- C++ -*----//
// 
//                          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.
// 
//===----------------------------------------------------------------------===//
//
// Parse and record all configuration parameters required by SAFECode.
//
// TODO: Move other cl::opt to this file and parse them here as appropriate
//
//===----------------------------------------------------------------------===//

#include "safecode/SAFECodeConfig.h"

#include "llvm/Support/CommandLine.h"

using namespace llvm;

NAMESPACE_SC_BEGIN

namespace {
  cl::opt<bool>
  DPChecks("dpchecks",
           cl::init(false),
           cl::desc("Perform Dangling Pointer Checks"));

  cl::opt<bool>
  RewritePtrs("rewrite-oob",
              cl::init(false),
              cl::desc("Rewrite Out of Bound (OOB) Pointers"));
  
  cl::opt<bool>
  StopOnFirstError("terminate",
                   cl::init(false),
                   cl::desc("Terminate when an Error Ocurs"));
  
  cl::opt<bool> EnableSVA("sva",
                          cl::init(false), 
                          cl::desc("Enable SVA-Kernel specific operations"));
}

namespace {
  SAFECodeConfiguration::StaticCheckTy
    none  = SAFECodeConfiguration::ABC_CHECK_NONE,
    local = SAFECodeConfiguration::ABC_CHECK_LOCAL, 
    full  = SAFECodeConfiguration::ABC_CHECK_FULL;
  
  static cl::opt<SAFECodeConfiguration::StaticCheckTy>
  StaticChecks("static-abc", cl::init(SAFECodeConfiguration::ABC_CHECK_LOCAL),
               cl::desc("Static array bounds check analysis"),
               cl::values
               (clEnumVal(none,
                          "No static array bound checks"),
                clEnumVal(local,
                          "Local static array bound checks"),
                clEnumVal(full,
                          "Omega static array bound checks"),
                clEnumValEnd));


  SAFECodeConfiguration::PATy
  single = SAFECodeConfiguration::PA_SINGLE,
    simple = SAFECodeConfiguration::PA_SIMPLE,
    multi = SAFECodeConfiguration::PA_MULTI,
    apa = SAFECodeConfiguration::PA_APA;

  static cl::opt<SAFECodeConfiguration::PATy>
  PA("pa", cl::init(simple),
     cl::desc("The type of pool allocation used by the program"),
     cl::values(
                clEnumVal(single,  "Dummy Pool Allocation (Single DS Node)"),
                clEnumVal(simple,  "Simple Pool Allocation"),
                clEnumVal(multi,   "Context-insensitive Pool Allocation"),
                clEnumVal(apa,     "Automatic Pool Allocation"),
                clEnumValEnd));
}

SAFECodeConfiguration SCConfig;

//
// Method: dpChecks()
//
// Description:
//  Determines whether the user wants dangling pointer checks enabled.
//
// Return value:
//  true  - Dangling pointer checks are enabled.
//  false - Dangling pointer checks are disabled.
//
bool
SAFECodeConfiguration::dpChecks() {
  return DPChecks;
}

//
// Method: svaEnabled()
//
// Description:
//  Determines whether the user wants the SVA features enabled.
//
// Return value:
//  true  - SVA features are enabled.
//  false - SVA features are disabled.
//
bool
SAFECodeConfiguration::svaEnabled() {
  return EnableSVA;
}

//
// Method: terminateOnErrors()
//
// Description:
//  Determines whether the user wants the generated program to terminate on
//  the first memory error detected.
//
// Return value:
//  true  - The run-time should terminate the program when a memory safety
//          violation  occurs.
//  false - The run-time should report the memory-safety error but allow the
//          program to continue execution.
//
bool
SAFECodeConfiguration::terminateOnErrors() {
  return StopOnFirstError;
}

//
// Method: rewriteOOB()
//
// Description:
//  This method determines how strict the indexing requirements are for the
//  generated program.
//
// Return value:
//  true  - Relaxes indexing options are enabled.  The program may create
//          pointers that are out-of-bounds but should not be allowed to
//          deference them.
//  false - Follow C indexing rules: a pointer must either point within a valid
//          memory object, or it can point to one byte past the end of the
//          object as long as it is never dereferenced.
//
bool
SAFECodeConfiguration::rewriteOOB() {
  return RewritePtrs;
}

//
// Method: staticCheckType()
//
// Description:
//  This method determines what algorithms should be used for static array
//  bounds checking.
//
// Return value:
//  An enumerated value indicating which type of static array bounds checking
//  should be used.
//
SAFECodeConfiguration::StaticCheckTy
SAFECodeConfiguration::staticCheckType() {
  return StaticChecks;
}

//
// Method: getPAType()
//
// Description:
//  This method examines the command-line arguments and determines which
//  version of pool allocation should be used.
//
// Return value:
//  An enumerated value that indicates which version of Pool Allocation to use.
//
SAFECodeConfiguration::PATy
SAFECodeConfiguration::getPAType() {
  return PA;
}

//
// Method: calculateDSAType()
//
// Description:
//  This method examines the various command-line arguments and determines
//  which version of DSA is needed.
//
// Return value:
//  The type of DSA analysis that SAFECode needs to use is returned.
//
SAFECodeConfiguration::DSATy
SAFECodeConfiguration::calculateDSAType() {
  struct mapping {
    PATy pa;
    DSATy dsa;
  };

  static const struct mapping M[] = {
    {PA_SINGLE, DSA_BASIC},
    {PA_SIMPLE, DSA_EQTD},
    {PA_MULTI,  DSA_STEENS},
    {PA_APA,    DSA_EQTD},
  };

  bool found = false;
  for (unsigned i = 0; i < sizeof(M) / sizeof(struct mapping); ++i) {
    if (PA == M[i].pa) {
      return M[i].dsa;
    }
  }

  assert (found && "Inconsistent usage of Pool Allocation and DSA!");
  abort();
}

NAMESPACE_SC_END