1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
// Copyright (c) 2011 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.
// This is the transformation and adjustment for all executables.
// The executable type is determined by ParseDetectedExecutable function.
#ifndef COURGETTE_WIN32_X86_GENERATOR_H_
#define COURGETTE_WIN32_X86_GENERATOR_H_
#include <memory>
#include "base/logging.h"
#include "base/macros.h"
#include "courgette/assembly_program.h"
#include "courgette/ensemble.h"
#include "courgette/patcher_x86_32.h"
#include "courgette/program_detector.h"
namespace courgette {
class PatchGeneratorX86_32 : public TransformationPatchGenerator {
public:
PatchGeneratorX86_32(Element* old_element,
Element* new_element,
PatcherX86_32* patcher,
ExecutableType kind)
: TransformationPatchGenerator(old_element, new_element, patcher),
kind_(kind) {
}
virtual ExecutableType Kind() { return kind_; }
Status WriteInitialParameters(SinkStream* parameter_stream) {
if (!parameter_stream->WriteSizeVarint32(
old_element_->offset_in_ensemble()) ||
!parameter_stream->WriteSizeVarint32(old_element_->region().length())) {
return C_STREAM_ERROR;
}
return C_OK;
// TODO(sra): Initialize |patcher_| with these parameters.
}
Status PredictTransformParameters(SinkStreamSet* prediction) {
return TransformationPatchGenerator::PredictTransformParameters(prediction);
}
Status CorrectedTransformParameters(SinkStreamSet* parameters) {
// No code needed to write an 'empty' parameter set.
return C_OK;
}
// The format of a transformed_element is a serialized EncodedProgram. We
// first disassemble the original old and new Elements into AssemblyPrograms.
// Then we adjust the new AssemblyProgram to make it as much like the old one
// as possible, before converting the AssemblyPrograms to EncodedPrograms and
// serializing them.
Status Transform(SourceStreamSet* corrected_parameters,
SinkStreamSet* old_transformed_element,
SinkStreamSet* new_transformed_element) {
// Don't expect any corrected parameters.
if (!corrected_parameters->Empty())
return C_GENERAL_ERROR;
// Generate old version of program using |corrected_parameters|.
// TODO(sra): refactor to use same code from patcher_.
std::unique_ptr<AssemblyProgram> old_program;
Status old_parse_status =
ParseDetectedExecutable(old_element_->region().start(),
old_element_->region().length(),
&old_program);
if (old_parse_status != C_OK) {
LOG(ERROR) << "Cannot parse an executable " << old_element_->Name();
return old_parse_status;
}
// TODO(huangs): Move the block below to right before |new_program| gets
// used, so we can reduce Courgette-gen peak memory.
std::unique_ptr<AssemblyProgram> new_program;
Status new_parse_status =
ParseDetectedExecutable(new_element_->region().start(),
new_element_->region().length(),
&new_program);
if (new_parse_status != C_OK) {
LOG(ERROR) << "Cannot parse an executable " << new_element_->Name();
return new_parse_status;
}
std::unique_ptr<EncodedProgram> old_encoded;
Status old_encode_status = Encode(*old_program, &old_encoded);
if (old_encode_status != C_OK)
return old_encode_status;
Status old_write_status =
WriteEncodedProgram(old_encoded.get(), old_transformed_element);
old_encoded.reset();
if (old_write_status != C_OK)
return old_write_status;
Status adjust_status = Adjust(*old_program, new_program.get());
old_program.reset();
if (adjust_status != C_OK)
return adjust_status;
std::unique_ptr<EncodedProgram> new_encoded;
Status new_encode_status = Encode(*new_program, &new_encoded);
if (new_encode_status != C_OK)
return new_encode_status;
new_program.reset();
Status new_write_status =
WriteEncodedProgram(new_encoded.get(), new_transformed_element);
return new_write_status;
}
Status Reform(SourceStreamSet* transformed_element,
SinkStream* reformed_element) {
return TransformationPatchGenerator::Reform(transformed_element,
reformed_element);
}
private:
virtual ~PatchGeneratorX86_32() { }
ExecutableType kind_;
DISALLOW_COPY_AND_ASSIGN(PatchGeneratorX86_32);
};
} // namespace courgette
#endif // COURGETTE_WIN32_X86_GENERATOR_H_
|
