Fix more MSVC warnings, courgette/ edition.

courgette/assembly_program.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/assembly_program.h"
 
 #include <memory.h>
 #include <algorithm>
 #include <map>
 #include <set>
@@ skipping 72 matching lines @@
 // Emits a single byte.
 class ByteInstruction : public Instruction {
  public:
   explicit ByteInstruction(uint8 value) : Instruction(DEFBYTE, value) {}
   uint8 byte_value() const { return info_; }
 };
 
 // Emits a single byte.
 class BytesInstruction : public Instruction {
  public:
-  BytesInstruction(const uint8* values, uint32 len)
+  BytesInstruction(const uint8* values, size_t len)
       : Instruction(DEFBYTES, 0),
         values_(values),
         len_(len) {}
   const uint8* byte_values() const { return values_; }
-  uint32 len() const { return len_; }
+  size_t len() const { return len_; }
 
  private:
   const uint8* values_;
-  uint32 len_;
+  size_t len_;
 };
 
 // A ABS32 to REL32 instruction emits a reference to a label's address.
 class InstructionWithLabel : public Instruction {
  public:
   InstructionWithLabel(OP op, Label* label)
     : Instruction(op, 0), label_(label) {
     if (label == NULL) NOTREACHED();
   }
   Label* label() const { return label_; }
@@ skipping 59 matching lines @@
 
 CheckBool AssemblyProgram::EmitOriginInstruction(RVA rva) {
   return Emit(new(std::nothrow) OriginInstruction(rva));
 }
 
 CheckBool AssemblyProgram::EmitByteInstruction(uint8 byte) {
   return Emit(GetByteInstruction(byte));
 }
 
 CheckBool AssemblyProgram::EmitBytesInstruction(const uint8* values,
-                                                uint32 len) {
+                                                size_t len) {
   return Emit(new(std::nothrow) BytesInstruction(values, len));
 }
 
 CheckBool AssemblyProgram::EmitRel32(Label* label) {
   return Emit(new(std::nothrow) InstructionWithLabel(REL32, label));
 }
 
 CheckBool AssemblyProgram::EmitRel32ARM(uint16 op, Label* label,
                                         const uint8* arm_op, uint16 op_size) {
   return Emit(new(std::nothrow) InstructionWithLabelARM(REL32ARM, op, label,
@@ skipping 221 matching lines @@
       }
       case DEFBYTE: {
         uint8 b = static_cast<ByteInstruction*>(instruction)->byte_value();
         if (!encoded->AddCopy(1, &b))
           return NULL;
         break;
       }
       case DEFBYTES: {
         const uint8* byte_values =
           static_cast<BytesInstruction*>(instruction)->byte_values();
-        uint32 len = static_cast<BytesInstruction*>(instruction)->len();
+        size_t len = static_cast<BytesInstruction*>(instruction)->len();
 
         if (!encoded->AddCopy(len, byte_values))
           return NULL;
         break;
       }
       case REL32: {
         Label* label = static_cast<InstructionWithLabel*>(instruction)->label();
         if (!encoded->AddRel32(label->index_))
           return NULL;
         break;
@@ skipping 105 matching lines @@
         break;
       }
       default:
         break;
     }
   }
 
   return true;
 }
 
-void AssemblyProgram::PrintLabelCounts(RVAToLabel* labels) {
-  for (RVAToLabel::const_iterator p = labels->begin(); p != labels->end();
-       ++p) {
-    Label* current = p->second;
-    if (current->index_ != Label::kNoIndex)
-      printf("%d\n", current->count_);
-  }
-}
-
-void AssemblyProgram::CountRel32ARM() {
-  PrintLabelCounts(&rel32_labels_);
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 
 Status TrimLabels(AssemblyProgram* program) {
   if (program->TrimLabels())
     return C_OK;
   else
     return C_TRIM_FAILED;
 }
 
 Status Encode(AssemblyProgram* program, EncodedProgram** output) {
   *output = NULL;
   EncodedProgram *encoded = program->Encode();
   if (encoded) {
     *output = encoded;
     return C_OK;
   } else {
     return C_GENERAL_ERROR;
   }
 }
 
 }  // namespace courgette