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)

[Peter Kasting, 2014/09/30 00:08:01]

These changes follow from the API change to EmitBytesInstruction().

       : 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 139 matching lines @@
   EncodedProgram *encoded = program->Encode();
   if (encoded) {
     *output = encoded;
     return C_OK;
   } else {
     return C_GENERAL_ERROR;
   }
 }
 
 }  // namespace courgette