Switch to standard integer types in courgette/.

courgette/adjustment_method_2.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "courgette/adjustment_method.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 #include <limits>
 #include <list>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "courgette/assembly_program.h"
 #include "courgette/courgette.h"
 #include "courgette/encoded_program.h"
 
 /*
 
 Shingle weighting matching.
 
@@ skipping 141 matching lines @@
       : label_(NULL), is_model_(false), debug_index_(0), refs_(0),
         assignment_(NULL), candidates_(NULL)
   {}
 
   ~LabelInfo();
 
   AssignmentCandidates* candidates();
 
   Label* label_;             // The label that this info a surrogate for.
 
-  uint32 is_model_ : 1;      // Is the label in the model?
-  uint32 debug_index_ : 31;  // A small number for naming the label in debug
-                             // output. The pair (is_model_, debug_index_) is
-                             // unique.
+  uint32_t is_model_ : 1;      // Is the label in the model?
+  uint32_t debug_index_ : 31;  // A small number for naming the label in debug
+                               // output. The pair (is_model_, debug_index_) is
+                               // unique.
 
   int refs_;                 // Number of times this Label is referenced.
 
   LabelInfo* assignment_;    // Label from other program corresponding to this.
 
-  std::vector<uint32> positions_;  // Offsets into the trace of references.
+  std::vector<uint32_t> positions_;  // Offsets into the trace of references.
 
  private:
   AssignmentCandidates* candidates_;
 
   void operator=(const LabelInfo*);  // Disallow assignment only.
   // Public compiler generated copy constructor is needed to constuct
   // std::pair<Label*, LabelInfo> so that fresh LabelInfos can be allocated
   // inside a std::map.
 };
 
 typedef std::vector<LabelInfo*> Trace;
 
 std::string ToString(const LabelInfo* info) {
   std::string s;
   base::StringAppendF(&s, "%c%d", "pm"[info->is_model_], info->debug_index_);
   if (info->label_->index_ != Label::kNoIndex)
     base::StringAppendF(&s, " (%d)", info->label_->index_);
 
   base::StringAppendF(&s, " #%u", info->refs_);
   return s;
 }
 
 // LabelInfoMaker maps labels to their surrogate LabelInfo objects.
 class LabelInfoMaker {
  public:
   LabelInfoMaker() : debug_label_index_gen_(0) {}
 
-  LabelInfo* MakeLabelInfo(Label* label, bool is_model, uint32 position) {
+  LabelInfo* MakeLabelInfo(Label* label, bool is_model, uint32_t position) {
     LabelInfo& slot = label_infos_[label];
     if (slot.label_ == NULL) {
       slot.label_ = label;
       slot.is_model_ = is_model;
       slot.debug_index_ = ++debug_label_index_gen_;
     }
     slot.positions_.push_back(position);
     ++slot.refs_;
     return &slot;
   }
@@ skipping 130 matching lines @@
 
 LabelInfo::~LabelInfo() {
   delete candidates_;
 }
 
 // A Shingle is a short fixed-length string of LabelInfos that actually occurs
 // in a Trace.  A Shingle may occur many times.  We repesent the Shingle by the
 // position of one of the occurrences in the Trace.
 class Shingle {
  public:
-  static const uint8 kWidth = 5;
+  static const uint8_t kWidth = 5;
 
   struct InterningLess {
     bool operator()(const Shingle& a, const Shingle& b) const;
   };
 
   typedef std::set<Shingle, InterningLess> OwningSet;
 
   static Shingle* Find(const Trace& trace, size_t position,
                        OwningSet* owning_set) {
     std::pair<OwningSet::iterator, bool> pair =
         owning_set->insert(Shingle(trace, position));
     // pair.first iterator 'points' to the newly inserted Shingle or the
     // previouly inserted one that looks the same according to the comparator.
 
     // const_cast required because key is const.  We modify the Shingle
     // extensively but not in a way that affects InterningLess.
     Shingle* shingle = const_cast<Shingle*>(&*pair.first);
     shingle->add_position(position);
     return shingle;
   }
 
   LabelInfo* at(size_t i) const { return trace_[exemplar_position_ + i]; }
   void add_position(size_t position) {
-    positions_.push_back(static_cast<uint32>(position));
+    positions_.push_back(static_cast<uint32_t>(position));
   }
   int position_count() const { return static_cast<int>(positions_.size()); }
 
   bool InModel() const { return at(0)->is_model_; }
 
   ShinglePattern* pattern() const { return pattern_; }
   void set_pattern(ShinglePattern* pattern) { pattern_ = pattern; }
 
   struct PointerLess {
     bool operator()(const Shingle* a, const Shingle* b) const {
       // Arbitrary but repeatable (memory-address) independent ordering:
       return a->exemplar_position_ < b->exemplar_position_;
       // return InterningLess()(*a, *b);
     }
   };
 
  private:
   Shingle(const Trace& trace, size_t exemplar_position)
       : trace_(trace),
         exemplar_position_(exemplar_position),
         pattern_(NULL) {
   }
 
   const Trace& trace_;             // The shingle lives inside trace_.
   size_t exemplar_position_;       // At this position (and other positions).
-  std::vector<uint32> positions_;  // Includes exemplar_position_.
+  std::vector<uint32_t> positions_;  // Includes exemplar_position_.
 
   ShinglePattern* pattern_;       // Pattern changes as LabelInfos are assigned.
 
   friend std::string ToString(const Shingle* instance);
 
   // We can't disallow the copy constructor because we use std::set<Shingle> and
   // VS2005's implementation of std::set<T>::set() requires T to have a copy
   // constructor.
   //   DISALLOW_COPY_AND_ASSIGN(Shingle);
   void operator=(const Shingle&);  // Disallow assignment only.
 };
 
 std::string ToString(const Shingle* instance) {
   std::string s;
   const char* sep = "<";
-  for (uint8 i = 0; i < Shingle::kWidth; ++i) {
+  for (uint8_t i = 0; i < Shingle::kWidth; ++i) {
     // base::StringAppendF(&s, "%s%x ", sep, instance.at(i)->label_->rva_);
     s += sep;
     s += ToString(instance->at(i));
     sep = ", ";
   }
   base::StringAppendF(&s, ">(%" PRIuS ")@{%d}",
                       instance->exemplar_position_,
                       instance->position_count());
   return s;
 }
 
 
 bool Shingle::InterningLess::operator()(
     const Shingle& a,
     const Shingle& b) const {
-  for (uint8 i = 0; i < kWidth; ++i) {
+  for (uint8_t i = 0; i < kWidth; ++i) {
     LabelInfo* info_a = a.at(i);
     LabelInfo* info_b = b.at(i);
     if (info_a->label_->rva_ < info_b->label_->rva_)
       return true;
     if (info_a->label_->rva_ > info_b->label_->rva_)
       return false;
     if (info_a->is_model_ < info_b->is_model_)
       return true;
     if (info_a->is_model_ > info_b->is_model_)
       return false;
@@ skipping 11 matching lines @@
          kVariable = 8     // kind & kVariable == 1  => variable.
          };
   // sequence[position + (kinds_[i] & kOffsetMask)] gives LabelInfo for position
   // i of shingle.  Below, second 'A' is duplicate of position 1, second '102'
   // is duplicate of position 0.
   //
   //   <102, A, 103, A , 102>
   //      --> <kFixed+0, kVariable+1, kFixed+2, kVariable+1, kFixed+0>
   struct Index {
     explicit Index(const Shingle* instance);
-    uint8 kinds_[Shingle::kWidth];
-    uint8 variables_;
-    uint8 unique_variables_;
-    uint8 first_variable_index_;
-    uint32 hash_;
+    uint8_t kinds_[Shingle::kWidth];
+    uint8_t variables_;
+    uint8_t unique_variables_;
+    uint8_t first_variable_index_;
+    uint32_t hash_;
     int assigned_indexes_[Shingle::kWidth];
   };
 
   // ShinglePattern keeps histograms of member Shingle instances, ordered by
   // decreasing number of occurrences.  We don't have a pair (occurrence count,
   // Shingle instance), so we use a FreqView adapter to make the instance
   // pointer look like the pair.
   class FreqView {
    public:
     explicit FreqView(const Shingle* instance) : instance_(instance) {}
@@ skipping 23 matching lines @@
   int program_coverage_;
 };
 
 std::string ToString(const ShinglePattern::Index* index) {
   std::string s;
   if (index == NULL) {
     s = "<null>";
   } else {
     base::StringAppendF(&s, "<%d: ", index->variables_);
     const char* sep = "";
-    for (uint8 i = 0; i < Shingle::kWidth; ++i) {
+    for (uint8_t i = 0; i < Shingle::kWidth; ++i) {
       s += sep;
       sep = ", ";
-      uint32 kind = index->kinds_[i];
+      uint32_t kind = index->kinds_[i];
       int offset = kind & ShinglePattern::kOffsetMask;
       if (kind & ShinglePattern::kVariable)
         base::StringAppendF(&s, "V%d", offset);
       else
         base::StringAppendF(&s, "%d", index->assigned_indexes_[offset]);
      }
     base::StringAppendF(&s, " %x", index->hash_);
     s += ">";
   }
   return s;
@@ skipping 72 matching lines @@
   s += HistogramToStringFull(pattern->program_histogram_, "    ", max);
   return s;
 }
 
 struct ShinglePatternIndexLess {
   bool operator()(const ShinglePattern::Index& a,
                   const ShinglePattern::Index& b) const {
     if (a.hash_ < b.hash_) return true;
     if (a.hash_ > b.hash_) return false;
 
-    for (uint8 i = 0; i < Shingle::kWidth; ++i) {
+    for (uint8_t i = 0; i < Shingle::kWidth; ++i) {
       if (a.kinds_[i] < b.kinds_[i]) return true;
       if (a.kinds_[i] > b.kinds_[i]) return false;
       if ((a.kinds_[i] & ShinglePattern::kVariable) == 0) {
         if (a.assigned_indexes_[i] < b.assigned_indexes_[i])
           return true;
         if (a.assigned_indexes_[i] > b.assigned_indexes_[i])
           return false;
       }
     }
     return false;
   }
 };
 
-static uint32 hash_combine(uint32 h, uint32 v) {
+static uint32_t hash_combine(uint32_t h, uint32_t v) {
   h += v;
   return (h * (37 + 0x0000d100)) ^ (h >> 13);
 }
 
 ShinglePattern::Index::Index(const Shingle* instance) {
-  uint32 hash = 0;
+  uint32_t hash = 0;
   variables_ = 0;
   unique_variables_ = 0;
   first_variable_index_ = 255;
 
-  for (uint8 i = 0; i < Shingle::kWidth; ++i) {
+  for (uint8_t i = 0; i < Shingle::kWidth; ++i) {
     LabelInfo* info = instance->at(i);
-    uint8 kind = 0;
+    uint8_t kind = 0;
     int code = -1;
-    uint8 j = 0;
+    uint8_t j = 0;
     for ( ; j < i; ++j) {
       if (info == instance->at(j)) {  // Duplicate LabelInfo
         kind = kinds_[j];
         break;
       }
     }
     if (j == i) {  // Not found above.
       if (info->assignment_) {
         code = info->label_->index_;
         assigned_indexes_[i] = code;
@@ skipping 270 matching lines @@
     for (Shingle::OwningSet::iterator p = shingle_instances_.begin();
          p != shingle_instances_.end();
          ++p) {
       // GCC's set<T>::iterator::operator *() returns a const object.
       Reclassify(const_cast<Shingle*>(&*p));
     }
   }
 
   // For the positions in |info|, find the shingles that overlap that position.
   void AddAffectedPositions(LabelInfo* info, ShingleSet* affected_shingles) {
-    const uint8 kWidth = Shingle::kWidth;
+    const uint8_t kWidth = Shingle::kWidth;
     for (size_t i = 0;  i < info->positions_.size();  ++i) {
       size_t position = info->positions_[i];
       // Find bounds to the subrange of |trace_| we are in.
       size_t start = position < model_end_ ? 0 : model_end_;
       size_t end = position < model_end_ ? model_end_ : trace_.size();
 
       // Clip [position-kWidth+1, position+1)
       size_t low =
           position > start + kWidth - 1 ? position - kWidth + 1 : start;
       size_t high = position + kWidth < end ? position + 1 : end - kWidth + 1;
@@ skipping 96 matching lines @@
            program_iter != pattern->program_histogram_.end();
            ++program_iter) {
         if (++n_program_samples > kUnwieldy) break;
         const ShinglePattern::FreqView& program_freq = *program_iter;
         int p1 = program_freq.count();
         const Shingle* program_instance = program_freq.instance();
 
         // int score = p1;  // ? weigh all equally??
         int score = std::min(p1, m1);
 
-        for (uint8 i = 0; i < Shingle::kWidth; ++i) {
+        for (uint8_t i = 0; i < Shingle::kWidth; ++i) {
           LabelInfo* program_info = program_instance->at(i);
           LabelInfo* model_info = model_instance->at(i);
           if ((model_info->assignment_ == NULL) !=
               (program_info->assignment_ == NULL)) {
             VLOG(2) << "ERROR " << i
                     << "\n\t"  << ToString(pattern, 10)
                     << "\n\t" << ToString(program_instance)
                     << "\n\t" << ToString(model_instance);
           }
           if (!program_info->assignment_ && !model_info->assignment_) {
@@ skipping 195 matching lines @@
 
   void Solve(const Trace& model, size_t model_end) {
     base::Time start_time = base::Time::Now();
     AssignmentProblem a(model, model_end);
     a.Solve();
     VLOG(1) << " Adjuster::Solve "
             << (base::Time::Now() - start_time).InSecondsF();
   }
 
   void ReferenceLabel(Trace* trace, Label* label, bool is_model) {
-    trace->push_back(
-        label_info_maker_.MakeLabelInfo(label, is_model,
-                                        static_cast<uint32>(trace->size())));
+    trace->push_back(label_info_maker_.MakeLabelInfo(
+        label, is_model, static_cast<uint32_t>(trace->size())));
   }
 
   AssemblyProgram* prog_;         // Program to be adjusted, owned by caller.
   const AssemblyProgram* model_;  // Program to be mimicked, owned by caller.
 
   LabelInfoMaker label_info_maker_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Adjuster);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 }  // namespace adjustment_method_2
 
 AdjustmentMethod* AdjustmentMethod::MakeShingleAdjustmentMethod() {
   return new adjustment_method_2::Adjuster();
 }
 
 }  // namespace courgette