← Back to branch summary

~ubuntu-branches/ubuntu/utopic/binutils-arm64-cross/utopic

« back to all changes in this revision

Viewing changes to binutils-2.23.52.20130611/gold/testsuite/binary_unittest.cc

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2013-06-20 17:38:09 UTC
  • Revision ID: package-import@ubuntu.com-20130620173809-app8lzgvymy5fg6c
Tags: 0.7
Build-depend on binutils-source (>= 2.23.52.20130620-1~).

Show diffs side-by-side

added added

removed removed

Lines of Context:
binutils-2.23.52.20130611/gold/testsuite/binary_unittest.cc
 
1
// binary_unittest.cc -- test Binary_to_elf
 
2
 
 
3
// Copyright 2008, 2012 Free Software Foundation, Inc.
 
4
// Written by Ian Lance Taylor <iant@google.com>.
 
5
 
 
6
// This file is part of gold.
 
7
 
 
8
// This program is free software; you can redistribute it and/or modify
 
9
// it under the terms of the GNU General Public License as published by
 
10
// the Free Software Foundation; either version 3 of the License, or
 
11
// (at your option) any later version.
 
12
 
 
13
// This program is distributed in the hope that it will be useful,
 
14
// but WITHOUT ANY WARRANTY; without even the implied warranty of
 
15
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
16
// GNU General Public License for more details.
 
17
 
 
18
// You should have received a copy of the GNU General Public License
 
19
// along with this program; if not, write to the Free Software
 
20
// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
 
21
// MA 02110-1301, USA.
 
22
 
 
23
#include "gold.h"
 
24
 
 
25
#include <unistd.h>
 
26
#include <sys/types.h>
 
27
#include <sys/stat.h>
 
28
#include <fcntl.h>
 
29
 
 
30
#include "elfcpp.h"
 
31
#include "parameters.h"
 
32
#include "errors.h"
 
33
#include "options.h"
 
34
#include "binary.h"
 
35
#include "object.h"
 
36
#include "descriptors.h"
 
37
 
 
38
#include "test.h"
 
39
#include "testfile.h"
 
40
 
 
41
namespace
 
42
{
 
43
 
 
44
ssize_t
 
45
read_all (int fd, unsigned char* buf, ssize_t size)
 
46
{
 
47
  ssize_t total_read = 0;
 
48
  while (size > 0)
 
49
    {
 
50
      ssize_t nread = ::read(fd, buf, size);
 
51
      if (nread < 0)
 
52
        return nread;
 
53
      if (nread == 0)
 
54
        break;
 
55
      buf += nread;
 
56
      size -= nread;
 
57
      total_read += nread;
 
58
    }
 
59
  return total_read;
 
60
}
 
61
 
 
62
} // End anonymous namespace.
 
63
 
 
64
namespace gold_testsuite
 
