merge

diff --combined action.cc
index 9c0e29920e362f5d2a2fa7d3681077dad4b7690a,4e3b59a386dce2fc8e5aff8eff4cf778f7902c47..cfdb6e67469d67baa14f02cca00cc49c65e809f0
--- 1/action.cc
--- 2/action.cc
+++ b/action.cc
@@@ -32,55 -32,23 +32,55 @@@
   * (default), then a Thread is assigned according to the scheduler.
   */
  ModelAction::ModelAction(action_type_t type, memory_order order, void *loc,
 -              uint64_t value, Thread *thread) :
 +                                                                                               uint64_t value, Thread *thread) :
 +      location(loc),
 +      reads_from(NULL),
 +      last_fence_release(NULL),
 +      node(NULL),
 +      cv(NULL),
 +      value(value),
        type(type),
        order(order),
        original_order(order),
 +      seq_number(ACTION_INITIAL_CLOCK)
 +{
 +      /* References to NULL atomic variables can end up here */
 +      ASSERT(loc || type == ATOMIC_FENCE);
 +
 +      Thread *t = thread ? thread : thread_current();
 +      this->tid = t->get_id();
 +}
 +
 +
 +/**
 + * @brief Construct a new ModelAction
 + *
 + * @param type The type of action
 + * @param order The memory order of this action. A "don't care" for non-ATOMIC
 + * actions (e.g., THREAD_* or MODEL_* actions).
 + * @param loc The location that this action acts upon
 + * @param value (optional) A value associated with the action (e.g., the value
 + * read or written). Defaults to a given macro constant, for debugging purposes.
 + * @param size (optional) The Thread in which this action occurred. If NULL
 + * (default), then a Thread is assigned according to the scheduler.
 + */
 +ModelAction::ModelAction(action_type_t type, memory_order order, void *loc,
 +                                                                                               uint64_t value, int size) :
        location(loc),
 -      value(value),
        reads_from(NULL),
        last_fence_release(NULL),
        node(NULL),
 -      seq_number(ACTION_INITIAL_CLOCK),
        cv(NULL),
 -      sleep_flag(false)
 +      value(value),
 +      type(type),
 +      order(order),
 +      original_order(order),
 +      seq_number(ACTION_INITIAL_CLOCK)
  {
        /* References to NULL atomic variables can end up here */
 -      ASSERT(loc || type == ATOMIC_FENCE || type == MODEL_FIXUP_RELSEQ);
 -
 -      Thread *t = thread ? thread : thread_current();
 +      ASSERT(loc);
 +      this->size = size;
 +      Thread *t = thread_current();
        this->tid = t->get_id();
  }
  
@@@ -95,12 -63,8 +95,12 @@@ ModelAction::~ModelAction(
         */
  
        /*
 -       if (cv)
 -              delete cv; */
 +         if (cv)
 +              delete cv; */
 +}
 +
 +int ModelAction::getSize() const {
 +      return size;
  }
  
  void ModelAction::copy_from_new(ModelAction *newaction)
@@@ -126,6 -90,11 +126,6 @@@ bool ModelAction::is_thread_join() cons
        return type == THREAD_JOIN || type == PTHREAD_JOIN;
  }
  
 -bool ModelAction::is_relseq_fixup() const
 -{
 -      return type == MODEL_FIXUP_RELSEQ;
 -}
 -
  bool ModelAction::is_mutex_op() const
  {
        return type == ATOMIC_LOCK || type == ATOMIC_TRYLOCK || type == ATOMIC_UNLOCK || type == ATOMIC_WAIT || type == ATOMIC_NOTIFY_ONE || type == ATOMIC_NOTIFY_ALL;
@@@ -181,7 -150,7 +181,7 @@@ bool ModelAction::is_uninitialized() co
  
  bool ModelAction::is_read() const
  {
 -      return type == ATOMIC_READ || type == ATOMIC_RMWR || type == ATOMIC_RMW;
 +      return type == ATOMIC_READ || type == ATOMIC_RMWR || type == ATOMIC_RMWRCAS || type == ATOMIC_RMW;
  }
  
  bool ModelAction::is_write() const
@@@ -201,12 -170,7 +201,12 @@@ bool ModelAction::is_yield() cons
  
  bool ModelAction::is_rmwr() const
  {
 -      return type == ATOMIC_RMWR;
 +      return type == ATOMIC_RMWR || type == ATOMIC_RMWRCAS;
 +}
 +
 +bool ModelAction::is_rmwrcas() const
 +{
 +      return type == ATOMIC_RMWRCAS;
  }
  
  bool ModelAction::is_rmw() const
@@@ -465,7 -429,7 +465,8 @@@ uint64_t ModelAction::get_reads_from_va
        ASSERT(is_read());
        if (reads_from)
                return reads_from->get_write_value();
 -      return VALUE_NONE; /* Only for new actions with no reads-from */
++
 +      return VALUE_NONE;      // Only for new actions with no reads-from
  }
  
  /**
@@@ -523,7 -487,7 +524,7 @@@ void ModelAction::set_read_from(const M
  
        reads_from = act;
  
 -      if (act->is_uninitialized()) { // WL
 +      if (act->is_uninitialized()) {  // WL
                uint64_t val = *((uint64_t *) location);
                ModelAction * act_initialized = (ModelAction *)act;
                act_initialized->set_value(val);
@@@ -531,10 -495,10 +532,10 @@@
  
  // disabled by WL, because LLVM IR is unable to detect atomic init
  /*            model->assert_bug("May read from uninitialized atomic:\n"
 -                              "    action %d, thread %d, location %p (%s, %s)",
 -                              seq_number, id_to_int(tid), location,
 -                              get_type_str(), get_mo_str());
 -*/
 +                                "    action %d, thread %d, location %p (%s, %s)",
 +                                seq_number, id_to_int(tid), location,
 +                                get_type_str(), get_mo_str());
 + */
        }
  }
  
