ClpValue.h

Go to the documentation of this file.

/*
 *      $Id$
 *      CLP Value definition
 *
 *      This file is part of OTAWA
 *      Copyright (c) 2011, IRIT UPS.
 *
 *      OTAWA is free software; you can redistribute it and/or modify
 *      it under the terms of the GNU General Public License as published by
 *      the Free Software Foundation; either version 2 of the License, or
 *      (at your option) any later version.
 *
 *      OTAWA is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *      GNU General Public License for more details.
 *
 *      You should have received a copy of the GNU General Public License
 *      along with OTAWA; if not, write to the Free Software
 *      Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 *      02110-1301  USA
 */

#ifndef OTAWA_DATA_CLP_VALUE_H_
#define OTAWA_DATA_CLP_VALUE_H_

#include <elm/types.h>
#include <elm/type_info.h>
#include <elm/io.h>
#include <elm/assert.h>

namespace otawa { namespace clp {

using namespace elm;

// Here we define the number of bits the CLP will be (here modulo 2^32)
const int NBITS = 32;
typedef elm::t::int32 intn_t;
typedef elm::t::uint32 uintn_t;
typedef t::uint64 STAT_UINT;
const uintn_t UMAXn = elm::type_info<uintn_t>::max;
const intn_t MAXn = elm::type_info<intn_t>::max;
const intn_t MINn = elm::type_info<intn_t>::min;


typedef enum {
        NONE,
        REG,    // only used for addresses
        VAL,
        ALL
} kind_t;

        class Value {
        public:
                static int and_threshold;

                inline bool isConst(void) const { return delta() == 0 || mtimes() == 0; }

                inline Value(kind_t kind=VAL, intn_t lower=0, intn_t delta=0,
                        uintn_t mtimes=0): _kind(kind), _lower(lower), _delta(delta),
                        _mtimes(mtimes) { check(); }
                inline Value(const Value& val):
                        _kind(val._kind), _lower(val._lower), _delta(val._delta),
                        _mtimes(val._mtimes) { }
                inline Value(const int val):
                        _kind(VAL), _lower(val), _delta(0), _mtimes(0) {}

                inline Value& operator=(const Value& val){
                        set(val._kind, val._lower, val._delta, val._mtimes);
                        return *this;
                }

                inline bool isTop(void) const { return _kind == ALL; }

                inline bool operator==(const Value& val) const {
                        return (
                                                (_kind == val._kind &&
                                                 _lower == val._lower &&
                                                 _delta == val._delta &&
                                                 _mtimes == val._mtimes)
                                                 /* WARNING: keep in order to verify it does not break something else
                                                  ||
                                                ( (_delta == 1 || _delta == -1) &&
                                                  (val._delta == 1 || val._delta == -1) &&
                                                 _mtimes == UMAXn && val._mtimes == UMAXn)*/
                                        );
                }
                inline bool operator!=(const Value& val) const {
                        return ! operator==(val);
                }

                Value operator+(const Value& val) const;
                Value operator-(const Value& val) const;
                inline bool operator>=(const int val) const {
                        return _lower >= val;
                }

                inline kind_t kind(void) const { return _kind; }
                inline intn_t lower(void) const { return _lower; }
                inline intn_t upper(void) const { return _lower + _delta * _mtimes; }
                inline intn_t delta(void) const { return _delta; }
                inline uintn_t mtimes(void) const { return _mtimes; }

                inline intn_t start(void) const {
                        if (_delta < 0)
                                return _lower + _delta * _mtimes;
                        else
                                return _lower;
                }

                inline intn_t stop(void) const {
                        if (_delta < 0)
                                return _lower;
                        else
                                return _lower + _delta * _mtimes;
                }

                void add(const Value& val);
                void sub(const Value& val);
                void print(io::Output& out) const;
                void shl(const Value& val);
                void shr(const Value& val);

                void _or(const Value& val);

                void join(const Value& val);
                void widening(const Value& val);
                void ffwidening(const Value& val, int loopBound);
                void inter(const Value& val);
                void reverse(void);

                inline bool swrap(void) const
                        { return _delta != 0 && _mtimes > (MAXn - _lower) / elm::abs(_delta); }
                inline bool uwrap(void) const
                        { return _delta != 0 && _mtimes > (UMAXn - _lower) / elm::abs(_delta); }

                void ge(intn_t k);
                void geu(uintn_t k);
                void le(intn_t k);
                void leu(uintn_t k);
                void eq(uintn_t k);
                void ne(uintn_t k);
                void _and(const Value& val);

                static const Value none;
                static const Value all;

                inline void set(kind_t kind, intn_t lower, intn_t delta,
                                                uintn_t mtimes){
                        _kind = kind;
                        _lower = lower;
                        _delta = delta;
                        _mtimes = mtimes;
                        check();
                }
        private:
                inline void check(void) { /*ASSERT((_delta == 0 && _mtimes == 0) || (_delta != 0 && _mtimes != 0));*/ }

                kind_t _kind;
                intn_t _lower;
                intn_t _delta;
                uintn_t _mtimes;
        };

        inline elm::io::Output& operator<<(elm::io::Output& out, const otawa::clp::Value &val)
                { val.print(out); return out; }

}       // clp

}       // otawa

#endif /* OTAWA_DATA_CLP_VALUE_H_ */