[clang] Use -Wshorten-64-to-32 to enable warnings about 64bit to 32bit truncations.

src/gdb-jit.cc

 // Copyright 2010 the V8 project 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 "src/v8.h"
 
 #include "src/base/bits.h"
 #include "src/base/platform/platform.h"
 #include "src/bootstrapper.h"
 #include "src/compiler.h"
@@ skipping 161 matching lines @@
 
 template<typename THeader>
 class DebugSectionBase : public ZoneObject {
  public:
   virtual ~DebugSectionBase() { }
 
   virtual void WriteBody(Writer::Slot<THeader> header, Writer* writer) {
     uintptr_t start = writer->position();
     if (WriteBodyInternal(writer)) {
       uintptr_t end = writer->position();
-      header->offset = start;
+      header->offset = static_cast<uint32_t>(start);
 #if defined(__MACH_O)
       header->addr = 0;
 #endif
       header->size = end - start;
     }
   }
 
   virtual bool WriteBodyInternal(Writer* writer) {
     return false;
   }
@@ skipping 265 matching lines @@
 
   Writer* writer_;
 
   uintptr_t offset_;
   uintptr_t size_;
 };
 
 
 void ELFSection::PopulateHeader(Writer::Slot<ELFSection::Header> header,
                                 ELFStringTable* strtab) {
-  header->name = strtab->Add(name_);
+  header->name = static_cast<uint32_t>(strtab->Add(name_));
   header->type = type_;
   header->alignment = align_;
   PopulateHeader(header);
 }
 #endif  // defined(__ELF)
 
 
 #if defined(__MACH_O)
 class MachO BASE_EMBEDDED {
  public:
@@ skipping 327 matching lines @@
     uint8_t info;
     uint8_t other;
     uint16_t section;
     uintptr_t value;
     uintptr_t size;
   };
 #endif
 
   void Write(Writer::Slot<SerializedLayout> s, ELFStringTable* t) {
     // Convert symbol names from strings to indexes in the string table.
-    s->name = t->Add(name);
+    s->name = static_cast<uint32_t>(t->Add(name));
     s->value = value;
     s->size = size;
     s->info = info;
     s->other = other;
     s->section = section;
   }
 
  private:
   const char* name;
   uintptr_t value;
@@ skipping 804 matching lines @@
                                     int initial_position) {
   uint32_t align = (w->position() - initial_position) % kPointerSize;
 
   if (align != 0) {
     for (uint32_t i = 0; i < (kPointerSize - align); i++) {
       w->Write<uint8_t>(DW_CFA_NOP);
     }
   }
 
   DCHECK((w->position() - initial_position) % kPointerSize == 0);
-  length_slot->set(w->position() - initial_position);
+  length_slot->set(static_cast<uint32_t>(w->position() - initial_position));
 }
 
 
 UnwindInfoSection::UnwindInfoSection(CodeDescription* desc)
 #ifdef __ELF
     : ELFSection(".eh_frame", TYPE_X86_64_UNWIND, 1),
 #else
     : MachOSection("__eh_frame", "__TEXT", sizeof(uintptr_t),
                    MachOSection::S_REGULAR),
 #endif
       desc_(desc) { }
 
 int UnwindInfoSection::WriteCIE(Writer* w) {
   Writer::Slot<uint32_t> cie_length_slot = w->CreateSlotHere<uint32_t>();
-  uint32_t cie_position = w->position();
+  uint32_t cie_position = static_cast<uint32_t>(w->position());
 
   // Write out the CIE header. Currently no 'common instructions' are
   // emitted onto the CIE; every FDE has its own set of instructions.
 
   w->Write<uint32_t>(CIE_ID);
   w->Write<uint8_t>(CIE_VERSION);
   w->Write<uint8_t>(0);  // Null augmentation string.
   w->WriteSLEB128(CODE_ALIGN_FACTOR);
   w->WriteSLEB128(DATA_ALIGN_FACTOR);
   w->Write<uint8_t>(RETURN_ADDRESS_REGISTER);
 
   WriteLength(w, &cie_length_slot, cie_position);
 
   return cie_position;
 }
 
 
 void UnwindInfoSection::WriteFDE(Writer* w, int cie_position) {
   // The only FDE for this function. The CFA is the current RBP.
   Writer::Slot<uint32_t> fde_length_slot = w->CreateSlotHere<uint32_t>();
-  int fde_position = w->position();
+  int fde_position = static_cast<uint32_t>(w->position());
   w->Write<int32_t>(fde_position - cie_position + 4);
 
   w->Write<uintptr_t>(desc_->CodeStart());
   w->Write<uintptr_t>(desc_->CodeSize());
 
   WriteFDEStateOnEntry(w);
   WriteFDEStateAfterRBPPush(w);
   WriteFDEStateAfterRBPSet(w);
   WriteFDEStateAfterRBPPop(w);
 
@@ skipping 372 matching lines @@
                             JITCodeEntry* entry, bool dump_if_enabled,
                             const char* name_hint) {
 #if defined(DEBUG) && !V8_OS_WIN
   static int file_num = 0;
   if (FLAG_gdbjit_dump && dump_if_enabled) {
     static const int kMaxFileNameSize = 64;
     char file_name[64];
 
     SNPrintF(Vector<char>(file_name, kMaxFileNameSize), "/tmp/elfdump%s%d.o",
              (name_hint != NULL) ? name_hint : "", file_num++);
-    WriteBytes(file_name, entry->symfile_addr_, entry->symfile_size_);
+    WriteBytes(file_name, entry->symfile_addr_,
+               static_cast<int>(entry->symfile_size_));
   }
 #endif
 
   CodeMap::Locator cur;
   CHECK(map->Insert(range, &cur));
   cur.set_value(entry);
 
   RegisterCodeEntry(entry);
 }
 
@@ skipping 78 matching lines @@
       LineInfo* line_info = reinterpret_cast<LineInfo*>(event->user_data);
       PutLineInfo(reinterpret_cast<Address>(event->code_start), line_info);
       break;
     }
   }
 }
 #endif
 }  // namespace GDBJITInterface
 }  // namespace internal
 }  // namespace v8