Code changes to get the code to compile under GCC....

courgette/encoded_program.cc

 // Copyright (c) 2009 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/encoded_program.h"
 
 #include <algorithm>
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 12 matching lines @@
 const int kStreamBytes   = 2;
 const int kStreamAbs32Indexes = 3;
 const int kStreamRel32Indexes = 4;
 const int kStreamAbs32Addresses = 5;
 const int kStreamRel32Addresses = 6;
 const int kStreamCopyCounts = 7;
 const int kStreamOriginAddresses = kStreamMisc;
 
 const int kStreamLimit = 9;
 
-// Binary assembly language operations.
-enum EncodedProgram::OP {
-  ORIGIN,    // ORIGIN <rva> - set address for subsequent assembly.
-  COPY,      // COPY <count> <bytes> - copy bytes to output.
-  COPY1,     // COPY1 <byte> - same as COPY 1 <byte>.
-  REL32,     // REL32 <index> - emit rel32 encoded reference to address at
-             // address table offset <index>
-  ABS32,     // ABS32 <index> - emit abs32 encoded reference to address at
-             // address table offset <index>
-  MAKE_BASE_RELOCATION_TABLE,  // Emit base relocation table blocks.
-  OP_LAST
-};
-
-
 // Constructor is here rather than in the header.  Although the constructor
 // appears to do nothing it is fact quite large because of the implict calls to
 // field constructors.  Ditto for the destructor.
 EncodedProgram::EncodedProgram() {}
 EncodedProgram::~EncodedProgram() {}
 
 // Serializes a vector of integral values using Varint32 coding.
 template<typename T>
 void WriteVector(const std::vector<T>& items, SinkStream* buffer) {
   size_t count = items.size();
@@ skipping 435 matching lines @@
   if (ix_rel32_ix != rel32_ix_.size())
     return false;
 
   return true;
 }
 
 
 // RelocBlock has the layout of a block of relocations in the base relocation
 // table file format.
 //
-class RelocBlock {
- public:
+struct RelocBlockPOD {
   uint32 page_rva;
   uint32 block_size;
   uint16 relocs[4096];  // Allow up to one relocation per byte of a 4k page.
+};
 
-  RelocBlock() : page_rva(~0), block_size(8) {}
+COMPILE_ASSERT(offsetof(RelocBlockPOD, relocs) == 8, reloc_block_header_size);
+
+class RelocBlock {
+ public:
+  RelocBlock() {
+    pod.page_rva = ~0;
+    pod.block_size = 8;
+  }
 
   void Add(uint16 item) {
-    relocs[(block_size-8)/2] = item;
-    block_size += 2;
+    pod.relocs[(pod.block_size-8)/2] = item;
+    pod.block_size += 2;
   }
 
   void Flush(SinkStream* buffer) {
-    if (block_size != 8) {
-      if (block_size % 4 != 0) {  // Pad to make size multiple of 4 bytes.
+    if (pod.block_size != 8) {
+      if (pod.block_size % 4 != 0) {  // Pad to make size multiple of 4 bytes.
         Add(0);
       }
-      buffer->Write(this, block_size);
-      block_size = 8;
+      buffer->Write(&pod, pod.block_size);
+      pod.block_size = 8;
     }
   }
+  RelocBlockPOD pod;
 };
 
-COMPILE_ASSERT(offsetof(RelocBlock, relocs) == 8, reloc_block_header_size);
-
 void EncodedProgram::GenerateBaseRelocations(SinkStream* buffer) {
   std::sort(abs32_relocs_.begin(), abs32_relocs_.end());
 
   RelocBlock block;
 
   for (size_t i = 0;  i < abs32_relocs_.size();  ++i) {
     uint32 rva = abs32_relocs_[i];
     uint32 page_rva = rva & ~0xFFF;
-    if (page_rva != block.page_rva) {
+    if (page_rva != block.pod.page_rva) {
       block.Flush(buffer);
-      block.page_rva = page_rva;
+      block.pod.page_rva = page_rva;
     }
     block.Add(0x3000 | (rva & 0xFFF));
   }
   block.Flush(buffer);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 Status WriteEncodedProgram(EncodedProgram* encoded, SinkStreamSet* sink) {
   encoded->WriteTo(sink);
@@ skipping 15 matching lines @@
   if (assembled)
     return C_OK;
   return C_ASSEMBLY_FAILED;
 }
 
 void DeleteEncodedProgram(EncodedProgram* encoded) {
   delete encoded;
 }
 
 }  // end namespace