encoded_program_unittest.cc 5.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177
  1. // Copyright (c) 2012 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "courgette/encoded_program.h"
  5. #include <stddef.h>
  6. #include <stdint.h>
  7. #include <memory>
  8. #include <vector>
  9. #include "courgette/image_utils.h"
  10. #include "courgette/label_manager.h"
  11. #include "courgette/streams.h"
  12. #include "testing/gtest/include/gtest/gtest.h"
  13. namespace courgette {
  14. namespace {
  15. // Helper class to instantiate RVAToLabel while managing allocation.
  16. class TestLabelManager : public LabelManager {
  17. public:
  18. void RawAddLabel(int index, RVA rva) {
  19. labels_.push_back(Label(rva, index)); // Don't care about |count_|.
  20. }
  21. };
  22. // Creates a simple new program with given addresses. The orders of elements
  23. // in |abs32_specs| and |rel32_specs| are important.
  24. std::unique_ptr<EncodedProgram> CreateTestProgram(
  25. const TestLabelManager& abs32_label_manager,
  26. const TestLabelManager& rel32_label_manager) {
  27. std::unique_ptr<EncodedProgram> program(new EncodedProgram());
  28. uint32_t base = 0x00900000;
  29. program->set_image_base(base);
  30. EXPECT_TRUE(program->ImportLabels(abs32_label_manager, rel32_label_manager));
  31. EXPECT_TRUE(program->AddOrigin(0)); // Start at base.
  32. // Add instructions. Since we're using TestLabelManager, Labels are sorted in
  33. // the order they're added via Add().
  34. for (const Label& label : abs32_label_manager.Labels())
  35. EXPECT_TRUE(program->AddAbs32(label.index_));
  36. for (const Label& label : rel32_label_manager.Labels())
  37. EXPECT_TRUE(program->AddRel32(label.index_));
  38. return program;
  39. }
  40. bool CompareSink(const uint8_t expected[],
  41. size_t num_expected,
  42. SinkStream* ss) {
  43. size_t n = ss->Length();
  44. if (num_expected != n)
  45. return false;
  46. const uint8_t* buffer = ss->Buffer();
  47. return memcmp(&expected[0], buffer, n) == 0;
  48. }
  49. } // namespace
  50. // Create a simple program with a few addresses and references and
  51. // check that the bits produced are as expected.
  52. TEST(EncodedProgramTest, Test) {
  53. // ABS32 index 7 <-- base + 4.
  54. TestLabelManager abs32_label_manager;
  55. abs32_label_manager.RawAddLabel(7, 4);
  56. // REL32 index 5 <-- base + 0.
  57. TestLabelManager rel32_label_manager;
  58. rel32_label_manager.RawAddLabel(5, 0);
  59. std::unique_ptr<EncodedProgram> program(
  60. CreateTestProgram(abs32_label_manager, rel32_label_manager));
  61. // Serialize and deserialize.
  62. SinkStreamSet sinks;
  63. EXPECT_TRUE(program->WriteTo(&sinks));
  64. program.reset();
  65. SinkStream sink;
  66. bool can_collect = sinks.CopyTo(&sink);
  67. EXPECT_TRUE(can_collect);
  68. const void* buffer = sink.Buffer();
  69. size_t length = sink.Length();
  70. SourceStreamSet sources;
  71. bool can_get_source_streams = sources.Init(buffer, length);
  72. EXPECT_TRUE(can_get_source_streams);
  73. std::unique_ptr<EncodedProgram> encoded2(new EncodedProgram());
  74. bool can_read = encoded2->ReadFrom(&sources);
  75. EXPECT_TRUE(can_read);
  76. // Finally, try to assemble.
  77. SinkStream assembled;
  78. bool can_assemble = encoded2->AssembleTo(&assembled);
  79. EXPECT_TRUE(can_assemble);
  80. encoded2.reset();
  81. const uint8_t golden[] = {
  82. 0x04, 0x00, 0x90,
  83. 0x00, // ABS32 to base + 4
  84. 0xF8, 0xFF, 0xFF,
  85. 0xFF // REL32 from next line to base + 2
  86. };
  87. EXPECT_TRUE(CompareSink(golden, std::size(golden), &assembled));
  88. }
  89. // A larger test with multiple addresses. We encode the program and check the
  90. // contents of the address streams.
  91. TEST(EncodedProgramTest, TestWriteAddress) {
  92. // Absolute addresses by index: [_, _, _, 2, _, 23, _, 11].
  93. TestLabelManager abs32_label_manager;
  94. abs32_label_manager.RawAddLabel(7, 11);
  95. abs32_label_manager.RawAddLabel(3, 2);
  96. abs32_label_manager.RawAddLabel(5, 23);
  97. // Relative addresses by index: [16, 7, _, 32].
  98. TestLabelManager rel32_label_manager;
  99. rel32_label_manager.RawAddLabel(0, 16);
  100. rel32_label_manager.RawAddLabel(3, 32);
  101. rel32_label_manager.RawAddLabel(1, 7);
  102. std::unique_ptr<EncodedProgram> program(
  103. CreateTestProgram(abs32_label_manager, rel32_label_manager));
  104. SinkStreamSet sinks;
  105. EXPECT_TRUE(program->WriteTo(&sinks));
  106. program.reset();
  107. // Check indexes and addresses in sinks.
  108. const uint8_t golden_abs32_indexes[] = {
  109. 0x03, 0x07, 0x03, 0x05 // 3 indexes: [7, 3, 5].
  110. };
  111. EXPECT_TRUE(CompareSink(golden_abs32_indexes, std::size(golden_abs32_indexes),
  112. sinks.stream(kStreamAbs32Indexes)));
  113. const uint8_t golden_rel32_indexes[] = {
  114. 0x03, 0x00, 0x03, 0x01 // 3 indexes: [0, 3, 1].
  115. };
  116. EXPECT_TRUE(CompareSink(golden_rel32_indexes, std::size(golden_rel32_indexes),
  117. sinks.stream(kStreamRel32Indexes)));
  118. // Addresses: [_, _, _, 2, _, 23, _, 11].
  119. // Padded: [0, 0, 0, 2, 2, 23, 23, 11].
  120. // Delta: [0, 0, 0, 2, 0, 21, 0, -12].
  121. // Hex: [0, 0, 0, 0x02, 0, 0x15, 0, 0xFFFFFFF4].
  122. // Complement neg: [0, 0, 0, 0x02, 0, 0x15, 0, (0x0B)].
  123. // Varint32 Signed: [0, 0, 0, 0x04, 0, 0x2A, 0, 0x17].
  124. const uint8_t golden_abs32_addresses[] = {
  125. 0x08, // 8 address deltas.
  126. 0x00, 0x00, 0x00, 0x04, 0x00, 0x2A, 0x00, 0x17,
  127. };
  128. EXPECT_TRUE(CompareSink(golden_abs32_addresses,
  129. std::size(golden_abs32_addresses),
  130. sinks.stream(kStreamAbs32Addresses)));
  131. // Addresses: [16, 7, _, 32].
  132. // Padded: [16, 7, 7, 32].
  133. // Delta: [16, -9, 0, 25].
  134. // Hex: [0x10, 0xFFFFFFF7, 0, 0x19].
  135. // Complement Neg: [0x10, (0x08), 0, 0x19].
  136. // Varint32 Signed: [0x20, 0x11, 0, 0x32].
  137. const uint8_t golden_rel32_addresses[] = {
  138. 0x04, // 4 address deltas.
  139. 0x20, 0x11, 0x00, 0x32,
  140. };
  141. EXPECT_TRUE(CompareSink(golden_rel32_addresses,
  142. std::size(golden_rel32_addresses),
  143. sinks.stream(kStreamRel32Addresses)));
  144. }
  145. } // namespace courgette