Fixed arm disassembler build problems.

src/disasm-arm.cc

 // Copyright 2007-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 34 matching lines @@
 
 
 //------------------------------------------------------------------------------
 
 // Decoder decodes and disassembles instructions into an output buffer.
 // It uses the converter to convert register names and call destinations into
 // more informative description.
 class Decoder {
  public:
   Decoder(const disasm::NameConverter& converter,
-          char* out_buffer, const int out_buffer_size)
+          v8::internal::Vector<char> out_buffer)
     : converter_(converter),
       out_buffer_(out_buffer),
-      out_buffer_size_(out_buffer_size),
       out_buffer_pos_(0) {
     ASSERT(out_buffer_size_ > 0);
     out_buffer_[out_buffer_pos_] = '\0';
   }
 
   ~Decoder() {}
 
   // Writes one disassembled instruction into 'buffer' (0-terminated).
   // Returns the length of the disassembled machine instruction in bytes.
   int InstructionDecode(byte* instruction);
 
  private:
   const disasm::NameConverter& converter_;
-  char* out_buffer_;
-  const int out_buffer_size_;
+  v8::internal::Vector<char> out_buffer_;
   int out_buffer_pos_;
 
   void PrintChar(const char ch);
   void Print(const char* str);
 
   void PrintRegister(int reg);
   void PrintCondition(Instr* instr);
   void PrintShiftRm(Instr* instr);
   void PrintShiftImm(Instr* instr);
 
