Switch to standard integer types in courgette/.

courgette/adjustment_method.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 <list>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "courgette/assembly_program.h"
 #include "courgette/courgette.h"
 #include "courgette/encoded_program.h"
 
 namespace courgette {
 
 ////////////////////////////////////////////////////////////////////////////////
 
 class NullAdjustmentMethod : public AdjustmentMethod {
   bool Adjust(const AssemblyProgram& model, AssemblyProgram* program) {
     return true;
   }
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // The purpose of adjustment is to assign indexes to Labels of a program 'p' to
 // make the sequence of indexes similar to a 'model' program 'm'.  Labels
 // themselves don't have enough information to do this job, so we work with a
 // LabelInfo surrogate for each label.
 //
 class LabelInfo {
  public:
   Label* label_;              // The label that this info a surrogate for.
 
   // Information used only in debugging messages.
-  uint32 is_model_ : 1;       // Is the label in the model?
-  uint32 debug_index_ : 31;   // An unique small number for naming the label.
+  uint32_t is_model_ : 1;      // Is the label in the model?
+  uint32_t debug_index_ : 31;  // An unique small number for naming the label.
 
-  uint32 refs_;               // Number of times this Label is referenced.
+  uint32_t refs_;  // Number of times this Label is referenced.
 
   LabelInfo* assignment_;     // Label from other program corresponding to this.
 
   // LabelInfos are in a doubly linked list ordered by address (label_->rva_) so
   // we can quickly find Labels adjacent in address order.
   LabelInfo* next_addr_;      // Label(Info) at next highest address.
   LabelInfo* prev_addr_;      // Label(Info) at next lowest address.
 
-  std::vector<uint32> positions_;  // Offsets into the trace of references.
+  std::vector<uint32_t> positions_;  // Offsets into the trace of references.
 
   // Just a no-argument constructor and copy constructor.  Actual LabelInfo
   // objects are allocated in std::pair structs in a std::map.
   LabelInfo()
       : label_(NULL), is_model_(false), debug_index_(0), refs_(0),
         assignment_(NULL),
         next_addr_(NULL),
         prev_addr_(NULL) {}
 
  private:
@@ skipping 75 matching lines @@
   int count_;           // Frequency of this path in Trie.
   int length_;
   typedef std::map<LabelInfo*, Node*> Edges;
   Edges edges_;
   std::vector<int> places_;   // Indexes into sequence of this item.
   std::list<Node*> edges_in_frequency_order;
 
   bool in_queue_;
   bool Extended() const { return !edges_.empty(); }
 
-  uint32 Weight() const {
-    return  edges_in_frequency_order.front()->count_;
-  }
+  uint32_t Weight() const { return edges_in_frequency_order.front()->count_; }
 };
 
 static std::string ToString(Node* node) {
   std::vector<std::string> prefix;
   for (Node* n = node;  n->prev_;  n = n->prev_)
     prefix.push_back(ToString(n->in_edge_));
 
   std::string s;
   s += "{";
   const char* sep = "";
@@ skipping 18 matching lines @@
     if (a->count_ != b->count_)
       return  (a->count_) > (b->count_);
     return a->places_.at(0) < b->places_.at(0);  // Prefer first occuring.
   }
 };
 
 struct OrderNodeByWeightDecreasing {
   bool operator()(Node* a, Node* b) const {
     // (Maybe tie-break on total count, followed by lowest assigned node indexes
     // in path.)
-    uint32 a_weight = a->Weight();
-    uint32 b_weight = b->Weight();
+    uint32_t a_weight = a->Weight();
+    uint32_t b_weight = b->Weight();
     if (a_weight != b_weight)
       return a_weight > b_weight;
     if (a->length_ != b->length_)
       return a->length_ > b->length_;            // Prefer longer.
     return a->places_.at(0) < b->places_.at(0);  // Prefer first occuring.
   }
 };
 
 typedef std::set<Node*, OrderNodeByWeightDecreasing> NodeQueue;
 
@@ skipping 42 matching lines @@
     ExtendNode(node, p_trace_);
     // SkipCommittedLabels(node);
     if (node->edges_in_frequency_order.empty())
       return;
     node->in_queue_ = true;
     worklist_.insert(node);
   }
 
   void SkipCommittedLabels(Node* node) {
     ExtendNode(node, p_trace_);
-    uint32 skipped = 0;
+    uint32_t skipped = 0;
     while (!node->edges_in_frequency_order.empty() &&
            node->edges_in_frequency_order.front()->in_edge_->assignment_) {
       ++skipped;
       node->edges_in_frequency_order.pop_front();
     }
     if (skipped > 0)
       VLOG(4) << "Skipped " << skipped << " at " << ToString(node);
   }
 
   void TrySolveNode(Node* p_node) {
@@ skipping 146 matching lines @@
 
       AssignOne(p_info_prev, m_info_prev);
       VLOG(4) << "  Extending assignment <- " << ToString(p_info_prev) << " := "
               << ToString(m_info_prev);
 
       p_info_prev = p_info_prev_prev;
       m_info_prev = m_info_prev_prev;
     }
   }
 
