X64: General fixes - added inline definitions and changed tome places to intptr_t.

src/disassembler.cc

 // Copyright 2006-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 25 matching lines @@
 #include "serialize.h"
 #include "string-stream.h"
 
 namespace v8 { namespace internal {
 
 #ifdef ENABLE_DISASSEMBLER
 
 void Disassembler::Dump(FILE* f, byte* begin, byte* end) {
   for (byte* pc = begin; pc < end; pc++) {
     if (f == NULL) {
-      PrintF("%p  %4d  %02x\n", pc, pc - begin, *pc);
+      PrintF("%"V8PRIp"  %4"V8PRId"  %02x\n", pc, pc - begin, *pc);

[Dean McNamee, 2009/05/12 08:22:40]

should we put space around these?  It looks weird, but I guess it will look
weird no matter what.

[Erik Corry, 2009/05/12 09:24:50]

I think the names are way too cryptic considering they are not used all that
many places.  The name V8PRId does not say "use this where you want to print a
ptrdiff_t" to me.  I would suggest something like POINTER_PRINT and
PTRDIFF_PRINT and as Dean says, normal spacing.

[Lasse Reichstein, 2009/05/12 10:32:51]

A quick look at what people do with PRId64 and likes from inttypes.h suggests
spaces around. I have added them where we have used the macro.

[Lasse Reichstein, 2009/05/12 10:32:51]

It shouldn't say "print a pointer difference". It should say "print a
pointer-size value as decimal". I admit that it doesn't say that either.
The corresponding standard macros are called, e.g., PRIdPTR, so we should call
it something like V8PRIdPTR for consistency.

     } else {
-      fprintf(f, "%p  %4d  %02x\n", pc, pc - begin, *pc);
+      fprintf(f, "%"V8PRIp"  %4"V8PRId"  %02x\n",
+              reinterpret_cast<uintptr_t>(pc), pc - begin, *pc);
     }
   }
 }
 
 
 class V8NameConverter: public disasm::NameConverter {
  public:
   explicit V8NameConverter(Code* code) : code_(code) {}
   virtual const char* NameOfAddress(byte* pc) const;
   virtual const char* NameInCode(byte* addr) const;
@@ skipping 78 matching lines @@
         OS::SNPrintF(decode_buffer,
                      "%08x       constant pool begin",
                      *reinterpret_cast<int32_t*>(pc));
         constants = num_const;
         pc += 4;
       } else if (it != NULL && !it->done() && it->rinfo()->pc() == pc &&
           it->rinfo()->rmode() == RelocInfo::INTERNAL_REFERENCE) {
         // raw pointer embedded in code stream, e.g., jump table
         byte* ptr = *reinterpret_cast<byte**>(pc);
         OS::SNPrintF(decode_buffer,
-                     "%08x      jump table entry %4d",
-                     reinterpret_cast<int32_t>(ptr),
+                     "%08"V8PRIp"      jump table entry %4"V8PRId,
+                     ptr,
                      ptr - begin);
         pc += 4;
       } else {
         decode_buffer[0] = '\0';
         pc += d.InstructionDecode(decode_buffer, pc);
       }
     }
 
     // Collect RelocInfo for this instruction (prev_pc .. pc-1)
     List<const char*> comments(4);
@@ skipping 141 matching lines @@
 
 #else  // ENABLE_DISASSEMBLER
 
 void Disassembler::Dump(FILE* f, byte* begin, byte* end) {}
 int Disassembler::Decode(FILE* f, byte* begin, byte* end) { return 0; }
 void Disassembler::Decode(FILE* f, Code* code) {}
 
 #endif  // ENABLE_DISASSEMBLER
 
 } }  // namespace v8::internal