@@ skipping 15 matching lines @@
 // Append the ch to the output buffer.
 void Decoder::PrintChar(const char ch) {
   ASSERT(out_buffer_pos_ < out_buffer_size_);
   out_buffer_[out_buffer_pos_++] = ch;
 }
 
 
 // Append the str to the output buffer.
 void Decoder::Print(const char* str) {
   char cur = *str++;
-  while (cur != 0 && (out_buffer_pos_ < (out_buffer_size_-1))) {
+  while (cur != 0 && (out_buffer_pos_ < (out_buffer_.length()-1))) {
     PrintChar(cur);
     cur = *str++;
   }
   out_buffer_[out_buffer_pos_] = 0;
 }
 
 
 static const char* cond_names[16] = {
 "eq", "ne", "cs" , "cc" , "mi" , "pl" , "vs" , "vc" ,
 "hi", "ls", "ge", "lt", "gt", "le", "", "invalid",
@@ skipping 32 matching lines @@
   }
   if (instr->RegShiftField() == 0) {
     // by immediate
     if ((shift == ROR) && (shift_amount == 0)) {
       Print(", RRX");
       return;
     } else if (((shift == LSR) || (shift == ASR)) && (shift_amount == 0)) {
       shift_amount = 32;
     }
     out_buffer_pos_ += v8i::OS::SNPrintF(out_buffer_ + out_buffer_pos_,
-                                         out_buffer_size_ - out_buffer_pos_,
                                          ", %s #%d",
                                          shift_names[shift], shift_amount);
   } else {
     // by register
     int rs = instr->RsField();
     out_buffer_pos_ += v8i::OS::SNPrintF(out_buffer_ + out_buffer_pos_,
-                                         out_buffer_size_ - out_buffer_pos_,
                                          ", %s ", shift_names[shift]);
     PrintRegister(rs);
   }
 }
 
 
 // Print the immediate operand for the instruction. Generally used for data
 // processing instructions.
 void Decoder::PrintShiftImm(Instr* instr) {
   int rotate = instr->RotateField() * 2;
   int immed8 = instr->Immed8Field();
   int imm = (immed8 >> rotate) | (immed8 << (32 - rotate));
   out_buffer_pos_ += v8i::OS::SNPrintF(out_buffer_ + out_buffer_pos_,
-                                       out_buffer_size_ - out_buffer_pos_,
                                        "#%d", imm);
 }
 
 
 // FormatOption takes a formatting string and interprets it based on
 // the current instructions. The format string points to the first
 // character of the option string (the option escape has already been
 // consumed by the caller.)  FormatOption returns the number of
 // characters that were consumed from the formatting string.
 int Decoder::FormatOption(Instr* instr, const char* format) {
@@ skipping 49 matching lines @@
           Print("ldr");
         } else {
           Print("str");
         }
         return 5;
       } else {
         ASSERT(format[1] == 's' && format[2] == 'g');
         byte* str =
             reinterpret_cast<byte*>(instr->InstructionBits() & 0x0fffffff);
         out_buffer_pos_ += v8i::OS::SNPrintF(out_buffer_ + out_buffer_pos_,
-                                             out_buffer_size_ - out_buffer_pos_,
                                              "%s", converter_.NameInCode(str));
         return 3;
       }
       break;
     }
     case 'o': {
       ASSERT(format[1] == 'f' && format[2] == 'f');
       if (format[3] == '1') {
         // 'off12: 12-bit offset for load and store instructions
         ASSERT(format[4] == '2');
         out_buffer_pos_ += v8i::OS::SNPrintF(out_buffer_ + out_buffer_pos_,
-                                             out_buffer_size_ - out_buffer_pos_,
                                              "%d", instr->Offset12Field());
         return 5;
       } else {
         // 'off8: 8-bit offset for extra load and store instructions
         ASSERT(format[3] == '8');
         int offs8 = (instr->ImmedHField() << 4) | instr->ImmedLField();
         out_buffer_pos_ += v8i::OS::SNPrintF(out_buffer_ + out_buffer_pos_,
-                                             out_buffer_size_ - out_buffer_pos_,
                                              "%d", offs8);
         return 4;
       }
       break;
     }
     case 'p': {  // 'pu: P and U bits for load and store instructions
       ASSERT(format[1] == 'u');
       switch (instr->PUField()) {
         case 0: {
           Print("da");
@@ skipping 76 matching lines @@
             break;
           case call_rt_r2:
             Print("call_rt_r2");
             break;
           case break_point:
             Print("break_point");
             break;
           default:
             out_buffer_pos_ += v8i::OS::SNPrintF(
                 out_buffer_ + out_buffer_pos_,
-                out_buffer_size_ - out_buffer_pos_,
                 "%d",
                 swi);
             break;
         }
         return 3;
       } else if (format[1] == 'i') {  // 'sign: signed extra loads and stores
         ASSERT(format[2] == 'g' && format[3] == 'n');
         if (instr->HasSign()) {
           Print("s");
         }
         return 4;
         break;
       } else {  // 's: S field of data processing instructions
         if (instr->HasS()) {
           Print("s");
         }
         return 1;
       }
       break;
     }
     case 't': {  // 'target: target of branch instructions
       ASSERT(format[1] == 'a' && format[2] == 'r' && format[3] == 'g'
              && format[4] == 'e' && format[5] == 't');
       int off = (instr->SImmed24Field() << 2) + 8;
       out_buffer_pos_ += v8i::OS::SNPrintF(
           out_buffer_ + out_buffer_pos_,
-          out_buffer_size_ - out_buffer_pos_,
           "%+d -> %s",
           off,
           converter_.NameOfAddress(reinterpret_cast<byte*>(instr) + off));
       return 6;
       break;
     }
     case 'u': {  // 'u: signed or unsigned multiplies
       if (instr->Bit(22) == 0) {
         Print("u");
       } else {
@@ skipping 17 matching lines @@
   UNREACHABLE();
   return -1;
 }
 
 
 // Format takes a formatting string for a whole instruction and prints it into
 // the output buffer. All escaped options are handed to FormatOption to be
 // parsed further.
 void Decoder::Format(Instr* instr, const char* format) {
   char cur = *format++;
-  while ((cur != 0) && (out_buffer_pos_ < (out_buffer_size_ - 1))) {
+  while ((cur != 0) && (out_buffer_pos_ < (out_buffer_.length() - 1))) {
     if (cur == '\'') {  // Single quote is used as the formatting escape.
       format += FormatOption(instr, format);
     } else {
       out_buffer_[out_buffer_pos_++] = cur;
     }
     cur = *format++;
   }
   ASSERT(out_buffer_pos_ < out_buffer_size_);
   out_buffer_[out_buffer_pos_]  = '\0';
 }
@@ skipping 351 matching lines @@
     Unknown(instr);
   }
 }
 
 
 // Disassemble the instruction at *instr_ptr into the output buffer.
 int Decoder::InstructionDecode(byte* instr_ptr) {
   Instr* instr = Instr::At(instr_ptr);
   // Print raw instruction bytes.
   out_buffer_pos_ += v8i::OS::SNPrintF(out_buffer_ + out_buffer_pos_,
-                                       out_buffer_size_ - out_buffer_pos_,
                                        "%08x       ",
                                        instr->InstructionBits());
   if (instr->ConditionField() == special_condition) {
     Format(instr, "break 'msg");
     return Instr::kInstrSize;
   }
   switch (instr->TypeField()) {
     case 0: {
       DecodeType0(instr);
       break;
@@ skipping 97 matching lines @@
 Disassembler::Disassembler() : converter_(defaultConverter) {}
 
 
 Disassembler::Disassembler(const NameConverter& converter)
     : converter_(converter) {}
 
 
 Disassembler::~Disassembler() {}
 
 
-int Disassembler::InstructionDecode(char* buffer, const int buffer_size,
+int Disassembler::InstructionDecode(v8::internal::Vector<char> buffer,
                                     byte* instruction) {
-  assembler::arm::Decoder d(converter_, buffer, buffer_size);
+  assembler::arm::Decoder d(converter_, buffer);
   return d.InstructionDecode(instruction);
 }
 
 
 int Disassembler::ConstantPoolSizeAt(byte* instruction) {
   int instruction_bits = *(reinterpret_cast<int*>(instruction));
   if ((instruction_bits & 0xfff00000) == 0x03000000) {
     return instruction_bits & 0x0000ffff;
   } else {
     return -1;
   }
 }
 
 
 void Disassembler::Disassemble(FILE* f, byte* begin, byte* end) {
   Disassembler d;
   for (byte* pc = begin; pc < end;) {
-    char buffer[128];
+    v8::internal::EmbeddedVector<char, 128> buffer;
     buffer[0] = '\0';
     byte* prev_pc = pc;
-    pc += d.InstructionDecode(buffer, sizeof buffer, pc);
+    pc += d.InstructionDecode(buffer, pc);
     fprintf(f, "%p    %08x      %s\n",
-            prev_pc, *reinterpret_cast<int32_t*>(prev_pc), buffer);
+            prev_pc, *reinterpret_cast<int32_t*>(prev_pc), buffer.start());
   }
 }
 
 
 }  // namespace disasm