-  uint32 TryExtendSequence(uint32 p_pos_start, uint32 m_pos_start) {
-    uint32 p_pos = p_pos_start + 1;
-    uint32 m_pos = m_pos_start + 1;
+  uint32_t TryExtendSequence(uint32_t p_pos_start, uint32_t m_pos_start) {
+    uint32_t p_pos = p_pos_start + 1;
+    uint32_t m_pos = m_pos_start + 1;
 
     while (p_pos < p_trace_.size()  &&  m_pos < m_trace_.size()) {
       LabelInfo* p_info = p_trace_[p_pos];
       LabelInfo* m_info = m_trace_[m_pos];
 
       // To match, either (1) both are assigned or (2) both are unassigned.
       if ((p_info->assignment_ == NULL) != (m_info->assignment_ == NULL))
         break;
 
       // If they are assigned, it needs to be consistent (same index).
@@ skipping 12 matching lines @@
       VLOG(4) << "    Extending assignment seq[+" << p_pos - p_pos_start
               << "] -> " << ToString(p_info) << " := " << ToString(m_info);
 
       ++p_pos;
       ++m_pos;
     }
 
     return p_pos - p_pos_start;
   }
 
-  uint32 TryExtendSequenceBackwards(uint32 p_pos_start, uint32 m_pos_start) {
+  uint32_t TryExtendSequenceBackwards(uint32_t p_pos_start,
+                                      uint32_t m_pos_start) {
     if (p_pos_start == 0  ||  m_pos_start == 0)
       return 0;
 
-    uint32 p_pos = p_pos_start - 1;
-    uint32 m_pos = m_pos_start - 1;
+    uint32_t p_pos = p_pos_start - 1;
+    uint32_t m_pos = m_pos_start - 1;
 
     while (p_pos > 0  &&  m_pos > 0) {
       LabelInfo* p_info = p_trace_[p_pos];
       LabelInfo* m_info = m_trace_[m_pos];
 
       if ((p_info->assignment_ == NULL) != (m_info->assignment_ == NULL))
         break;
 
       if (p_info->assignment_ && m_info->assignment_) {
         if (p_info->label_->index_ != m_info->label_->index_)
@@ skipping 40 matching lines @@
       VLOG(3) << "Expected defined edge in parent";
       return NULL;
     }
 
     return e->second;
   }
 
   Node* MakeRootNode(const Trace& trace) {
     Node* node = new Node(NULL, NULL);
     all_nodes_.push_back(node);
-    for (uint32 i = 0;  i < trace.size();  ++i) {
+    for (uint32_t i = 0; i < trace.size(); ++i) {
       ++node->count_;
       node->places_.push_back(i);
     }
     return node;
   }
 
   void ExtendNode(Node* node, const Trace& trace) {
     // Make sure trie is filled in at this node.
     if (node->Extended())
       return;
     for (size_t i = 0; i < node->places_.size();  ++i) {
-      uint32 index = node->places_.at(i);
+      uint32_t index = node->places_.at(i);
       if (index < trace.size()) {
         LabelInfo* item = trace.at(index);
         Node*& slot = node->edges_[item];
         if (slot == NULL) {
           slot = new Node(item, node);
           all_nodes_.push_back(slot);
           node->edges_in_frequency_order.push_back(slot);
         }
         slot->places_.push_back(index + 1);
         ++slot->count_;
@@ skipping 78 matching lines @@
       if (prev) prev->next_addr_ = curr;
       curr->prev_addr_ = prev;
       prev = curr;
 
       if (curr->positions_.size() != curr->refs_)
         NOTREACHED();
     }
   }
 
   void ReferenceLabel(Trace* trace, Label* label, bool is_model) {
-    trace->push_back(MakeLabelInfo(label, is_model,
-                                   static_cast<uint32>(trace->size())));
+    trace->push_back(
+        MakeLabelInfo(label, is_model, static_cast<uint32_t>(trace->size())));
   }
 
-  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 33 matching lines @@
   AdjustmentMethod* method = AdjustmentMethod::MakeProductionAdjustmentMethod();
   bool ok = method->Adjust(model, program);
   method->Destroy();
   if (ok)
     return C_OK;
   else
     return C_ADJUSTMENT_FAILED;
 }
 
 }  // namespace courgette