Clean up the usage of V8_TARGET_ARCH_${arch} and V8_HOST_ARCH_${arch}

src/gdb-jit.cc

 // Copyright 2010 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 199 matching lines @@
     return false;
   }
 
   typedef THeader Header;
 };
 
 
 struct MachOSectionHeader {
   char sectname[16];
   char segname[16];
-#if defined(V8_TARGET_ARCH_IA32)
+#if V8_TARGET_ARCH_IA32
   uint32_t addr;
   uint32_t size;
 #else
   uint64_t addr;
   uint64_t size;
 #endif
   uint32_t offset;
   uint32_t align;
   uint32_t reloff;
   uint32_t nreloc;
@@ skipping 287 matching lines @@
 
  private:
   struct MachOHeader {
     uint32_t magic;
     uint32_t cputype;
     uint32_t cpusubtype;
     uint32_t filetype;
     uint32_t ncmds;
     uint32_t sizeofcmds;
     uint32_t flags;
-#if defined(V8_TARGET_ARCH_X64)
+#if V8_TARGET_ARCH_X64
     uint32_t reserved;
 #endif
   };
 
   struct MachOSegmentCommand {
     uint32_t cmd;
     uint32_t cmdsize;
     char segname[16];
-#if defined(V8_TARGET_ARCH_IA32)
+#if V8_TARGET_ARCH_IA32
     uint32_t vmaddr;
     uint32_t vmsize;
     uint32_t fileoff;
     uint32_t filesize;
 #else
     uint64_t vmaddr;
     uint64_t vmsize;
     uint64_t fileoff;
     uint64_t filesize;
 #endif
     uint32_t maxprot;
     uint32_t initprot;
     uint32_t nsects;
     uint32_t flags;
   };
 
   enum MachOLoadCommandCmd {
     LC_SEGMENT_32 = 0x00000001u,
     LC_SEGMENT_64 = 0x00000019u
   };
 
 
   Writer::Slot<MachOHeader> WriteHeader(Writer* w) {
     ASSERT(w->position() == 0);
     Writer::Slot<MachOHeader> header = w->CreateSlotHere<MachOHeader>();
-#if defined(V8_TARGET_ARCH_IA32)
+#if V8_TARGET_ARCH_IA32
     header->magic = 0xFEEDFACEu;
     header->cputype = 7;  // i386
     header->cpusubtype = 3;  // CPU_SUBTYPE_I386_ALL
-#elif defined(V8_TARGET_ARCH_X64)
+#elif V8_TARGET_ARCH_X64
     header->magic = 0xFEEDFACFu;
     header->cputype = 7 | 0x01000000;  // i386 | 64-bit ABI
     header->cpusubtype = 3;  // CPU_SUBTYPE_I386_ALL
     header->reserved = 0;
 #else
 #error Unsupported target architecture.
 #endif
     header->filetype = 0x1;  // MH_OBJECT
     header->ncmds = 1;
     header->sizeofcmds = 0;
     header->flags = 0;
     return header;
   }
 
 
   Writer::Slot<MachOSegmentCommand> WriteSegmentCommand(Writer* w,
                                                         uintptr_t code_start,
                                                         uintptr_t code_size) {
     Writer::Slot<MachOSegmentCommand> cmd =
         w->CreateSlotHere<MachOSegmentCommand>();
-#if defined(V8_TARGET_ARCH_IA32)
+#if V8_TARGET_ARCH_IA32
     cmd->cmd = LC_SEGMENT_32;
 #else
     cmd->cmd = LC_SEGMENT_64;
 #endif
     cmd->vmaddr = code_start;
     cmd->vmsize = code_size;
     cmd->fileoff = 0;
     cmd->filesize = 0;
     cmd->maxprot = 7;
     cmd->initprot = 7;
@@ skipping 66 matching lines @@
     uint16_t pht_entry_num;
     uint16_t sht_entry_size;
     uint16_t sht_entry_num;
     uint16_t sht_strtab_index;
   };
 
 
   void WriteHeader(Writer* w) {
     ASSERT(w->position() == 0);
     Writer::Slot<ELFHeader> header = w->CreateSlotHere<ELFHeader>();
-#if defined(V8_TARGET_ARCH_IA32) || defined(V8_TARGET_ARCH_ARM)
+#if V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_ARM
     const uint8_t ident[16] =
         { 0x7f, 'E', 'L', 'F', 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-#elif defined(V8_TARGET_ARCH_X64)
+#elif V8_TARGET_ARCH_X64
     const uint8_t ident[16] =
         { 0x7f, 'E', 'L', 'F', 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 #else
 #error Unsupported target architecture.
 #endif
     OS::MemCopy(header->ident, ident, 16);
     header->type = 1;
-#if defined(V8_TARGET_ARCH_IA32)
+#if V8_TARGET_ARCH_IA32
     header->machine = 3;
-#elif defined(V8_TARGET_ARCH_X64)
+#elif V8_TARGET_ARCH_X64
     // Processor identification value for x64 is 62 as defined in
     //    System V ABI, AMD64 Supplement
     //    http://www.x86-64.org/documentation/abi.pdf
     header->machine = 62;
-#elif defined(V8_TARGET_ARCH_ARM)
+#elif V8_TARGET_ARCH_ARM
     // Set to EM_ARM, defined as 40, in "ARM ELF File Format" at
     // infocenter.arm.com/help/topic/com.arm.doc.dui0101a/DUI0101A_Elf.pdf
     header->machine = 40;
 #else
 #error Unsupported target architecture.
 #endif
     header->version = 1;
     header->entry = 0;
     header->pht_offset = 0;
     header->sht_offset = sizeof(ELFHeader);  // Section table follows header.
@@ skipping 73 matching lines @@
         value(value),
         size(size),
         info((binding << 4) | type),
         other(0),
         section(section) {
   }
 
   Binding binding() const {
     return static_cast<Binding>(info >> 4);
   }
-#if defined(V8_TARGET_ARCH_IA32) || defined(V8_TARGET_ARCH_ARM)
+#if V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_ARM
   struct SerializedLayout {
     SerializedLayout(uint32_t name,
                      uintptr_t value,
                      uintptr_t size,
                      Binding binding,
                      Type type,
                      uint16_t section)
         : name(name),
           value(value),
           size(size),
           info((binding << 4) | type),
           other(0),
           section(section) {
     }
 
     uint32_t name;
     uintptr_t value;
     uintptr_t size;
     uint8_t info;
     uint8_t other;
     uint16_t section;
   };
-#elif defined(V8_TARGET_ARCH_X64)
+#elif V8_TARGET_ARCH_X64
   struct SerializedLayout {
     SerializedLayout(uint32_t name,
                      uintptr_t value,
                      uintptr_t size,
                      Binding binding,
                      Type type,
                      uint16_t section)
         : name(name),
           info((binding << 4) | type),
           other(0),
@@ skipping 93 matching lines @@
   }
 
   ZoneList<ELFSymbol> locals_;
   ZoneList<ELFSymbol> globals_;
 };
 #endif  // defined(__ELF)
 
 
 class CodeDescription BASE_EMBEDDED {
  public:
-#ifdef V8_TARGET_ARCH_X64
+#if V8_TARGET_ARCH_X64
   enum StackState {
     POST_RBP_PUSH,
     POST_RBP_SET,
     POST_RBP_POP,
     STACK_STATE_MAX
   };
 #endif
 
   CodeDescription(const char* name,
                   Code* code,
@@ skipping 42 matching lines @@
   }
 
   bool IsLineInfoAvailable() {
     return !script_.is_null() &&
         script_->source()->IsString() &&
         script_->HasValidSource() &&
         script_->name()->IsString() &&
         lineinfo_ != NULL;
   }
 
-#ifdef V8_TARGET_ARCH_X64
+#if V8_TARGET_ARCH_X64
   uintptr_t GetStackStateStartAddress(StackState state) const {
     ASSERT(state < STACK_STATE_MAX);
     return stack_state_start_addresses_[state];
   }
 
   void SetStackStateStartAddress(StackState state, uintptr_t addr) {
     ASSERT(state < STACK_STATE_MAX);
     stack_state_start_addresses_[state] = addr;
   }
 #endif
 
   SmartArrayPointer<char> GetFilename() {
     return String::cast(script_->name())->ToCString();
   }
 
   int GetScriptLineNumber(int pos) {
     return GetScriptLineNumberSafe(script_, pos) + 1;
   }
 
 
  private:
   const char* name_;
   Code* code_;
   Handle<Script> script_;
   GDBJITLineInfo* lineinfo_;
   GDBJITInterface::CodeTag tag_;
   CompilationInfo* info_;
-#ifdef V8_TARGET_ARCH_X64
+#if V8_TARGET_ARCH_X64
   uintptr_t stack_state_start_addresses_[STACK_STATE_MAX];
 #endif
 };
 
 #if defined(__ELF)
 static void CreateSymbolsTable(CodeDescription* desc,
                                Zone* zone,
                                ELF* elf,
                                int text_section_index) {
   ELFSymbolTable* symtab = new(zone) ELFSymbolTable(".symtab", zone);
@@ skipping 73 matching lines @@
     w->WriteString("v8value");
 
     if (desc_->IsInfoAvailable()) {
       Scope* scope = desc_->info()->scope();
       w->WriteULEB128(2);
       w->WriteString(desc_->name());
       w->Write<intptr_t>(desc_->CodeStart());
       w->Write<intptr_t>(desc_->CodeStart() + desc_->CodeSize());
       Writer::Slot<uint32_t> fb_block_size = w->CreateSlotHere<uint32_t>();
       uintptr_t fb_block_start = w->position();
-#if defined(V8_TARGET_ARCH_IA32)
+#if V8_TARGET_ARCH_IA32
       w->Write<uint8_t>(DW_OP_reg5);  // The frame pointer's here on ia32
-#elif defined(V8_TARGET_ARCH_X64)
+#elif V8_TARGET_ARCH_X64
       w->Write<uint8_t>(DW_OP_reg6);  // and here on x64.
-#elif defined(V8_TARGET_ARCH_ARM)
+#elif V8_TARGET_ARCH_ARM
       UNIMPLEMENTED();
-#elif defined(V8_TARGET_ARCH_MIPS)
+#elif V8_TARGET_ARCH_MIPS
       UNIMPLEMENTED();
 #else
 #error Unsupported target architecture.
 #endif
       fb_block_size.set(static_cast<uint32_t>(w->position() - fb_block_start));
 
       int params = scope->num_parameters();
       int slots = scope->num_stack_slots();
       int context_slots = scope->ContextLocalCount();
       // The real slot ID is internal_slots + context_slot_id.
@@ skipping 430 matching lines @@
       return +1;
     } else {
       return -1;
     }
   }
 
   CodeDescription* desc_;
 };
 
 
-#ifdef V8_TARGET_ARCH_X64
+#if V8_TARGET_ARCH_X64
 
 class UnwindInfoSection : public DebugSection {
  public:
   explicit UnwindInfoSection(CodeDescription* desc);
   virtual bool WriteBodyInternal(Writer* w);
 
   int WriteCIE(Writer* w);
   void WriteFDE(Writer* w, int);
 
   void WriteFDEStateOnEntry(Writer* w);
@@ skipping 213 matching lines @@
 #endif  // V8_TARGET_ARCH_X64
 
 static void CreateDWARFSections(CodeDescription* desc,
                                 Zone* zone,
                                 DebugObject* obj) {
   if (desc->IsLineInfoAvailable()) {
     obj->AddSection(new(zone) DebugInfoSection(desc), zone);
     obj->AddSection(new(zone) DebugAbbrevSection(desc), zone);
     obj->AddSection(new(zone) DebugLineSection(desc), zone);
   }
-#ifdef V8_TARGET_ARCH_X64
+#if V8_TARGET_ARCH_X64
   obj->AddSection(new(zone) UnwindInfoSection(desc), zone);
 #endif
 }
 
 
 // -------------------------------------------------------------------
 // Binary GDB JIT Interface as described in
 //   http://sourceware.org/gdb/onlinedocs/gdb/Declarations.html
 extern "C" {
   typedef enum {
@@ skipping 197 matching lines @@
   if (!name.is_null() && name->IsString()) {
     SmartArrayPointer<char> name_cstring =
         Handle<String>::cast(name)->ToCString(DISALLOW_NULLS);
     AddCode(*name_cstring, *code, GDBJITInterface::FUNCTION, *script, info);
   } else {
     AddCode("", *code, GDBJITInterface::FUNCTION, *script, info);
   }
 }
 
 static void AddUnwindInfo(CodeDescription* desc) {
-#ifdef V8_TARGET_ARCH_X64
+#if V8_TARGET_ARCH_X64
   if (desc->tag() == GDBJITInterface::FUNCTION) {
     // To avoid propagating unwinding information through
     // compilation pipeline we use an approximation.
     // For most use cases this should not affect usability.
     static const int kFramePointerPushOffset = 1;
     static const int kFramePointerSetOffset = 4;
     static const int kFramePointerPopOffset = -3;
 
     uintptr_t frame_pointer_push_address =
         desc->CodeStart() + kFramePointerPushOffset;
@@ skipping 142 matching lines @@
   ScopedLock lock(mutex.Pointer());
   ASSERT(!IsLineInfoTagged(line_info));
   HashMap::Entry* e = GetEntries()->Lookup(code, HashForCodeObject(code), true);
   ASSERT(e->value == NULL);
   e->value = TagLineInfo(line_info);
 }
 
 
 } }  // namespace v8::internal
 #endif