@@@ -571,44 -535,44 +572,44 @@@ bool ModelAction::happens_before(const 
  const char * ModelAction::get_type_str() const
  {
        switch (this->type) {
 -              case MODEL_FIXUP_RELSEQ: return "relseq fixup";
 -              case THREAD_CREATE: return "thread create";
 -              case THREAD_START: return "thread start";
 -              case THREAD_YIELD: return "thread yield";
 -              case THREAD_JOIN: return "thread join";
 -              case THREAD_FINISH: return "thread finish";
 -
 -              case PTHREAD_CREATE: return "pthread create";
 -              case PTHREAD_JOIN: return "pthread join";
 -
 -              case ATOMIC_UNINIT: return "uninitialized";
 -              case ATOMIC_READ: return "atomic read";
 -              case ATOMIC_WRITE: return "atomic write";
 -              case ATOMIC_RMW: return "atomic rmw";
 -              case ATOMIC_FENCE: return "fence";
 -              case ATOMIC_RMWR: return "atomic rmwr";
 -              case ATOMIC_RMWC: return "atomic rmwc";
 -              case ATOMIC_INIT: return "init atomic";
 -              case ATOMIC_LOCK: return "lock";
 -              case ATOMIC_UNLOCK: return "unlock";
 -              case ATOMIC_TRYLOCK: return "trylock";
 -              case ATOMIC_WAIT: return "wait";
 -              case ATOMIC_NOTIFY_ONE: return "notify one";
 -        case ATOMIC_NOTIFY_ALL: return "notify all";
 -        case ATOMIC_ANNOTATION: return "annotation";
 -              default: return "unknown type";
 +      case THREAD_CREATE: return "thread create";
 +      case THREAD_START: return "thread start";
 +      case THREAD_YIELD: return "thread yield";
 +      case THREAD_JOIN: return "thread join";
 +      case THREAD_FINISH: return "thread finish";
 +
 +      case PTHREAD_CREATE: return "pthread create";
 +      case PTHREAD_JOIN: return "pthread join";
 +
 +      case ATOMIC_UNINIT: return "uninitialized";
 +      case ATOMIC_READ: return "atomic read";
 +      case ATOMIC_WRITE: return "atomic write";
 +      case ATOMIC_RMW: return "atomic rmw";
 +      case ATOMIC_FENCE: return "fence";
 +      case ATOMIC_RMWR: return "atomic rmwr";
 +      case ATOMIC_RMWRCAS: return "atomic rmwrcas";
 +      case ATOMIC_RMWC: return "atomic rmwc";
 +      case ATOMIC_INIT: return "init atomic";
 +      case ATOMIC_LOCK: return "lock";
 +      case ATOMIC_UNLOCK: return "unlock";
 +      case ATOMIC_TRYLOCK: return "trylock";
 +      case ATOMIC_WAIT: return "wait";
 +      case ATOMIC_NOTIFY_ONE: return "notify one";
 +      case ATOMIC_NOTIFY_ALL: return "notify all";
 +      case ATOMIC_ANNOTATION: return "annotation";
 +      default: return "unknown type";
        };
  }
  
  const char * ModelAction::get_mo_str() const
  {
        switch (this->order) {
 -              case std::memory_order_relaxed: return "relaxed";
 -              case std::memory_order_acquire: return "acquire";
 -              case std::memory_order_release: return "release";
 -              case std::memory_order_acq_rel: return "acq_rel";
 -              case std::memory_order_seq_cst: return "seq_cst";
 -              default: return "unknown";
 +      case std::memory_order_relaxed: return "relaxed";
 +      case std::memory_order_acquire: return "acquire";
 +      case std::memory_order_release: return "release";
 +      case std::memory_order_acq_rel: return "acq_rel";
 +      case std::memory_order_seq_cst: return "seq_cst";
 +      default: return "unknown";
        }
  }
  
@@@ -618,7 -582,7 +619,7 @@@ void ModelAction::print() cons
        const char *type_str = get_type_str(), *mo_str = get_mo_str();
  
        model_print("%-4d %-2d   %-14s  %7s  %14p   %-#18" PRIx64,
 -                      seq_number, id_to_int(tid), type_str, mo_str, location, get_return_value());
 +                                                      seq_number, id_to_int(tid), type_str, mo_str, location, get_return_value());
        if (is_read()) {
                if (reads_from)
                        model_print("  %-3d", reads_from->get_seq_number());
@@@ -644,9 -608,9 +645,9 @@@ unsigned int ModelAction::hash() cons
        hash ^= id_to_int(tid) << 6;
  
        if (is_read()) {
 -             if (reads_from)
 -                     hash ^= reads_from->get_seq_number();
 -             hash ^= get_reads_from_value();
 +              if (reads_from)
 +                      hash ^= reads_from->get_seq_number();
 +              hash ^= get_reads_from_value();
        }
        return hash;
  }