google-breakpad/src/common/test_assembler.cc - nest-cam/4320010/google-breakpad - Git at Google

 // Copyright (c) 2010, Google Inc.
 // 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 with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 // Original author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>

 // test_assembler.cc: Implementation of google_breakpad::TestAssembler.
 // See test_assembler.h for details.

 #include "common/test_assembler.h"

 #include <assert.h>
 #include <stdio.h>

 #include <iterator>

 namespace google_breakpad {
 namespace test_assembler {

 using std::back_insert_iterator;

 Label::Label() : value_(new Binding()) { }
 Label::Label(uint64_t value) : value_(new Binding(value)) { }
 Label::Label(const Label &label) {
   value_ = label.value_;
   value_->Acquire();
 }
 Label::~Label() {
   if (value_->Release()) delete value_;
 }

 Label &Label::operator=(uint64_t value) {
   value_->Set(NULL, value);
   return *this;
 }

 Label &Label::operator=(const Label &label) {
   value_->Set(label.value_, 0);
   return *this;
 }

 Label Label::operator+(uint64_t addend) const {
   Label l;
   l.value_->Set(this->value_, addend);
   return l;
 }

 Label Label::operator-(uint64_t subtrahend) const {
   Label l;
   l.value_->Set(this->value_, -subtrahend);
   return l;
 }

 // When NDEBUG is #defined, assert doesn't evaluate its argument. This
 // means you can't simply use assert to check the return value of a
 // function with necessary side effects.
 //
 // ALWAYS_EVALUATE_AND_ASSERT(x) evaluates x regardless of whether
 // NDEBUG is #defined; when NDEBUG is not #defined, it further asserts
 // that x is true.
 #ifdef NDEBUG
 #define ALWAYS_EVALUATE_AND_ASSERT(x) x
 #else
 #define ALWAYS_EVALUATE_AND_ASSERT(x) assert(x)
 #endif

 uint64_t Label::operator-(const Label &label) const {
   uint64_t offset;
   ALWAYS_EVALUATE_AND_ASSERT(IsKnownOffsetFrom(label, &offset));
   return offset;
 }

 uint64_t Label::Value() const {
   uint64_t v = 0;
   ALWAYS_EVALUATE_AND_ASSERT(IsKnownConstant(&v));
   return v;
 };

 bool Label::IsKnownConstant(uint64_t *value_p) const {
   Binding *base;
   uint64_t addend;
   value_->Get(&base, &addend);
   if (base != NULL) return false;
   if (value_p) *value_p = addend;
   return true;
 }

 bool Label::IsKnownOffsetFrom(const Label &label, uint64_t *offset_p) const
 {
   Binding *label_base, *this_base;
   uint64_t label_addend, this_addend;
   label.value_->Get(&label_base, &label_addend);
   value_->Get(&this_base, &this_addend);
   // If this and label are related, Get will find their final
   // common ancestor, regardless of how indirect the relation is. This
   // comparison also handles the constant vs. constant case.
   if (this_base != label_base) return false;
   if (offset_p) *offset_p = this_addend - label_addend;
   return true;
 }

 Label::Binding::Binding() : base_(this), addend_(), reference_count_(1) { }

 Label::Binding::Binding(uint64_t addend)
     : base_(NULL), addend_(addend), reference_count_(1) { }

 Label::Binding::~Binding() {
   assert(reference_count_ == 0);
   if (base_ && base_ != this && base_->Release())
     delete base_;
 }

 void Label::Binding::Set(Binding *binding, uint64_t addend) {
   if (!base_ && !binding) {
     // We're equating two constants. This could be okay.
     assert(addend_ == addend);
   } else if (!base_) {
     // We are a known constant, but BINDING may not be, so turn the
     // tables and try to set BINDING's value instead.
     binding->Set(NULL, addend_ - addend);
   } else {
     if (binding) {
       // Find binding's final value. Since the final value is always either
       // completely unconstrained or a constant, never a reference to
       // another variable (otherwise, it wouldn't be final), this
       // guarantees we won't create cycles here, even for code like this:
       //   l = m, m = n, n = l;
       uint64_t binding_addend;
       binding->Get(&binding, &binding_addend);
       addend += binding_addend;
     }

     // It seems likely that setting a binding to itself is a bug
     // (although I can imagine this might turn out to be helpful to
     // permit).
     assert(binding != this);

     if (base_ != this) {
       // Set the other bindings on our chain as well. Note that this
       // is sufficient even though binding relationships form trees:
       // All binding operations traverse their chains to the end, and
       // all bindings related to us share some tail of our chain, so
       // they will see the changes we make here.
       base_->Set(binding, addend - addend_);
       // We're not going to use base_ any more.
       if (base_->Release()) delete base_;
     }

     // Adopt BINDING as our base. Note that it should be correct to
     // acquire here, after the release above, even though the usual
     // reference-counting rules call for acquiring first, and then
     // releasing: the self-reference assertion above should have
     // complained if BINDING were 'this' or anywhere along our chain,
     // so we didn't release BINDING.
     if (binding) binding->Acquire();
     base_ = binding;
     addend_ = addend;
   }
 }

 void Label::Binding::Get(Binding **base, uint64_t *addend) {
   if (base_ && base_ != this) {
     // Recurse to find the end of our reference chain (the root of our
     // tree), and then rewrite every binding along the chain to refer
     // to it directly, adjusting addends appropriately. (This is why
     // this member function isn't this-const.)
     Binding *final_base;
     uint64_t final_addend;
     base_->Get(&final_base, &final_addend);
     if (final_base) final_base->Acquire();
     if (base_->Release()) delete base_;
     base_ = final_base;
     addend_ += final_addend;
   }
   *base = base_;
   *addend = addend_;
 }

 template<typename Inserter>
 static inline void InsertEndian(test_assembler::Endianness endianness,
                                 size_t size, uint64_t number, Inserter dest) {
   assert(size > 0);
   if (endianness == kLittleEndian) {
     for (size_t i = 0; i < size; i++) {
       *dest++ = (char) (number & 0xff);
       number >>= 8;
     }
   } else {
     assert(endianness == kBigEndian);
     // The loop condition is odd, but it's correct for size_t.
     for (size_t i = size - 1; i < size; i--)
       *dest++ = (char) ((number >> (i * 8)) & 0xff);
   }
 }

 Section &Section::Append(Endianness endianness, size_t size, uint64_t number) {
   InsertEndian(endianness, size, number,
                back_insert_iterator<string>(contents_));
   return *this;
 }

 Section &Section::Append(Endianness endianness, size_t size,
                          const Label &label) {
   // If this label's value is known, there's no reason to waste an
   // entry in references_ on it.
   uint64_t value;
   if (label.IsKnownConstant(&value))
     return Append(endianness, size, value);

   // This will get caught when the references are resolved, but it's
   // nicer to find out earlier.
   assert(endianness != kUnsetEndian);

   references_.push_back(Reference(contents_.size(), endianness, size, label));
   contents_.append(size, 0);
   return *this;
 }

 #define ENDIANNESS_L kLittleEndian
 #define ENDIANNESS_B kBigEndian
 #define ENDIANNESS(e) ENDIANNESS_ ## e

 #define DEFINE_SHORT_APPEND_NUMBER_ENDIAN(e, bits)                      \
   Section &Section::e ## bits(uint ## bits ## _t v) {                  \
     InsertEndian(ENDIANNESS(e), bits / 8, v,                            \
                  back_insert_iterator<string>(contents_));              \
     return *this;                                                       \
   }

 #define DEFINE_SHORT_APPEND_LABEL_ENDIAN(e, bits)                       \
   Section &Section::e ## bits(const Label &v) {                         \
     return Append(ENDIANNESS(e), bits / 8, v);                          \
   }

 // Define L16, B32, and friends.
 #define DEFINE_SHORT_APPEND_ENDIAN(e, bits)                             \
   DEFINE_SHORT_APPEND_NUMBER_ENDIAN(e, bits)                            \
   DEFINE_SHORT_APPEND_LABEL_ENDIAN(e, bits)

 DEFINE_SHORT_APPEND_LABEL_ENDIAN(L, 8);
 DEFINE_SHORT_APPEND_LABEL_ENDIAN(B, 8);
 DEFINE_SHORT_APPEND_ENDIAN(L, 16);
 DEFINE_SHORT_APPEND_ENDIAN(L, 32);
 DEFINE_SHORT_APPEND_ENDIAN(L, 64);
 DEFINE_SHORT_APPEND_ENDIAN(B, 16);
 DEFINE_SHORT_APPEND_ENDIAN(B, 32);
 DEFINE_SHORT_APPEND_ENDIAN(B, 64);

 #define DEFINE_SHORT_APPEND_NUMBER_DEFAULT(bits)                        \
   Section &Section::D ## bits(uint ## bits ## _t v) {                  \
     InsertEndian(endianness_, bits / 8, v,                              \
                  back_insert_iterator<string>(contents_));              \
     return *this;                                                       \
   }
 #define DEFINE_SHORT_APPEND_LABEL_DEFAULT(bits)                         \
   Section &Section::D ## bits(const Label &v) {                         \
     return Append(endianness_, bits / 8, v);                            \
   }
 #define DEFINE_SHORT_APPEND_DEFAULT(bits)                               \
   DEFINE_SHORT_APPEND_NUMBER_DEFAULT(bits)                              \
   DEFINE_SHORT_APPEND_LABEL_DEFAULT(bits)

 DEFINE_SHORT_APPEND_LABEL_DEFAULT(8)
 DEFINE_SHORT_APPEND_DEFAULT(16);
 DEFINE_SHORT_APPEND_DEFAULT(32);
 DEFINE_SHORT_APPEND_DEFAULT(64);

 Section &Section::Append(const Section &section) {
   size_t base = contents_.size();
   contents_.append(section.contents_);
   for (vector<Reference>::const_iterator it = section.references_.begin();
        it != section.references_.end(); it++)
     references_.push_back(Reference(base + it->offset, it->endianness,
                                     it->size, it->label));
   return *this;
 }

 Section &Section::LEB128(long long value) {
   while (value < -0x40 || 0x3f < value) {
     contents_ += (value & 0x7f) | 0x80;
     if (value < 0)
       value = (value >> 7) | ~(((unsigned long long) -1) >> 7);
     else
       value = (value >> 7);
   }
   contents_ += value & 0x7f;
   return *this;
 }

 Section &Section::ULEB128(uint64_t value) {
   while (value > 0x7f) {
     contents_ += (value & 0x7f) | 0x80;
     value = (value >> 7);
   }
   contents_ += value;
   return *this;
 }

 Section &Section::Align(size_t alignment, uint8_t pad_byte) {
   // ALIGNMENT must be a power of two.
   assert(((alignment - 1) & alignment) == 0);
   size_t new_size = (contents_.size() + alignment - 1) & ~(alignment - 1);
   contents_.append(new_size - contents_.size(), pad_byte);
   assert((contents_.size() & (alignment - 1)) == 0);
   return *this;
 }

 void Section::Clear() {
   contents_.clear();
   references_.clear();
 }

 bool Section::GetContents(string *contents) {
   // For each label reference, find the label's value, and patch it into
   // the section's contents.
   for (size_t i = 0; i < references_.size(); i++) {
     Reference &r = references_[i];
     uint64_t value;
     if (!r.label.IsKnownConstant(&value)) {
       fprintf(stderr, "Undefined label #%zu at offset 0x%zx\n", i, r.offset);
       return false;
     }
     assert(r.offset < contents_.size());
     assert(contents_.size() - r.offset >= r.size);
     InsertEndian(r.endianness, r.size, value, contents_.begin() + r.offset);
   }
   contents->clear();
   std::swap(contents_, *contents);
   references_.clear();
   return true;
 }

 }  // namespace test_assembler
 }  // namespace google_breakpad
	// Copyright (c) 2010, Google Inc.
	// 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 with the
	// distribution.
	// * Neither the name of Google Inc. nor the names of its
	// contributors may be used to endorse or promote products derived from
	// this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	// Original author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>

	// test_assembler.cc: Implementation of google_breakpad::TestAssembler.
	// See test_assembler.h for details.

	#include "common/test_assembler.h"

	#include <assert.h>
	#include <stdio.h>

	#include <iterator>

	namespace google_breakpad {
	namespace test_assembler {

	using std::back_insert_iterator;

	Label::Label() : value_(new Binding()) { }
	Label::Label(uint64_t value) : value_(new Binding(value)) { }
	Label::Label(const Label &label) {
	value_ = label.value_;
	value_->Acquire();
	}
	Label::~Label() {
	if (value_->Release()) delete value_;
	}

	Label &Label::operator=(uint64_t value) {
	value_->Set(NULL, value);
	return *this;
	}

	Label &Label::operator=(const Label &label) {
	value_->Set(label.value_, 0);
	return *this;
	}

	Label Label::operator+(uint64_t addend) const {
	Label l;
	l.value_->Set(this->value_, addend);
	return l;
	}

	Label Label::operator-(uint64_t subtrahend) const {
	Label l;
	l.value_->Set(this->value_, -subtrahend);
	return l;
	}

	// When NDEBUG is #defined, assert doesn't evaluate its argument. This
	// means you can't simply use assert to check the return value of a
	// function with necessary side effects.
	//
	// ALWAYS_EVALUATE_AND_ASSERT(x) evaluates x regardless of whether
	// NDEBUG is #defined; when NDEBUG is not #defined, it further asserts
	// that x is true.
	#ifdef NDEBUG
	#define ALWAYS_EVALUATE_AND_ASSERT(x) x
	#else
	#define ALWAYS_EVALUATE_AND_ASSERT(x) assert(x)
	#endif

	uint64_t Label::operator-(const Label &label) const {
	uint64_t offset;
	ALWAYS_EVALUATE_AND_ASSERT(IsKnownOffsetFrom(label, &offset));
	return offset;
	}

	uint64_t Label::Value() const {
	uint64_t v = 0;
	ALWAYS_EVALUATE_AND_ASSERT(IsKnownConstant(&v));
	return v;
	};

	bool Label::IsKnownConstant(uint64_t *value_p) const {
	Binding *base;
	uint64_t addend;
	value_->Get(&base, &addend);
	if (base != NULL) return false;
	if (value_p) *value_p = addend;
	return true;
	}

	bool Label::IsKnownOffsetFrom(const Label &label, uint64_t *offset_p) const
	{
	Binding label_base, this_base;
	uint64_t label_addend, this_addend;
	label.value_->Get(&label_base, &label_addend);
	value_->Get(&this_base, &this_addend);
	// If this and label are related, Get will find their final
	// common ancestor, regardless of how indirect the relation is. This
	// comparison also handles the constant vs. constant case.
	if (this_base != label_base) return false;
	if (offset_p) *offset_p = this_addend - label_addend;
	return true;
	}

	Label::Binding::Binding() : base_(this), addend_(), reference_count_(1) { }

	Label::Binding::Binding(uint64_t addend)
	: base_(NULL), addend_(addend), reference_count_(1) { }

	Label::Binding::~Binding() {
	assert(reference_count_ == 0);
	if (base_ && base_ != this && base_->Release())
	delete base_;
	}

	void Label::Binding::Set(Binding *binding, uint64_t addend) {
	if (!base_ && !binding) {
	// We're equating two constants. This could be okay.
	assert(addend_ == addend);
	} else if (!base_) {
	// We are a known constant, but BINDING may not be, so turn the
	// tables and try to set BINDING's value instead.
	binding->Set(NULL, addend_ - addend);
	} else {
	if (binding) {
	// Find binding's final value. Since the final value is always either
	// completely unconstrained or a constant, never a reference to
	// another variable (otherwise, it wouldn't be final), this
	// guarantees we won't create cycles here, even for code like this:
	// l = m, m = n, n = l;
	uint64_t binding_addend;
	binding->Get(&binding, &binding_addend);
	addend += binding_addend;
	}

	// It seems likely that setting a binding to itself is a bug
	// (although I can imagine this might turn out to be helpful to
	// permit).
	assert(binding != this);

	if (base_ != this) {
	// Set the other bindings on our chain as well. Note that this
	// is sufficient even though binding relationships form trees:
	// All binding operations traverse their chains to the end, and
	// all bindings related to us share some tail of our chain, so
	// they will see the changes we make here.
	base_->Set(binding, addend - addend_);
	// We're not going to use base_ any more.
	if (base_->Release()) delete base_;
	}

	// Adopt BINDING as our base. Note that it should be correct to
	// acquire here, after the release above, even though the usual
	// reference-counting rules call for acquiring first, and then
	// releasing: the self-reference assertion above should have
	// complained if BINDING were 'this' or anywhere along our chain,
	// so we didn't release BINDING.
	if (binding) binding->Acquire();
	base_ = binding;
	addend_ = addend;
	}
	}

	void Label::Binding::Get(Binding *base, uint64_t addend) {
	if (base_ && base_ != this) {
	// Recurse to find the end of our reference chain (the root of our
	// tree), and then rewrite every binding along the chain to refer
	// to it directly, adjusting addends appropriately. (This is why
	// this member function isn't this-const.)
	Binding *final_base;
	uint64_t final_addend;
	base_->Get(&final_base, &final_addend);
	if (final_base) final_base->Acquire();
	if (base_->Release()) delete base_;
	base_ = final_base;
	addend_ += final_addend;
	}
	*base = base_;
	*addend = addend_;
	}

	template<typename Inserter>
	static inline void InsertEndian(test_assembler::Endianness endianness,
	size_t size, uint64_t number, Inserter dest) {
	assert(size > 0);
	if (endianness == kLittleEndian) {
	for (size_t i = 0; i < size; i++) {
	*dest++ = (char) (number & 0xff);
	number >>= 8;
	}
	} else {
	assert(endianness == kBigEndian);
	// The loop condition is odd, but it's correct for size_t.
	for (size_t i = size - 1; i < size; i--)
	dest++ = (char) ((number >> (i 8)) & 0xff);
	}
	}

	Section &Section::Append(Endianness endianness, size_t size, uint64_t number) {
	InsertEndian(endianness, size, number,
	back_insert_iterator<string>(contents_));
	return *this;
	}

	Section &Section::Append(Endianness endianness, size_t size,
	const Label &label) {
	// If this label's value is known, there's no reason to waste an
	// entry in references_ on it.
	uint64_t value;
	if (label.IsKnownConstant(&value))
	return Append(endianness, size, value);

	// This will get caught when the references are resolved, but it's
	// nicer to find out earlier.
	assert(endianness != kUnsetEndian);

	references_.push_back(Reference(contents_.size(), endianness, size, label));
	contents_.append(size, 0);
	return *this;
	}

	#define ENDIANNESS_L kLittleEndian
	#define ENDIANNESS_B kBigEndian
	#define ENDIANNESS(e) ENDIANNESS_ ## e

	#define DEFINE_SHORT_APPEND_NUMBER_ENDIAN(e, bits) \
	Section &Section::e ## bits(uint ## bits ## _t v) { \
	InsertEndian(ENDIANNESS(e), bits / 8, v, \
	back_insert_iterator<string>(contents_)); \
	return *this; \
	}

	#define DEFINE_SHORT_APPEND_LABEL_ENDIAN(e, bits) \
	Section &Section::e ## bits(const Label &v) { \
	return Append(ENDIANNESS(e), bits / 8, v); \
	}

	// Define L16, B32, and friends.
	#define DEFINE_SHORT_APPEND_ENDIAN(e, bits) \
	DEFINE_SHORT_APPEND_NUMBER_ENDIAN(e, bits) \
	DEFINE_SHORT_APPEND_LABEL_ENDIAN(e, bits)

	DEFINE_SHORT_APPEND_LABEL_ENDIAN(L, 8);
	DEFINE_SHORT_APPEND_LABEL_ENDIAN(B, 8);
	DEFINE_SHORT_APPEND_ENDIAN(L, 16);
	DEFINE_SHORT_APPEND_ENDIAN(L, 32);
	DEFINE_SHORT_APPEND_ENDIAN(L, 64);
	DEFINE_SHORT_APPEND_ENDIAN(B, 16);
	DEFINE_SHORT_APPEND_ENDIAN(B, 32);
	DEFINE_SHORT_APPEND_ENDIAN(B, 64);

	#define DEFINE_SHORT_APPEND_NUMBER_DEFAULT(bits) \
	Section &Section::D ## bits(uint ## bits ## _t v) { \
	InsertEndian(endianness_, bits / 8, v, \
	back_insert_iterator<string>(contents_)); \
	return *this; \
	}
	#define DEFINE_SHORT_APPEND_LABEL_DEFAULT(bits) \
	Section &Section::D ## bits(const Label &v) { \
	return Append(endianness_, bits / 8, v); \
	}
	#define DEFINE_SHORT_APPEND_DEFAULT(bits) \
	DEFINE_SHORT_APPEND_NUMBER_DEFAULT(bits) \
	DEFINE_SHORT_APPEND_LABEL_DEFAULT(bits)

	DEFINE_SHORT_APPEND_LABEL_DEFAULT(8)
	DEFINE_SHORT_APPEND_DEFAULT(16);
	DEFINE_SHORT_APPEND_DEFAULT(32);
	DEFINE_SHORT_APPEND_DEFAULT(64);

	Section &Section::Append(const Section &section) {
	size_t base = contents_.size();
	contents_.append(section.contents_);
	for (vector<Reference>::const_iterator it = section.references_.begin();
	it != section.references_.end(); it++)
	references_.push_back(Reference(base + it->offset, it->endianness,
	it->size, it->label));
	return *this;
	}

	Section &Section::LEB128(long long value) {
	while (value < -0x40 \|\| 0x3f < value) {
	contents_ += (value & 0x7f) \| 0x80;
	if (value < 0)
	value = (value >> 7) \| ~(((unsigned long long) -1) >> 7);
	else
	value = (value >> 7);
	}
	contents_ += value & 0x7f;
	return *this;
	}

	Section &Section::ULEB128(uint64_t value) {
	while (value > 0x7f) {
	contents_ += (value & 0x7f) \| 0x80;
	value = (value >> 7);
	}
	contents_ += value;
	return *this;
	}

	Section &Section::Align(size_t alignment, uint8_t pad_byte) {
	// ALIGNMENT must be a power of two.
	assert(((alignment - 1) & alignment) == 0);
	size_t new_size = (contents_.size() + alignment - 1) & ~(alignment - 1);
	contents_.append(new_size - contents_.size(), pad_byte);
	assert((contents_.size() & (alignment - 1)) == 0);
	return *this;
	}

	void Section::Clear() {
	contents_.clear();
	references_.clear();
	}

	bool Section::GetContents(string *contents) {
	// For each label reference, find the label's value, and patch it into
	// the section's contents.
	for (size_t i = 0; i < references_.size(); i++) {
	Reference &r = references_[i];
	uint64_t value;
	if (!r.label.IsKnownConstant(&value)) {
	fprintf(stderr, "Undefined label #%zu at offset 0x%zx\n", i, r.offset);
	return false;
	}
	assert(r.offset < contents_.size());
	assert(contents_.size() - r.offset >= r.size);
	InsertEndian(r.endianness, r.size, value, contents_.begin() + r.offset);
	}
	contents->clear();
	std::swap(contents_, *contents);
	references_.clear();
	return true;
	}

	} // namespace test_assembler
	} // namespace google_breakpad