1 // Copyright (C) 2019 The Android Open Source Project
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 //      http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 
15 #include "repr/protobuf/converter.h"
16 
17 #include <llvm/Support/raw_ostream.h>
18 
19 #include <fstream>
20 #include <iostream>
21 #include <memory>
22 #include <string>
23 
24 
25 namespace header_checker {
26 namespace repr {
27 
28 
AddTypeInfoDiff(abi_diff::TypeInfoDiff * type_info_diff_protobuf,const TypeDiffIR * type_diff_ir)29 bool IRDiffToProtobufConverter::AddTypeInfoDiff(
30     abi_diff::TypeInfoDiff *type_info_diff_protobuf,
31     const TypeDiffIR *type_diff_ir) {
32   abi_diff::TypeInfo *old_type_info_protobuf =
33       type_info_diff_protobuf->mutable_old_type_info();
34   abi_diff::TypeInfo *new_type_info_protobuf =
35       type_info_diff_protobuf->mutable_new_type_info();
36   if (old_type_info_protobuf == nullptr || new_type_info_protobuf == nullptr) {
37     return false;
38   }
39   const std::pair<uint64_t, uint64_t> &sizes = type_diff_ir->GetSizes();
40   const std::pair<uint32_t, uint32_t> &alignments =
41       type_diff_ir->GetAlignments();
42   old_type_info_protobuf->set_size(sizes.first);
43   new_type_info_protobuf->set_size(sizes.second);
44 
45   old_type_info_protobuf->set_alignment(alignments.first);
46   new_type_info_protobuf->set_alignment(alignments.second);
47   return true;
48 }
49 
AddVTableLayoutDiff(abi_diff::VTableLayoutDiff * vtable_layout_diff_protobuf,const VTableLayoutDiffIR * vtable_layout_diff_ir)50 bool IRDiffToProtobufConverter::AddVTableLayoutDiff(
51     abi_diff::VTableLayoutDiff *vtable_layout_diff_protobuf,
52     const VTableLayoutDiffIR *vtable_layout_diff_ir) {
53   abi_dump:: VTableLayout *old_vtable =
54       vtable_layout_diff_protobuf->mutable_old_vtable();
55   abi_dump:: VTableLayout *new_vtable =
56       vtable_layout_diff_protobuf->mutable_new_vtable();
57   if (old_vtable == nullptr || new_vtable == nullptr ||
58       !SetIRToProtobufVTableLayout(old_vtable,
59                                    vtable_layout_diff_ir->GetOldVTable()) ||
60       !SetIRToProtobufVTableLayout(new_vtable,
61                                    vtable_layout_diff_ir->GetNewVTable())) {
62     return false;
63   }
64   return true;
65 }
66 
67 template <typename T>
CopyBaseSpecifiersDiffIRToProtobuf(google::protobuf::RepeatedPtrField<T> * dst,const std::vector<CXXBaseSpecifierIR> & bases_ir)68 static bool CopyBaseSpecifiersDiffIRToProtobuf(
69     google::protobuf::RepeatedPtrField<T> *dst,
70     const std::vector<CXXBaseSpecifierIR> &bases_ir) {
71   for (auto &&base_ir : bases_ir) {
72     T *added_base = dst->Add();
73     if (!SetIRToProtobufBaseSpecifier(added_base, base_ir)) {
74       return false;
75     }
76   }
77   return true;
78 }
79 
AddBaseSpecifierDiffs(abi_diff::CXXBaseSpecifierDiff * base_specifiers_diff_protobuf,const CXXBaseSpecifierDiffIR * base_specifiers_diff_ir)80 bool IRDiffToProtobufConverter::AddBaseSpecifierDiffs(
81     abi_diff::CXXBaseSpecifierDiff *base_specifiers_diff_protobuf,
82     const CXXBaseSpecifierDiffIR *base_specifiers_diff_ir) {
83   if (!CopyBaseSpecifiersDiffIRToProtobuf(
84           base_specifiers_diff_protobuf->mutable_old_bases(),
85           base_specifiers_diff_ir->GetOldBases()) ||
86       !CopyBaseSpecifiersDiffIRToProtobuf(
87           base_specifiers_diff_protobuf->mutable_new_bases(),
88           base_specifiers_diff_ir->GetNewBases())) {
89     return false;
90   }
91   return true;
92 }
93 
AddRecordFields(abi_diff::RecordTypeDiff * record_diff_protobuf,const std::vector<const RecordFieldIR * > & record_fields_ir,bool field_removed)94 bool IRDiffToProtobufConverter::AddRecordFields(
95     abi_diff::RecordTypeDiff *record_diff_protobuf,
96     const std::vector<const RecordFieldIR *> &record_fields_ir,
97     bool field_removed) {
98   for (auto &&record_field_ir : record_fields_ir) {
99     abi_dump::RecordFieldDecl *field = nullptr;
100     if (field_removed) {
101       field = record_diff_protobuf->add_fields_removed();
102     } else {
103       field = record_diff_protobuf->add_fields_added();
104     }
105     if (field == nullptr) {
106       return false;
107     }
108     SetIRToProtobufRecordField(field, record_field_ir);
109   }
110   return true;
111 }
112 
AddRecordFieldDiffs(abi_diff::RecordTypeDiff * record_diff_protobuf,const std::vector<RecordFieldDiffIR> & record_field_diffs_ir)113 bool IRDiffToProtobufConverter::AddRecordFieldDiffs(
114     abi_diff::RecordTypeDiff *record_diff_protobuf,
115     const std::vector<RecordFieldDiffIR> &record_field_diffs_ir) {
116   for (auto &&record_field_diff_ir : record_field_diffs_ir) {
117     abi_diff::RecordFieldDeclDiff *record_field_diff =
118         record_diff_protobuf->add_fields_diff();
119     if (record_field_diff == nullptr) {
120       return false;
121     }
122     abi_dump::RecordFieldDecl *old_field =
123         record_field_diff->mutable_old_field();
124     abi_dump::RecordFieldDecl *new_field =
125         record_field_diff->mutable_new_field();
126     if (old_field == nullptr || new_field == nullptr) {
127       return false;
128     }
129     SetIRToProtobufRecordField(old_field,
130                                record_field_diff_ir.GetOldField());
131     SetIRToProtobufRecordField(new_field,
132                                record_field_diff_ir.GetNewField());
133   }
134   return true;
135 }
136 
ConvertRecordTypeDiffIR(const RecordTypeDiffIR * record_type_diff_ir)137 abi_diff::RecordTypeDiff IRDiffToProtobufConverter::ConvertRecordTypeDiffIR(
138     const RecordTypeDiffIR *record_type_diff_ir) {
139   abi_diff::RecordTypeDiff record_type_diff_protobuf;
140   record_type_diff_protobuf.set_name(record_type_diff_ir->GetName());
141   const TypeDiffIR *type_diff_ir = record_type_diff_ir->GetTypeDiff();
142   // If a type_info diff exists
143   if (type_diff_ir != nullptr) {
144     abi_diff::TypeInfoDiff *type_info_diff =
145         record_type_diff_protobuf.mutable_type_info_diff();
146     if (!AddTypeInfoDiff(type_info_diff, type_diff_ir)) {
147       llvm::errs() << "RecordType could not be converted\n";
148       ::exit(1);
149     }
150   }
151   // If vtables differ.
152   const VTableLayoutDiffIR *vtable_layout_diff_ir =
153       record_type_diff_ir->GetVTableLayoutDiff();
154   if (vtable_layout_diff_ir != nullptr) {
155     abi_diff::VTableLayoutDiff *vtable_layout_diff_protobuf =
156         record_type_diff_protobuf.mutable_vtable_layout_diff();
157     if (!AddVTableLayoutDiff(vtable_layout_diff_protobuf,
158                              vtable_layout_diff_ir)) {
159       llvm::errs() << "VTable layout diff could not be added\n";
160       ::exit(1);
161     }
162   }
163   // If base specifiers differ.
164   const CXXBaseSpecifierDiffIR *base_specifier_diff_ir =
165       record_type_diff_ir->GetBaseSpecifiers();
166   if (base_specifier_diff_ir != nullptr) {
167     abi_diff::CXXBaseSpecifierDiff *base_specifier_diff_protobuf =
168         record_type_diff_protobuf.mutable_bases_diff();
169     if (!AddBaseSpecifierDiffs(base_specifier_diff_protobuf,
170                                base_specifier_diff_ir)) {
171       llvm::errs() << "Base Specifier diff could not be added\n";
172       ::exit(1);
173     }
174   }
175   // Field diffs
176   if (!AddRecordFields(&record_type_diff_protobuf,
177                        record_type_diff_ir->GetFieldsRemoved(), true) ||
178       !AddRecordFields(&record_type_diff_protobuf,
179                        record_type_diff_ir->GetFieldsAdded(), false) ||
180       !AddRecordFieldDiffs(&record_type_diff_protobuf,
181                            record_type_diff_ir->GetFieldDiffs())) {
182     llvm::errs() << "Record Field diff could not be added\n";
183     ::exit(1);
184   }
185   return record_type_diff_protobuf;
186 }
187 
AddEnumUnderlyingTypeDiff(abi_diff::UnderlyingTypeDiff * underlying_type_diff_protobuf,const std::pair<std::string,std::string> * underlying_type_diff_ir)188 bool IRDiffToProtobufConverter::AddEnumUnderlyingTypeDiff(
189     abi_diff::UnderlyingTypeDiff *underlying_type_diff_protobuf,
190     const std::pair<std::string, std::string> *underlying_type_diff_ir) {
191   if (underlying_type_diff_protobuf == nullptr) {
192     return false;
193   }
194   underlying_type_diff_protobuf->set_old_type(underlying_type_diff_ir->first);
195   underlying_type_diff_protobuf->set_new_type(underlying_type_diff_ir->second);
196   return true;
197 }
198 
AddEnumFields(google::protobuf::RepeatedPtrField<abi_dump::EnumFieldDecl> * dst,const std::vector<const EnumFieldIR * > & enum_fields)199 static bool AddEnumFields(
200     google::protobuf::RepeatedPtrField<abi_dump::EnumFieldDecl> *dst,
201     const std::vector<const EnumFieldIR *> &enum_fields) {
202   for (auto &&enum_field : enum_fields) {
203     abi_dump::EnumFieldDecl *added_enum_field = dst->Add();
204     if (!SetIRToProtobufEnumField(added_enum_field, enum_field)) {
205       return false;
206     }
207   }
208   return true;
209 }
210 
AddEnumFieldDiffs(google::protobuf::RepeatedPtrField<abi_diff::EnumFieldDeclDiff> * dst,const std::vector<EnumFieldDiffIR> & fields_diff_ir)211 static bool AddEnumFieldDiffs(
212     google::protobuf::RepeatedPtrField<abi_diff::EnumFieldDeclDiff> *dst,
213     const std::vector<EnumFieldDiffIR> &fields_diff_ir) {
214   for (auto &&field_diff_ir : fields_diff_ir) {
215     abi_diff::EnumFieldDeclDiff *field_diff_protobuf = dst->Add();
216     if (field_diff_protobuf == nullptr) {
217       return false;
218     }
219     if (!SetIRToProtobufEnumField(field_diff_protobuf->mutable_old_field(),
220                                   field_diff_ir.GetOldField()) ||
221         !SetIRToProtobufEnumField(field_diff_protobuf->mutable_new_field(),
222                                   field_diff_ir.GetNewField())) {
223       return false;
224     }
225   }
226   return true;
227 }
228 
ConvertEnumTypeDiffIR(const EnumTypeDiffIR * enum_type_diff_ir)229 abi_diff::EnumTypeDiff IRDiffToProtobufConverter::ConvertEnumTypeDiffIR(
230     const EnumTypeDiffIR *enum_type_diff_ir) {
231   abi_diff::EnumTypeDiff enum_type_diff_protobuf;
232   enum_type_diff_protobuf.set_name(enum_type_diff_ir->GetName());
233   const std::pair<std::string, std::string> *underlying_type_diff =
234       enum_type_diff_ir->GetUnderlyingTypeDiff();
235   if ((underlying_type_diff != nullptr &&
236        !AddEnumUnderlyingTypeDiff(
237            enum_type_diff_protobuf.mutable_underlying_type_diff(),
238            underlying_type_diff)) ||
239       !AddEnumFields(enum_type_diff_protobuf.mutable_fields_removed(),
240                      enum_type_diff_ir->GetFieldsRemoved()) ||
241       !AddEnumFields(enum_type_diff_protobuf.mutable_fields_added(),
242                      enum_type_diff_ir->GetFieldsAdded()) ||
243       !AddEnumFieldDiffs(enum_type_diff_protobuf.mutable_fields_diff(),
244                          enum_type_diff_ir->GetFieldsDiff())) {
245     llvm::errs() << "Enum field diff could not be added\n";
246     ::exit(1);
247   }
248   return enum_type_diff_protobuf;
249 }
250 
ConvertGlobalVarDiffIR(const GlobalVarDiffIR * global_var_diff_ir)251 abi_diff::GlobalVarDeclDiff IRDiffToProtobufConverter::ConvertGlobalVarDiffIR(
252     const GlobalVarDiffIR *global_var_diff_ir) {
253   abi_diff::GlobalVarDeclDiff global_var_diff;
254   global_var_diff.set_name(global_var_diff_ir->GetName());
255   abi_dump::GlobalVarDecl *old_global_var = global_var_diff.mutable_old();
256   abi_dump::GlobalVarDecl *new_global_var = global_var_diff.mutable_new_();
257   if (old_global_var == nullptr || new_global_var == nullptr) {
258     llvm::errs() << "Globar Var diff could not be added\n";
259     ::exit(1);
260   }
261   *old_global_var =
262       IRToProtobufConverter::ConvertGlobalVarIR(
263           global_var_diff_ir->GetOldGlobalVar());
264   *new_global_var =
265       IRToProtobufConverter::ConvertGlobalVarIR(
266           global_var_diff_ir->GetNewGlobalVar());
267   return global_var_diff;
268 }
269 
ConvertFunctionDiffIR(const FunctionDiffIR * function_diff_ir)270 abi_diff::FunctionDeclDiff IRDiffToProtobufConverter::ConvertFunctionDiffIR(
271     const FunctionDiffIR *function_diff_ir) {
272   abi_diff::FunctionDeclDiff function_diff;
273   function_diff.set_name(function_diff_ir->GetName());
274   abi_dump::FunctionDecl *old_function = function_diff.mutable_old();
275   abi_dump::FunctionDecl *new_function = function_diff.mutable_new_();
276   if (old_function == nullptr || new_function == nullptr) {
277     llvm::errs() << "Function diff could not be added\n";
278     ::exit(1);
279   }
280   *old_function = IRToProtobufConverter::ConvertFunctionIR(
281       function_diff_ir->GetOldFunction());
282   *new_function = IRToProtobufConverter::ConvertFunctionIR(
283       function_diff_ir->GetNewFunction());
284   return function_diff;
285 }
286 
287 
288 }  // namespace repr
289 }  // namespace header_checker
290