65
{
 
66
 
 
67
using namespace gold;
 
68
 
 
69
template<int size, bool big_endian>
 
70
bool
 
71
Sized_binary_test()
 
72
{
 
73
  parameters_clear_target();
 
74
  // We need a pretend Task.
 
75
  const Task* task = reinterpret_cast<const Task*>(-1);
 
76
 
 
77
  // Use the executable itself as the binary data.
 
78
  struct stat st;
 
79
  CHECK(::stat(gold::program_name, &st) == 0);
 
80
  int o = open_descriptor(-1, gold::program_name, O_RDONLY);
 
81
  CHECK(o >= 0);
 
82
  unsigned char* filedata = new unsigned char[st.st_size];
 
83
  CHECK(read_all(o, filedata, st.st_size) == static_cast<ssize_t>(st.st_size));
 
84
  CHECK(::close(o) == 0);
 
85
 
 
86
  Binary_to_elf binary(static_cast<elfcpp::EM>(0xffff), size, big_endian,
 
87
                       gold::program_name);
 
88
 
 
89
  CHECK(binary.convert(task));
 
90
 
 
91
  Input_file input_file(task, "test.o", binary.converted_data(),
 
92
                        binary.converted_size());
 
93
  Object* object = make_elf_object("test.o", &input_file, 0,
 
94
                                   binary.converted_data(),
 
95
                                   binary.converted_size(), NULL);
 
96
  CHECK(object != NULL);
 
97
  if (object == NULL)
 
98
    return false;
 
99
 
 
100
  CHECK(!object->is_dynamic());
 
101
  CHECK(object->shnum() == 5);
 
102
  CHECK(object->section_name(1) == ".data");
 
103
  CHECK(object->section_flags(1) == (elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE));
 
104
  section_size_type len;
 
105
  const unsigned char* contents = object->section_contents(1, &len, false);
 
106
  CHECK(len == convert_to_section_size_type(st.st_size));
 
107
  CHECK(memcmp(filedata, contents, len) == 0);
 
108
 
 
109
  // Force the symbols to be read internally, so that
 
110
  // symbol_section_and_value will work.
 
111
  Read_symbols_data sd;
 
112
  object->read_symbols(&sd);
 
113
  delete sd.section_headers;
 
114
  sd.section_headers = NULL;
 
115
  delete sd.section_names;
 
116
  sd.section_names = NULL;
 
117
  delete sd.symbols;
 
118
  sd.symbols = NULL;
 
119
  delete sd.symbol_names;
 
120
  sd.symbol_names = NULL;
 
121
 
 
122
  Sized_relobj_file<size, big_endian>* relobj =
 
123
    static_cast<Sized_relobj_file<size, big_endian>*>(object);
 
124
  typename Sized_relobj_file<size, big_endian>::Address value;
 
125
  bool is_ordinary;
 
126
  CHECK(relobj->symbol_section_and_value(0, &value, &is_ordinary) == 0);
 
127
  CHECK(is_ordinary);
 
128
  CHECK(value == 0);
 
129
  CHECK(relobj->symbol_section_and_value(1, &value, &is_ordinary) == 1);
 
130
  CHECK(is_ordinary);
 
131
  CHECK(value == 0);
 
132
  CHECK(relobj->symbol_section_and_value(2, &value, &is_ordinary) == 1);
 
133
  CHECK(is_ordinary);
 
134
  CHECK(static_cast<off_t>(value) == st.st_size);
 
135
  CHECK(relobj->symbol_section_and_value(3, &value, &is_ordinary)
 
136
        == elfcpp::SHN_ABS);
 
137
  CHECK(!is_ordinary);
 
138
  CHECK(static_cast<off_t>(value) == st.st_size);
 
139
 
 
140
  object->unlock(task);
 
141
  return true;
 
142
}
 
143
 
 
144
bool
 
145
Binary_test(Test_report*)
 
146
{
 
147
  Errors errors(gold::program_name);
 
148
  set_parameters_errors(&errors);
 
149
 
 
150
  General_options options;
 
151
  set_parameters_options(&options);
 
152
 
 
153
  int fail = 0;
 
154
 
 
155
#ifdef HAVE_TARGET_32_LITTLE
 
156
  if (!Sized_binary_test<32, false>())
 
157
    ++fail;
 
158
  CHECK(&parameters->target() == target_test_pointer_32_little);
 
159
#endif
 
160
 
 
161
#ifdef HAVE_TARGET_32_BIG
 
162
  if (!Sized_binary_test<32, true>())
 
163
    ++fail;
 
164
  CHECK(&parameters->target() == target_test_pointer_32_big);
 
165
#endif
 
166
 
 
167
#ifdef HAVE_TARGET_64_LITTLE
 
168
  if (!Sized_binary_test<64, false>())
 
169
    ++fail;
 
170
  CHECK(&parameters->target() == target_test_pointer_64_little);
 
171
#endif
 
172
 
 
173
#ifdef HAVE_TARGET_64_BIG
 
174
  if (!Sized_binary_test<64, true>())
 
175
    ++fail;
 
176
  CHECK(&parameters->target() == target_test_pointer_64_big);
 
177
#endif
 
178
 
 
179
  return fail == 0;
 
180
}
 
181
 
 
182
Register_test binary_register("Binary", Binary_test);
 
183
 
 
184
} // End namespace gold_testsuite.