mirror of
https://forge.sourceware.org/marek/gcc.git
synced 2026-02-22 03:47:02 -05:00
333 lines
8.7 KiB
C++
333 lines
8.7 KiB
C++
/* Every class defined here represents a single bit value of a variable.
|
|
Every variable will be represented as a vector of these classes which later
|
|
will be used for bit-level symbolic execution.
|
|
Copyright (C) 2022-2026 Free Software Foundation, Inc.
|
|
Contributed by Matevos Mehrabyan <matevosmehrabyan@gmail.com>
|
|
|
|
This file is part of GCC.
|
|
|
|
GCC 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 3, or (at your option) any later
|
|
version.
|
|
|
|
GCC 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 GCC; see the file COPYING3. If not see
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
#ifndef SYM_EXEC_EXPRESSION_H
|
|
#define SYM_EXEC_EXPRESSION_H
|
|
|
|
#include "config.h"
|
|
#include "system.h"
|
|
#include "coretypes.h"
|
|
#include "backend.h"
|
|
#include "tree.h"
|
|
#include "hwint.h"
|
|
#include "gimple-pretty-print.h"
|
|
#include "is-a.h"
|
|
#include "vec.h"
|
|
#include "hash-map.h"
|
|
#include "hash-set.h"
|
|
#include "stddef.h"
|
|
|
|
/* Enum used for identifying the class of the bit. */
|
|
|
|
enum value_type {
|
|
SYMBOLIC_BIT,
|
|
BIT,
|
|
BIT_XOR_EXPRESSION,
|
|
BIT_AND_EXPRESSION,
|
|
BIT_OR_EXPRESSION,
|
|
BIT_COMPLEMENT_EXPRESSION,
|
|
SHIFT_RIGHT_EXPRESSION,
|
|
SHIFT_LEFT_EXPRESSION,
|
|
ADD_EXPRESSION,
|
|
SUB_EXPRESSION,
|
|
BIT_CONDITION
|
|
};
|
|
|
|
|
|
/* Base class for single bit value. */
|
|
|
|
class value_bit {
|
|
protected:
|
|
/* This will help us to understand where is moved the bit
|
|
from its initial position. */
|
|
const size_t m_index;
|
|
|
|
/* Type of the bit. Used by type checkers. */
|
|
value_type m_type;
|
|
|
|
public:
|
|
|
|
/* Default constructor. Sets m_index 0. */
|
|
value_bit () : m_index (0)
|
|
{};
|
|
|
|
/* Constructor that sets m_index to the specified value. */
|
|
value_bit (size_t i) : m_index (i)
|
|
{};
|
|
|
|
/* Copy constructor for value_bit. */
|
|
value_bit (const value_bit &val) : m_index (val.m_index)
|
|
{};
|
|
|
|
/* Returns the bit's initial index in bit-vector. */
|
|
size_t get_index () const;
|
|
|
|
/* Returns type of the bit. */
|
|
value_type get_type () const;
|
|
|
|
/* This will support deep copy of objects' values. */
|
|
virtual value_bit *copy () const = 0;
|
|
|
|
/* Prints the bit. Inherited classes must implement it. */
|
|
virtual void print () = 0;
|
|
|
|
/* Destructor. */
|
|
virtual ~value_bit () = default;
|
|
};
|
|
|
|
|
|
/* Represents value of a single bit of symbolic marked variables. */
|
|
|
|
class symbolic_bit : public value_bit {
|
|
/* The Origin of the bit. */
|
|
tree m_origin = nullptr;
|
|
|
|
public:
|
|
/* Constructor that sets the bit's initial position and its origin. */
|
|
symbolic_bit (size_t i, tree orig);
|
|
|
|
/* Copy constructor for symbolic_bit. */
|
|
symbolic_bit (const symbolic_bit &sym_bit) : symbolic_bit (sym_bit.m_index,
|
|
sym_bit.m_origin)
|
|
{};
|
|
|
|
/* Returns a copy of the bit. */
|
|
value_bit *copy () const;
|
|
|
|
/* Prints the bit. */
|
|
void print ();
|
|
|
|
/* Returns the origin of the bit, to whom it belongs. */
|
|
tree get_origin ();
|
|
};
|
|
|
|
|
|
/* Represents value of a single bit. */
|
|
|
|
class bit : public value_bit {
|
|
private:
|
|
/* This is the value of a bit. It must be either 1 or 0. */
|
|
unsigned char m_val = 0;
|
|
|
|
public:
|
|
/* Constructor that sets m_val to the specified value. */
|
|
bit (unsigned char i);
|
|
|
|
/* Copy constructor for bit. */
|
|
bit (const bit &b) : bit (b.m_val)
|
|
{};
|
|
|
|
/* Returns the value of the bit. */
|
|
unsigned char get_val () const;
|
|
|
|
/* Sets the value of the bit. */
|
|
void set_val (unsigned char new_val);
|
|
|
|
/* Return a copy of the bit. */
|
|
value_bit *copy () const;
|
|
|
|
/* Prints the bit. */
|
|
void print ();
|
|
};
|
|
|
|
|
|
/* Bit-level base expression class. In general expressions consist of
|
|
two operands. Here we named them m_left and m_right. */
|
|
|
|
class bit_expression : public value_bit {
|
|
protected:
|
|
/* The bit left to the expression sign. */
|
|
value_bit *m_left = nullptr;
|
|
|
|
/* The bit right to the expression sign. */
|
|
value_bit *m_right = nullptr;
|
|
|
|
/* Copies the given expression to it by copying
|
|
the left and right operands. */
|
|
void copy (const bit_expression *expr);
|
|
|
|
/* Depending on the expression, prints its sign. */
|
|
virtual void print_expr_sign ();
|
|
|
|
public:
|
|
|
|
/* Returns left operand of the expression. */
|
|
value_bit *get_left ();
|
|
|
|
/* Returns right operand of the expression. */
|
|
value_bit *get_right ();
|
|
|
|
/* Destructor for bit_expression. */
|
|
~bit_expression ();
|
|
|
|
/* Sets left operand of the expression. */
|
|
void set_left (value_bit *expr);
|
|
|
|
/* Sets right operand of the expression. */
|
|
void set_right (value_bit *expr);
|
|
|
|
/* Returns a deep copy of the expression. */
|
|
value_bit *copy () const = 0;
|
|
|
|
/* Prints the expression. */
|
|
void print ();
|
|
};
|
|
|
|
|
|
/* Bit-level XOR expression. XOR operation on two variables (when one of
|
|
them is symbolic) can be represented by XOR operations on
|
|
each of their bits. */
|
|
|
|
class bit_xor_expression : public bit_expression {
|
|
public:
|
|
/* Constructor that sets the left and right side bits
|
|
of the bit_xor_expression sign. */
|
|
bit_xor_expression (value_bit *left, value_bit *right);
|
|
|
|
/* Copy constructor for bit_xor_expression. */
|
|
bit_xor_expression (const bit_xor_expression &expr);
|
|
|
|
/* Returns a copy of the expression. */
|
|
value_bit *copy () const;
|
|
};
|
|
|
|
|
|
/* Bit-level AND expression. AND operation on two variables (when one of
|
|
them is symbolic) can be represented by AND operations on
|
|
each of their bits. */
|
|
|
|
class bit_and_expression : public bit_expression {
|
|
public:
|
|
/* Constructor that sets the left and right side bits
|
|
of the bit_and_expression sign. */
|
|
bit_and_expression (value_bit *left, value_bit *right);
|
|
|
|
/* Copy constructor for bit_and_expression. */
|
|
bit_and_expression (const bit_and_expression &expr);
|
|
|
|
/* Returns a copy of the expression. */
|
|
value_bit *copy () const;
|
|
};
|
|
|
|
|
|
/* Bit-level OR expression. OR operation on two variables (when one of
|
|
them is symbolic) can be represented by OR operations on
|
|
each of their bits. */
|
|
|
|
class bit_or_expression : public bit_expression {
|
|
public:
|
|
/* Constructor that sets the left and right side bits
|
|
of the bit_or_expression sign. */
|
|
bit_or_expression (value_bit *left, value_bit *right);
|
|
|
|
/* Copy constructor for bit_or_expression. */
|
|
bit_or_expression (const bit_or_expression &expr);
|
|
|
|
/* Returns a copy of the expression. */
|
|
value_bit *copy () const;
|
|
};
|
|
|
|
|
|
/* SHIFT_RIGHT expression. Result must be stored bit by bit. */
|
|
|
|
class shift_right_expression : public bit_expression {
|
|
public:
|
|
/* Constructor that sets the left and right side bits
|
|
of the shift_right_expression sign. */
|
|
shift_right_expression (value_bit *left, value_bit *right);
|
|
|
|
/* Copy constructor for shift_right_expression. */
|
|
shift_right_expression (const shift_right_expression &expr);
|
|
|
|
/* Returns a copy of the expression. */
|
|
value_bit *copy () const;
|
|
};
|
|
|
|
|
|
/* SHIFT_LEFT expression. Result must be stored bit by bit. */
|
|
|
|
class shift_left_expression : public bit_expression {
|
|
public:
|
|
/* Constructor that sets the left and right side bits
|
|
of the shift_left_expression sign. */
|
|
shift_left_expression (value_bit *left, value_bit *right);
|
|
|
|
/* Copy constructor for shift_left_expression. */
|
|
shift_left_expression (const shift_left_expression &expr);
|
|
|
|
/* Returns a copy of the expression. */
|
|
value_bit *copy () const;
|
|
};
|
|
|
|
|
|
/* ADD expression. Result must be stored bit by bit. */
|
|
|
|
class add_expression : public bit_expression {
|
|
public:
|
|
/* Constructor that sets the left and right side bits
|
|
of the add_expression sign. */
|
|
add_expression (value_bit *left, value_bit *right);
|
|
|
|
/* Copy constructor for add_expression. */
|
|
add_expression (const add_expression &expr);
|
|
|
|
/* Returns a copy of the expression. */
|
|
value_bit *copy () const;
|
|
};
|
|
|
|
|
|
/* SUB expression. Result must be stored bit by bit. */
|
|
|
|
class sub_expression : public bit_expression {
|
|
public:
|
|
/* Constructor that sets the left and right side bits
|
|
of the sub_expression sign. */
|
|
sub_expression (value_bit *left, value_bit *right);
|
|
|
|
/* Copy constructor for sub_expression. */
|
|
sub_expression (const sub_expression &expr);
|
|
|
|
/* Returns a copy of the expression. */
|
|
value_bit *copy () const;
|
|
};
|
|
|
|
|
|
/* Bit-level negation expression. */
|
|
|
|
class bit_complement_expression : public bit_expression {
|
|
public:
|
|
/* Constructor that sets the left and right side bits
|
|
of the bit_complement_expression sign. */
|
|
bit_complement_expression (value_bit *right);
|
|
|
|
/* Copy constructor for bit_complement_expression. */
|
|
bit_complement_expression (const bit_complement_expression &expr);
|
|
|
|
/* Returns a copy of the expression. */
|
|
value_bit *copy () const;
|
|
|
|
/* Prints the expression. */
|
|
void print ();
|
|
};
|
|
|
|
#endif /* SYM_EXEC_EXPRESSION_H. */
|