SafeOpFlags.cpp

// -*- mode: C++ -*-
//
// Copyright (c) 2007, 2008, 2009, 2010, 2011 The University of Utah
// All rights reserved.
//
// This file is part of `csmith', a random generator of C programs.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
//   * Redistributions of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistributions in binary form must reproduce the above copyright
//     notice, this list of conditions and the following disclaimer in the
//     documentation and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.

#include <cassert>
#include <iostream>
#include <sstream>
#include <vector>

#include "SafeOpFlags.h"
#include "random.h"
#include "Error.h"
#include "Probabilities.h"
#include "DepthSpec.h"
#include "MspFilters.h"

using namespace std;

vector<string> SafeOpFlags::wrapper_names;

SafeOpFlags::SafeOpFlags()
{
	//Nothing to do
}

SafeOpFlags::SafeOpFlags(bool o1, bool o2, bool is_func, SafeOpSize osize)
	: op1_(o1),
	  op2_(o2),
	  is_func_(is_func),
	  op_size_(osize)
{
	//Nothing to do
}

SafeOpFlags::SafeOpFlags(const SafeOpFlags &flags)
	: op1_(flags.op1_),
	  op2_(flags.op2_),
	  is_func_(flags.is_func_),
	  op_size_(flags.op_size_)
{

}

SafeOpFlags*
SafeOpFlags::make_dummy_flags()
{
	return new SafeOpFlags();
}

eSimpleType
SafeOpFlags::flags_to_type(bool sign, enum SafeOpSize size)
{
	if (sign) {
		switch(size) {
		case sInt8: return eChar;
		case sInt16: return eShort;
		case sInt32: return eInt;
		case sInt64: return eLongLong;
		default: assert(0); break;
		}
	}
	else {
		switch(size) {
		case sInt8: return eUChar;
		case sInt16: return eUShort;
		case sInt32: return eUInt;
		case sInt64: return eULongLong;
		default: assert(0); break;
		}
	}
	assert(0);
	return eInt;
}

const Type*
SafeOpFlags::get_lhs_type(void)
{  
	eSimpleType st = flags_to_type(op1_, op_size_);
	const Type& t = Type::get_simple_type(st);
	return &t;
}

const Type*
SafeOpFlags::get_rhs_type(void)
{  
	eSimpleType st = flags_to_type(op2_, op_size_);
	const Type& t = Type::get_simple_type(st);
	return &t;
}

SafeOpFlags*
SafeOpFlags::make_random(SafeOpKind op_kind, eBinaryOps op)
{
	DEPTH_GUARD_BY_TYPE_RETURN_WITH_FLAG(dtSafeOpFlags, op_kind, NULL);
	SafeOpFlags *flags = new SafeOpFlags();
	assert("new SafeOpFlags fail!");

	flags->op1_ = rnd_flipcoin(SafeOpsSignedProb);
	ERROR_GUARD_AND_DEL1(NULL, flags);

	if (op_kind == sOpBinary) {
		flags->op2_ = rnd_flipcoin(SafeOpsSignedProb);
		ERROR_GUARD_AND_DEL1(NULL, flags);
	}
	else {
		flags->op2_ = flags->op1_;
	}

	// ISSUE: in the old code, is_func is always true
	// Probably need to be fixed later.
	flags->is_func_ = true;

	MspSafeOpSizeFilter *filter = new MspSafeOpSizeFilter(op);
	Probabilities::register_extra_filter(pSafeOpsSizeProb, filter);

	flags->op_size_ = (SafeOpSize)rnd_upto(MAX_SAFE_OP_SIZE, SAFE_OPS_SIZE_PROB_FILTER);
	Probabilities::unregister_extra_filter(pSafeOpsSizeProb, filter);
	ERROR_GUARD_AND_DEL2(NULL, flags, filter);

	//Probabilities::unregister_extra_filter(pSafeOpsSizeProb, filter);
	delete filter;
	return flags;
}

SafeOpFlags *
SafeOpFlags::clone() const
{
	return new SafeOpFlags(*this);
}

void
SafeOpFlags::OutputSize(std::ostream &out) const
{
	if(!op1_)
		out << "u";

	switch(op_size_) {
	case sInt8:
		out << "int8_t";
		break;
	case sInt16:
		out << "int16_t";
		break;
	case sInt32:
		out << "int32_t";
		break;
	case sInt64:
		out << "int64_t";
		break;
	default:
		assert(!"invalid size!");
		break;
	}
}

void
SafeOpFlags::OutputFuncOrMacro(std::ostream &out) const
{
	is_func_ ? (out << "func_")
		: (out << "macro_");
}

void 
SafeOpFlags::OutputSign(std::ostream &out, bool is_signed) const
{
	is_signed ? (out << "_s")
		: (out << "_u");
}

void
SafeOpFlags::OutputOp1(std::ostream &out) const
{
	OutputSign(out, op1_);
}

void
SafeOpFlags::OutputOp2(std::ostream &out) const
{
	OutputSign(out, op2_);
}

SafeOpFlags::~SafeOpFlags()
{
	// Nothing to do
}

/* find the safe math function/macro name */
std::string 
SafeOpFlags::to_string(enum eBinaryOps op) const
{
	string s;
	switch (op) {
		case eAdd: s = "safe_add_"; break;
		case eSub: s = "safe_sub_"; break;
		case eMul: s = "safe_mul_"; break;
		case eMod: s = "safe_mod_"; break;
		case eDiv: s = "safe_div_"; break;
		case eLShift: s = "safe_lshift_"; break;
		case eRShift: s = "safe_rshift_"; break;
		default: break;
	} 
	ostringstream oss;
	OutputFuncOrMacro(oss);
	OutputSize(oss);
	OutputOp1(oss); 
	(op == eLShift || op == eRShift) ? OutputOp2(oss) : OutputOp1(oss);
	s += oss.str();
	return s;
}

/* find the safe math function/macro name */
std::string 
SafeOpFlags::to_string(enum eUnaryOps op) const
{
	string s;
	switch (op) {
		case eMinus: s = "safe_unary_minus_"; break; 
		default: break;
	} 
	ostringstream oss;
	OutputFuncOrMacro(oss);
	OutputSize(oss);
	OutputOp1(oss);  
	s += oss.str();
	return s;
}

/* assign id to safe math function */
int 
SafeOpFlags::to_id(std::string fname)
{ 
	for (size_t i=0; i<wrapper_names.size(); i++) {
		if (wrapper_names[i] == fname) {
			return i+1;
		}
	}
	wrapper_names.push_back(fname);
	return wrapper_names.size();
}