1 #ifndef SRC_TRACE_PROCESSOR_TABLES_V8_TABLES_PY_H_ 2 #define SRC_TRACE_PROCESSOR_TABLES_V8_TABLES_PY_H_ 3 4 #include <array> 5 #include <cstddef> 6 #include <cstdint> 7 #include <memory> 8 #include <optional> 9 #include <type_traits> 10 #include <utility> 11 #include <vector> 12 13 #include "perfetto/base/logging.h" 14 #include "perfetto/trace_processor/basic_types.h" 15 #include "perfetto/trace_processor/ref_counted.h" 16 #include "src/trace_processor/containers/bit_vector.h" 17 #include "src/trace_processor/containers/row_map.h" 18 #include "src/trace_processor/containers/string_pool.h" 19 #include "src/trace_processor/db/column/arrangement_overlay.h" 20 #include "src/trace_processor/db/column/data_layer.h" 21 #include "src/trace_processor/db/column/dense_null_overlay.h" 22 #include "src/trace_processor/db/column/numeric_storage.h" 23 #include "src/trace_processor/db/column/id_storage.h" 24 #include "src/trace_processor/db/column/null_overlay.h" 25 #include "src/trace_processor/db/column/range_overlay.h" 26 #include "src/trace_processor/db/column/selector_overlay.h" 27 #include "src/trace_processor/db/column/set_id_storage.h" 28 #include "src/trace_processor/db/column/string_storage.h" 29 #include "src/trace_processor/db/column/types.h" 30 #include "src/trace_processor/db/column_storage.h" 31 #include "src/trace_processor/db/column.h" 32 #include "src/trace_processor/db/table.h" 33 #include "src/trace_processor/db/typed_column.h" 34 #include "src/trace_processor/db/typed_column_internal.h" 35 #include "src/trace_processor/tables/macros_internal.h" 36 37 #include "src/trace_processor/tables/jit_tables_py.h" 38 39 namespace perfetto::trace_processor::tables { 40 41 class V8IsolateTable : public macros_internal::MacroTable { 42 public: 43 static constexpr uint32_t kColumnCount = 10; 44 45 struct Id : public BaseId { 46 Id() = default; IdId47 explicit constexpr Id(uint32_t v) : BaseId(v) {} 48 }; 49 static_assert(std::is_trivially_destructible_v<Id>, 50 "Inheritance used without trivial destruction"); 51 52 struct ColumnIndex { 53 static constexpr uint32_t id = 0; 54 static constexpr uint32_t type = 1; 55 static constexpr uint32_t upid = 2; 56 static constexpr uint32_t internal_isolate_id = 3; 57 static constexpr uint32_t embedded_blob_code_start_address = 4; 58 static constexpr uint32_t embedded_blob_code_size = 5; 59 static constexpr uint32_t code_range_base_address = 6; 60 static constexpr uint32_t code_range_size = 7; 61 static constexpr uint32_t shared_code_range = 8; 62 static constexpr uint32_t embedded_blob_code_copy_start_address = 9; 63 }; 64 struct ColumnType { 65 using id = IdColumn<V8IsolateTable::Id>; 66 using type = TypedColumn<StringPool::Id>; 67 using upid = TypedColumn<uint32_t>; 68 using internal_isolate_id = TypedColumn<int32_t>; 69 using embedded_blob_code_start_address = TypedColumn<int64_t>; 70 using embedded_blob_code_size = TypedColumn<int64_t>; 71 using code_range_base_address = TypedColumn<std::optional<int64_t>>; 72 using code_range_size = TypedColumn<std::optional<int64_t>>; 73 using shared_code_range = TypedColumn<std::optional<uint32_t>>; 74 using embedded_blob_code_copy_start_address = TypedColumn<std::optional<int64_t>>; 75 }; 76 struct Row : public macros_internal::RootParentTable::Row { 77 Row(uint32_t in_upid = {}, 78 int32_t in_internal_isolate_id = {}, 79 int64_t in_embedded_blob_code_start_address = {}, 80 int64_t in_embedded_blob_code_size = {}, 81 std::optional<int64_t> in_code_range_base_address = {}, 82 std::optional<int64_t> in_code_range_size = {}, 83 std::optional<uint32_t> in_shared_code_range = {}, 84 std::optional<int64_t> in_embedded_blob_code_copy_start_address = {}, 85 std::nullptr_t = nullptr) RowRow86 : macros_internal::RootParentTable::Row(), 87 upid(in_upid), 88 internal_isolate_id(in_internal_isolate_id), 89 embedded_blob_code_start_address(in_embedded_blob_code_start_address), 90 embedded_blob_code_size(in_embedded_blob_code_size), 91 code_range_base_address(in_code_range_base_address), 92 code_range_size(in_code_range_size), 93 shared_code_range(in_shared_code_range), 94 embedded_blob_code_copy_start_address(in_embedded_blob_code_copy_start_address) { 95 type_ = "__intrinsic_v8_isolate"; 96 } 97 uint32_t upid; 98 int32_t internal_isolate_id; 99 int64_t embedded_blob_code_start_address; 100 int64_t embedded_blob_code_size; 101 std::optional<int64_t> code_range_base_address; 102 std::optional<int64_t> code_range_size; 103 std::optional<uint32_t> shared_code_range; 104 std::optional<int64_t> embedded_blob_code_copy_start_address; 105 106 bool operator==(const V8IsolateTable::Row& other) const { 107 return type() == other.type() && ColumnType::upid::Equals(upid, other.upid) && 108 ColumnType::internal_isolate_id::Equals(internal_isolate_id, other.internal_isolate_id) && 109 ColumnType::embedded_blob_code_start_address::Equals(embedded_blob_code_start_address, other.embedded_blob_code_start_address) && 110 ColumnType::embedded_blob_code_size::Equals(embedded_blob_code_size, other.embedded_blob_code_size) && 111 ColumnType::code_range_base_address::Equals(code_range_base_address, other.code_range_base_address) && 112 ColumnType::code_range_size::Equals(code_range_size, other.code_range_size) && 113 ColumnType::shared_code_range::Equals(shared_code_range, other.shared_code_range) && 114 ColumnType::embedded_blob_code_copy_start_address::Equals(embedded_blob_code_copy_start_address, other.embedded_blob_code_copy_start_address); 115 } 116 }; 117 struct ColumnFlag { 118 static constexpr uint32_t upid = ColumnType::upid::default_flags(); 119 static constexpr uint32_t internal_isolate_id = ColumnType::internal_isolate_id::default_flags(); 120 static constexpr uint32_t embedded_blob_code_start_address = ColumnType::embedded_blob_code_start_address::default_flags(); 121 static constexpr uint32_t embedded_blob_code_size = ColumnType::embedded_blob_code_size::default_flags(); 122 static constexpr uint32_t code_range_base_address = ColumnType::code_range_base_address::default_flags(); 123 static constexpr uint32_t code_range_size = ColumnType::code_range_size::default_flags(); 124 static constexpr uint32_t shared_code_range = ColumnType::shared_code_range::default_flags(); 125 static constexpr uint32_t embedded_blob_code_copy_start_address = ColumnType::embedded_blob_code_copy_start_address::default_flags(); 126 }; 127 128 class RowNumber; 129 class ConstRowReference; 130 class RowReference; 131 132 class RowNumber : public macros_internal::AbstractRowNumber< 133 V8IsolateTable, ConstRowReference, RowReference> { 134 public: RowNumber(uint32_t row_number)135 explicit RowNumber(uint32_t row_number) 136 : AbstractRowNumber(row_number) {} 137 }; 138 static_assert(std::is_trivially_destructible_v<RowNumber>, 139 "Inheritance used without trivial destruction"); 140 141 class ConstRowReference : public macros_internal::AbstractConstRowReference< 142 V8IsolateTable, RowNumber> { 143 public: ConstRowReference(const V8IsolateTable * table,uint32_t row_number)144 ConstRowReference(const V8IsolateTable* table, uint32_t row_number) 145 : AbstractConstRowReference(table, row_number) {} 146 id()147 ColumnType::id::type id() const { 148 return table()->id()[row_number_]; 149 } type()150 ColumnType::type::type type() const { 151 return table()->type()[row_number_]; 152 } upid()153 ColumnType::upid::type upid() const { 154 return table()->upid()[row_number_]; 155 } internal_isolate_id()156 ColumnType::internal_isolate_id::type internal_isolate_id() const { 157 return table()->internal_isolate_id()[row_number_]; 158 } embedded_blob_code_start_address()159 ColumnType::embedded_blob_code_start_address::type embedded_blob_code_start_address() const { 160 return table()->embedded_blob_code_start_address()[row_number_]; 161 } embedded_blob_code_size()162 ColumnType::embedded_blob_code_size::type embedded_blob_code_size() const { 163 return table()->embedded_blob_code_size()[row_number_]; 164 } code_range_base_address()165 ColumnType::code_range_base_address::type code_range_base_address() const { 166 return table()->code_range_base_address()[row_number_]; 167 } code_range_size()168 ColumnType::code_range_size::type code_range_size() const { 169 return table()->code_range_size()[row_number_]; 170 } shared_code_range()171 ColumnType::shared_code_range::type shared_code_range() const { 172 return table()->shared_code_range()[row_number_]; 173 } embedded_blob_code_copy_start_address()174 ColumnType::embedded_blob_code_copy_start_address::type embedded_blob_code_copy_start_address() const { 175 return table()->embedded_blob_code_copy_start_address()[row_number_]; 176 } 177 }; 178 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 179 "Inheritance used without trivial destruction"); 180 class RowReference : public ConstRowReference { 181 public: RowReference(const V8IsolateTable * table,uint32_t row_number)182 RowReference(const V8IsolateTable* table, uint32_t row_number) 183 : ConstRowReference(table, row_number) {} 184 set_upid(ColumnType::upid::non_optional_type v)185 void set_upid( 186 ColumnType::upid::non_optional_type v) { 187 return mutable_table()->mutable_upid()->Set(row_number_, v); 188 } set_internal_isolate_id(ColumnType::internal_isolate_id::non_optional_type v)189 void set_internal_isolate_id( 190 ColumnType::internal_isolate_id::non_optional_type v) { 191 return mutable_table()->mutable_internal_isolate_id()->Set(row_number_, v); 192 } set_embedded_blob_code_start_address(ColumnType::embedded_blob_code_start_address::non_optional_type v)193 void set_embedded_blob_code_start_address( 194 ColumnType::embedded_blob_code_start_address::non_optional_type v) { 195 return mutable_table()->mutable_embedded_blob_code_start_address()->Set(row_number_, v); 196 } set_embedded_blob_code_size(ColumnType::embedded_blob_code_size::non_optional_type v)197 void set_embedded_blob_code_size( 198 ColumnType::embedded_blob_code_size::non_optional_type v) { 199 return mutable_table()->mutable_embedded_blob_code_size()->Set(row_number_, v); 200 } set_code_range_base_address(ColumnType::code_range_base_address::non_optional_type v)201 void set_code_range_base_address( 202 ColumnType::code_range_base_address::non_optional_type v) { 203 return mutable_table()->mutable_code_range_base_address()->Set(row_number_, v); 204 } set_code_range_size(ColumnType::code_range_size::non_optional_type v)205 void set_code_range_size( 206 ColumnType::code_range_size::non_optional_type v) { 207 return mutable_table()->mutable_code_range_size()->Set(row_number_, v); 208 } set_shared_code_range(ColumnType::shared_code_range::non_optional_type v)209 void set_shared_code_range( 210 ColumnType::shared_code_range::non_optional_type v) { 211 return mutable_table()->mutable_shared_code_range()->Set(row_number_, v); 212 } set_embedded_blob_code_copy_start_address(ColumnType::embedded_blob_code_copy_start_address::non_optional_type v)213 void set_embedded_blob_code_copy_start_address( 214 ColumnType::embedded_blob_code_copy_start_address::non_optional_type v) { 215 return mutable_table()->mutable_embedded_blob_code_copy_start_address()->Set(row_number_, v); 216 } 217 218 private: mutable_table()219 V8IsolateTable* mutable_table() const { 220 return const_cast<V8IsolateTable*>(table()); 221 } 222 }; 223 static_assert(std::is_trivially_destructible_v<RowReference>, 224 "Inheritance used without trivial destruction"); 225 226 class ConstIterator; 227 class ConstIterator : public macros_internal::AbstractConstIterator< 228 ConstIterator, V8IsolateTable, RowNumber, ConstRowReference> { 229 public: id()230 ColumnType::id::type id() const { 231 const auto& col = table()->id(); 232 return col.GetAtIdx( 233 iterator_.StorageIndexForColumn(col.index_in_table())); 234 } type()235 ColumnType::type::type type() const { 236 const auto& col = table()->type(); 237 return col.GetAtIdx( 238 iterator_.StorageIndexForColumn(col.index_in_table())); 239 } upid()240 ColumnType::upid::type upid() const { 241 const auto& col = table()->upid(); 242 return col.GetAtIdx( 243 iterator_.StorageIndexForColumn(col.index_in_table())); 244 } internal_isolate_id()245 ColumnType::internal_isolate_id::type internal_isolate_id() const { 246 const auto& col = table()->internal_isolate_id(); 247 return col.GetAtIdx( 248 iterator_.StorageIndexForColumn(col.index_in_table())); 249 } embedded_blob_code_start_address()250 ColumnType::embedded_blob_code_start_address::type embedded_blob_code_start_address() const { 251 const auto& col = table()->embedded_blob_code_start_address(); 252 return col.GetAtIdx( 253 iterator_.StorageIndexForColumn(col.index_in_table())); 254 } embedded_blob_code_size()255 ColumnType::embedded_blob_code_size::type embedded_blob_code_size() const { 256 const auto& col = table()->embedded_blob_code_size(); 257 return col.GetAtIdx( 258 iterator_.StorageIndexForColumn(col.index_in_table())); 259 } code_range_base_address()260 ColumnType::code_range_base_address::type code_range_base_address() const { 261 const auto& col = table()->code_range_base_address(); 262 return col.GetAtIdx( 263 iterator_.StorageIndexForColumn(col.index_in_table())); 264 } code_range_size()265 ColumnType::code_range_size::type code_range_size() const { 266 const auto& col = table()->code_range_size(); 267 return col.GetAtIdx( 268 iterator_.StorageIndexForColumn(col.index_in_table())); 269 } shared_code_range()270 ColumnType::shared_code_range::type shared_code_range() const { 271 const auto& col = table()->shared_code_range(); 272 return col.GetAtIdx( 273 iterator_.StorageIndexForColumn(col.index_in_table())); 274 } embedded_blob_code_copy_start_address()275 ColumnType::embedded_blob_code_copy_start_address::type embedded_blob_code_copy_start_address() const { 276 const auto& col = table()->embedded_blob_code_copy_start_address(); 277 return col.GetAtIdx( 278 iterator_.StorageIndexForColumn(col.index_in_table())); 279 } 280 281 protected: ConstIterator(const V8IsolateTable * table,Table::Iterator iterator)282 explicit ConstIterator(const V8IsolateTable* table, 283 Table::Iterator iterator) 284 : AbstractConstIterator(table, std::move(iterator)) {} 285 CurrentRowNumber()286 uint32_t CurrentRowNumber() const { 287 return iterator_.StorageIndexForLastOverlay(); 288 } 289 290 private: 291 friend class V8IsolateTable; 292 friend class macros_internal::AbstractConstIterator< 293 ConstIterator, V8IsolateTable, RowNumber, ConstRowReference>; 294 }; 295 class Iterator : public ConstIterator { 296 public: row_reference()297 RowReference row_reference() const { 298 return {const_cast<V8IsolateTable*>(table()), CurrentRowNumber()}; 299 } 300 301 private: 302 friend class V8IsolateTable; 303 Iterator(V8IsolateTable * table,Table::Iterator iterator)304 explicit Iterator(V8IsolateTable* table, Table::Iterator iterator) 305 : ConstIterator(table, std::move(iterator)) {} 306 }; 307 308 struct IdAndRow { 309 Id id; 310 uint32_t row; 311 RowReference row_reference; 312 RowNumber row_number; 313 }; 314 GetColumns(V8IsolateTable * self,const macros_internal::MacroTable * parent)315 static std::vector<ColumnLegacy> GetColumns( 316 V8IsolateTable* self, 317 const macros_internal::MacroTable* parent) { 318 std::vector<ColumnLegacy> columns = 319 CopyColumnsFromParentOrAddRootColumns(self, parent); 320 uint32_t olay_idx = OverlayCount(parent); 321 AddColumnToVector(columns, "upid", &self->upid_, ColumnFlag::upid, 322 static_cast<uint32_t>(columns.size()), olay_idx); 323 AddColumnToVector(columns, "internal_isolate_id", &self->internal_isolate_id_, ColumnFlag::internal_isolate_id, 324 static_cast<uint32_t>(columns.size()), olay_idx); 325 AddColumnToVector(columns, "embedded_blob_code_start_address", &self->embedded_blob_code_start_address_, ColumnFlag::embedded_blob_code_start_address, 326 static_cast<uint32_t>(columns.size()), olay_idx); 327 AddColumnToVector(columns, "embedded_blob_code_size", &self->embedded_blob_code_size_, ColumnFlag::embedded_blob_code_size, 328 static_cast<uint32_t>(columns.size()), olay_idx); 329 AddColumnToVector(columns, "code_range_base_address", &self->code_range_base_address_, ColumnFlag::code_range_base_address, 330 static_cast<uint32_t>(columns.size()), olay_idx); 331 AddColumnToVector(columns, "code_range_size", &self->code_range_size_, ColumnFlag::code_range_size, 332 static_cast<uint32_t>(columns.size()), olay_idx); 333 AddColumnToVector(columns, "shared_code_range", &self->shared_code_range_, ColumnFlag::shared_code_range, 334 static_cast<uint32_t>(columns.size()), olay_idx); 335 AddColumnToVector(columns, "embedded_blob_code_copy_start_address", &self->embedded_blob_code_copy_start_address_, ColumnFlag::embedded_blob_code_copy_start_address, 336 static_cast<uint32_t>(columns.size()), olay_idx); 337 return columns; 338 } 339 V8IsolateTable(StringPool * pool)340 PERFETTO_NO_INLINE explicit V8IsolateTable(StringPool* pool) 341 : macros_internal::MacroTable( 342 pool, 343 GetColumns(this, nullptr), 344 nullptr), 345 upid_(ColumnStorage<ColumnType::upid::stored_type>::Create<false>()), 346 internal_isolate_id_(ColumnStorage<ColumnType::internal_isolate_id::stored_type>::Create<false>()), 347 embedded_blob_code_start_address_(ColumnStorage<ColumnType::embedded_blob_code_start_address::stored_type>::Create<false>()), 348 embedded_blob_code_size_(ColumnStorage<ColumnType::embedded_blob_code_size::stored_type>::Create<false>()), 349 code_range_base_address_(ColumnStorage<ColumnType::code_range_base_address::stored_type>::Create<false>()), 350 code_range_size_(ColumnStorage<ColumnType::code_range_size::stored_type>::Create<false>()), 351 shared_code_range_(ColumnStorage<ColumnType::shared_code_range::stored_type>::Create<false>()), 352 embedded_blob_code_copy_start_address_(ColumnStorage<ColumnType::embedded_blob_code_copy_start_address::stored_type>::Create<false>()) 353 , 354 id_storage_layer_(new column::IdStorage()), 355 type_storage_layer_( 356 new column::StringStorage(string_pool(), &type_.vector())), 357 upid_storage_layer_( 358 new column::NumericStorage<ColumnType::upid::non_optional_stored_type>( 359 &upid_.vector(), 360 ColumnTypeHelper<ColumnType::upid::stored_type>::ToColumnType(), 361 false)), 362 internal_isolate_id_storage_layer_( 363 new column::NumericStorage<ColumnType::internal_isolate_id::non_optional_stored_type>( 364 &internal_isolate_id_.vector(), 365 ColumnTypeHelper<ColumnType::internal_isolate_id::stored_type>::ToColumnType(), 366 false)), 367 embedded_blob_code_start_address_storage_layer_( 368 new column::NumericStorage<ColumnType::embedded_blob_code_start_address::non_optional_stored_type>( 369 &embedded_blob_code_start_address_.vector(), 370 ColumnTypeHelper<ColumnType::embedded_blob_code_start_address::stored_type>::ToColumnType(), 371 false)), 372 embedded_blob_code_size_storage_layer_( 373 new column::NumericStorage<ColumnType::embedded_blob_code_size::non_optional_stored_type>( 374 &embedded_blob_code_size_.vector(), 375 ColumnTypeHelper<ColumnType::embedded_blob_code_size::stored_type>::ToColumnType(), 376 false)), 377 code_range_base_address_storage_layer_( 378 new column::NumericStorage<ColumnType::code_range_base_address::non_optional_stored_type>( 379 &code_range_base_address_.non_null_vector(), 380 ColumnTypeHelper<ColumnType::code_range_base_address::stored_type>::ToColumnType(), 381 false)), 382 code_range_size_storage_layer_( 383 new column::NumericStorage<ColumnType::code_range_size::non_optional_stored_type>( 384 &code_range_size_.non_null_vector(), 385 ColumnTypeHelper<ColumnType::code_range_size::stored_type>::ToColumnType(), 386 false)), 387 shared_code_range_storage_layer_( 388 new column::NumericStorage<ColumnType::shared_code_range::non_optional_stored_type>( 389 &shared_code_range_.non_null_vector(), 390 ColumnTypeHelper<ColumnType::shared_code_range::stored_type>::ToColumnType(), 391 false)), 392 embedded_blob_code_copy_start_address_storage_layer_( 393 new column::NumericStorage<ColumnType::embedded_blob_code_copy_start_address::non_optional_stored_type>( 394 &embedded_blob_code_copy_start_address_.non_null_vector(), 395 ColumnTypeHelper<ColumnType::embedded_blob_code_copy_start_address::stored_type>::ToColumnType(), 396 false)) 397 , 398 code_range_base_address_null_layer_(new column::NullOverlay(code_range_base_address_.bv())), 399 code_range_size_null_layer_(new column::NullOverlay(code_range_size_.bv())), 400 shared_code_range_null_layer_(new column::NullOverlay(shared_code_range_.bv())), 401 embedded_blob_code_copy_start_address_null_layer_(new column::NullOverlay(embedded_blob_code_copy_start_address_.bv())) { 402 static_assert( 403 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::upid::stored_type>( 404 ColumnFlag::upid), 405 "Column type and flag combination is not valid"); 406 static_assert( 407 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::internal_isolate_id::stored_type>( 408 ColumnFlag::internal_isolate_id), 409 "Column type and flag combination is not valid"); 410 static_assert( 411 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::embedded_blob_code_start_address::stored_type>( 412 ColumnFlag::embedded_blob_code_start_address), 413 "Column type and flag combination is not valid"); 414 static_assert( 415 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::embedded_blob_code_size::stored_type>( 416 ColumnFlag::embedded_blob_code_size), 417 "Column type and flag combination is not valid"); 418 static_assert( 419 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::code_range_base_address::stored_type>( 420 ColumnFlag::code_range_base_address), 421 "Column type and flag combination is not valid"); 422 static_assert( 423 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::code_range_size::stored_type>( 424 ColumnFlag::code_range_size), 425 "Column type and flag combination is not valid"); 426 static_assert( 427 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::shared_code_range::stored_type>( 428 ColumnFlag::shared_code_range), 429 "Column type and flag combination is not valid"); 430 static_assert( 431 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::embedded_blob_code_copy_start_address::stored_type>( 432 ColumnFlag::embedded_blob_code_copy_start_address), 433 "Column type and flag combination is not valid"); 434 OnConstructionCompletedRegularConstructor( 435 {id_storage_layer_,type_storage_layer_,upid_storage_layer_,internal_isolate_id_storage_layer_,embedded_blob_code_start_address_storage_layer_,embedded_blob_code_size_storage_layer_,code_range_base_address_storage_layer_,code_range_size_storage_layer_,shared_code_range_storage_layer_,embedded_blob_code_copy_start_address_storage_layer_}, 436 {{},{},{},{},{},{},code_range_base_address_null_layer_,code_range_size_null_layer_,shared_code_range_null_layer_,embedded_blob_code_copy_start_address_null_layer_}); 437 } 438 ~V8IsolateTable() override; 439 Name()440 static const char* Name() { return "__intrinsic_v8_isolate"; } 441 ComputeStaticSchema()442 static Table::Schema ComputeStaticSchema() { 443 Table::Schema schema; 444 schema.columns.emplace_back(Table::Schema::Column{ 445 "id", SqlValue::Type::kLong, true, true, false, false}); 446 schema.columns.emplace_back(Table::Schema::Column{ 447 "type", SqlValue::Type::kString, false, false, false, false}); 448 schema.columns.emplace_back(Table::Schema::Column{ 449 "upid", ColumnType::upid::SqlValueType(), false, 450 false, 451 false, 452 false}); 453 schema.columns.emplace_back(Table::Schema::Column{ 454 "internal_isolate_id", ColumnType::internal_isolate_id::SqlValueType(), false, 455 false, 456 false, 457 false}); 458 schema.columns.emplace_back(Table::Schema::Column{ 459 "embedded_blob_code_start_address", ColumnType::embedded_blob_code_start_address::SqlValueType(), false, 460 false, 461 false, 462 false}); 463 schema.columns.emplace_back(Table::Schema::Column{ 464 "embedded_blob_code_size", ColumnType::embedded_blob_code_size::SqlValueType(), false, 465 false, 466 false, 467 false}); 468 schema.columns.emplace_back(Table::Schema::Column{ 469 "code_range_base_address", ColumnType::code_range_base_address::SqlValueType(), false, 470 false, 471 false, 472 false}); 473 schema.columns.emplace_back(Table::Schema::Column{ 474 "code_range_size", ColumnType::code_range_size::SqlValueType(), false, 475 false, 476 false, 477 false}); 478 schema.columns.emplace_back(Table::Schema::Column{ 479 "shared_code_range", ColumnType::shared_code_range::SqlValueType(), false, 480 false, 481 false, 482 false}); 483 schema.columns.emplace_back(Table::Schema::Column{ 484 "embedded_blob_code_copy_start_address", ColumnType::embedded_blob_code_copy_start_address::SqlValueType(), false, 485 false, 486 false, 487 false}); 488 return schema; 489 } 490 IterateRows()491 ConstIterator IterateRows() const { 492 return ConstIterator(this, Table::IterateRows()); 493 } 494 IterateRows()495 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 496 FilterToIterator(const Query & q)497 ConstIterator FilterToIterator(const Query& q) const { 498 return ConstIterator(this, QueryToIterator(q)); 499 } 500 FilterToIterator(const Query & q)501 Iterator FilterToIterator(const Query& q) { 502 return Iterator(this, QueryToIterator(q)); 503 } 504 ShrinkToFit()505 void ShrinkToFit() { 506 type_.ShrinkToFit(); 507 upid_.ShrinkToFit(); 508 internal_isolate_id_.ShrinkToFit(); 509 embedded_blob_code_start_address_.ShrinkToFit(); 510 embedded_blob_code_size_.ShrinkToFit(); 511 code_range_base_address_.ShrinkToFit(); 512 code_range_size_.ShrinkToFit(); 513 shared_code_range_.ShrinkToFit(); 514 embedded_blob_code_copy_start_address_.ShrinkToFit(); 515 } 516 517 ConstRowReference operator[](uint32_t r) const { 518 return ConstRowReference(this, r); 519 } 520 RowReference operator[](uint32_t r) { return RowReference(this, r); } 521 ConstRowReference operator[](RowNumber r) const { 522 return ConstRowReference(this, r.row_number()); 523 } 524 RowReference operator[](RowNumber r) { 525 return RowReference(this, r.row_number()); 526 } 527 FindById(Id find_id)528 std::optional<ConstRowReference> FindById(Id find_id) const { 529 std::optional<uint32_t> row = id().IndexOf(find_id); 530 return row ? std::make_optional(ConstRowReference(this, *row)) 531 : std::nullopt; 532 } 533 FindById(Id find_id)534 std::optional<RowReference> FindById(Id find_id) { 535 std::optional<uint32_t> row = id().IndexOf(find_id); 536 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 537 } 538 Insert(const Row & row)539 IdAndRow Insert(const Row& row) { 540 uint32_t row_number = row_count(); 541 Id id = Id{row_number}; 542 type_.Append(string_pool()->InternString(row.type())); 543 mutable_upid()->Append(row.upid); 544 mutable_internal_isolate_id()->Append(row.internal_isolate_id); 545 mutable_embedded_blob_code_start_address()->Append(row.embedded_blob_code_start_address); 546 mutable_embedded_blob_code_size()->Append(row.embedded_blob_code_size); 547 mutable_code_range_base_address()->Append(row.code_range_base_address); 548 mutable_code_range_size()->Append(row.code_range_size); 549 mutable_shared_code_range()->Append(row.shared_code_range); 550 mutable_embedded_blob_code_copy_start_address()->Append(row.embedded_blob_code_copy_start_address); 551 UpdateSelfOverlayAfterInsert(); 552 return IdAndRow{id, row_number, RowReference(this, row_number), 553 RowNumber(row_number)}; 554 } 555 556 557 id()558 const IdColumn<V8IsolateTable::Id>& id() const { 559 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 560 } type()561 const TypedColumn<StringPool::Id>& type() const { 562 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 563 } upid()564 const TypedColumn<uint32_t>& upid() const { 565 return static_cast<const ColumnType::upid&>(columns()[ColumnIndex::upid]); 566 } internal_isolate_id()567 const TypedColumn<int32_t>& internal_isolate_id() const { 568 return static_cast<const ColumnType::internal_isolate_id&>(columns()[ColumnIndex::internal_isolate_id]); 569 } embedded_blob_code_start_address()570 const TypedColumn<int64_t>& embedded_blob_code_start_address() const { 571 return static_cast<const ColumnType::embedded_blob_code_start_address&>(columns()[ColumnIndex::embedded_blob_code_start_address]); 572 } embedded_blob_code_size()573 const TypedColumn<int64_t>& embedded_blob_code_size() const { 574 return static_cast<const ColumnType::embedded_blob_code_size&>(columns()[ColumnIndex::embedded_blob_code_size]); 575 } code_range_base_address()576 const TypedColumn<std::optional<int64_t>>& code_range_base_address() const { 577 return static_cast<const ColumnType::code_range_base_address&>(columns()[ColumnIndex::code_range_base_address]); 578 } code_range_size()579 const TypedColumn<std::optional<int64_t>>& code_range_size() const { 580 return static_cast<const ColumnType::code_range_size&>(columns()[ColumnIndex::code_range_size]); 581 } shared_code_range()582 const TypedColumn<std::optional<uint32_t>>& shared_code_range() const { 583 return static_cast<const ColumnType::shared_code_range&>(columns()[ColumnIndex::shared_code_range]); 584 } embedded_blob_code_copy_start_address()585 const TypedColumn<std::optional<int64_t>>& embedded_blob_code_copy_start_address() const { 586 return static_cast<const ColumnType::embedded_blob_code_copy_start_address&>(columns()[ColumnIndex::embedded_blob_code_copy_start_address]); 587 } 588 mutable_upid()589 TypedColumn<uint32_t>* mutable_upid() { 590 return static_cast<ColumnType::upid*>( 591 GetColumn(ColumnIndex::upid)); 592 } mutable_internal_isolate_id()593 TypedColumn<int32_t>* mutable_internal_isolate_id() { 594 return static_cast<ColumnType::internal_isolate_id*>( 595 GetColumn(ColumnIndex::internal_isolate_id)); 596 } mutable_embedded_blob_code_start_address()597 TypedColumn<int64_t>* mutable_embedded_blob_code_start_address() { 598 return static_cast<ColumnType::embedded_blob_code_start_address*>( 599 GetColumn(ColumnIndex::embedded_blob_code_start_address)); 600 } mutable_embedded_blob_code_size()601 TypedColumn<int64_t>* mutable_embedded_blob_code_size() { 602 return static_cast<ColumnType::embedded_blob_code_size*>( 603 GetColumn(ColumnIndex::embedded_blob_code_size)); 604 } mutable_code_range_base_address()605 TypedColumn<std::optional<int64_t>>* mutable_code_range_base_address() { 606 return static_cast<ColumnType::code_range_base_address*>( 607 GetColumn(ColumnIndex::code_range_base_address)); 608 } mutable_code_range_size()609 TypedColumn<std::optional<int64_t>>* mutable_code_range_size() { 610 return static_cast<ColumnType::code_range_size*>( 611 GetColumn(ColumnIndex::code_range_size)); 612 } mutable_shared_code_range()613 TypedColumn<std::optional<uint32_t>>* mutable_shared_code_range() { 614 return static_cast<ColumnType::shared_code_range*>( 615 GetColumn(ColumnIndex::shared_code_range)); 616 } mutable_embedded_blob_code_copy_start_address()617 TypedColumn<std::optional<int64_t>>* mutable_embedded_blob_code_copy_start_address() { 618 return static_cast<ColumnType::embedded_blob_code_copy_start_address*>( 619 GetColumn(ColumnIndex::embedded_blob_code_copy_start_address)); 620 } 621 622 private: 623 624 625 ColumnStorage<ColumnType::upid::stored_type> upid_; 626 ColumnStorage<ColumnType::internal_isolate_id::stored_type> internal_isolate_id_; 627 ColumnStorage<ColumnType::embedded_blob_code_start_address::stored_type> embedded_blob_code_start_address_; 628 ColumnStorage<ColumnType::embedded_blob_code_size::stored_type> embedded_blob_code_size_; 629 ColumnStorage<ColumnType::code_range_base_address::stored_type> code_range_base_address_; 630 ColumnStorage<ColumnType::code_range_size::stored_type> code_range_size_; 631 ColumnStorage<ColumnType::shared_code_range::stored_type> shared_code_range_; 632 ColumnStorage<ColumnType::embedded_blob_code_copy_start_address::stored_type> embedded_blob_code_copy_start_address_; 633 634 RefPtr<column::StorageLayer> id_storage_layer_; 635 RefPtr<column::StorageLayer> type_storage_layer_; 636 RefPtr<column::StorageLayer> upid_storage_layer_; 637 RefPtr<column::StorageLayer> internal_isolate_id_storage_layer_; 638 RefPtr<column::StorageLayer> embedded_blob_code_start_address_storage_layer_; 639 RefPtr<column::StorageLayer> embedded_blob_code_size_storage_layer_; 640 RefPtr<column::StorageLayer> code_range_base_address_storage_layer_; 641 RefPtr<column::StorageLayer> code_range_size_storage_layer_; 642 RefPtr<column::StorageLayer> shared_code_range_storage_layer_; 643 RefPtr<column::StorageLayer> embedded_blob_code_copy_start_address_storage_layer_; 644 645 RefPtr<column::OverlayLayer> code_range_base_address_null_layer_; 646 RefPtr<column::OverlayLayer> code_range_size_null_layer_; 647 RefPtr<column::OverlayLayer> shared_code_range_null_layer_; 648 RefPtr<column::OverlayLayer> embedded_blob_code_copy_start_address_null_layer_; 649 }; 650 651 652 class V8JsScriptTable : public macros_internal::MacroTable { 653 public: 654 static constexpr uint32_t kColumnCount = 7; 655 656 struct Id : public BaseId { 657 Id() = default; IdId658 explicit constexpr Id(uint32_t v) : BaseId(v) {} 659 }; 660 static_assert(std::is_trivially_destructible_v<Id>, 661 "Inheritance used without trivial destruction"); 662 663 struct ColumnIndex { 664 static constexpr uint32_t id = 0; 665 static constexpr uint32_t type = 1; 666 static constexpr uint32_t v8_isolate_id = 2; 667 static constexpr uint32_t internal_script_id = 3; 668 static constexpr uint32_t script_type = 4; 669 static constexpr uint32_t name = 5; 670 static constexpr uint32_t source = 6; 671 }; 672 struct ColumnType { 673 using id = IdColumn<V8JsScriptTable::Id>; 674 using type = TypedColumn<StringPool::Id>; 675 using v8_isolate_id = TypedColumn<V8IsolateTable::Id>; 676 using internal_script_id = TypedColumn<int32_t>; 677 using script_type = TypedColumn<StringPool::Id>; 678 using name = TypedColumn<StringPool::Id>; 679 using source = TypedColumn<std::optional<StringPool::Id>>; 680 }; 681 struct Row : public macros_internal::RootParentTable::Row { 682 Row(V8IsolateTable::Id in_v8_isolate_id = {}, 683 int32_t in_internal_script_id = {}, 684 StringPool::Id in_script_type = {}, 685 StringPool::Id in_name = {}, 686 std::optional<StringPool::Id> in_source = {}, 687 std::nullptr_t = nullptr) RowRow688 : macros_internal::RootParentTable::Row(), 689 v8_isolate_id(in_v8_isolate_id), 690 internal_script_id(in_internal_script_id), 691 script_type(in_script_type), 692 name(in_name), 693 source(in_source) { 694 type_ = "__intrinsic_v8_js_script"; 695 } 696 V8IsolateTable::Id v8_isolate_id; 697 int32_t internal_script_id; 698 StringPool::Id script_type; 699 StringPool::Id name; 700 std::optional<StringPool::Id> source; 701 702 bool operator==(const V8JsScriptTable::Row& other) const { 703 return type() == other.type() && ColumnType::v8_isolate_id::Equals(v8_isolate_id, other.v8_isolate_id) && 704 ColumnType::internal_script_id::Equals(internal_script_id, other.internal_script_id) && 705 ColumnType::script_type::Equals(script_type, other.script_type) && 706 ColumnType::name::Equals(name, other.name) && 707 ColumnType::source::Equals(source, other.source); 708 } 709 }; 710 struct ColumnFlag { 711 static constexpr uint32_t v8_isolate_id = ColumnType::v8_isolate_id::default_flags(); 712 static constexpr uint32_t internal_script_id = ColumnType::internal_script_id::default_flags(); 713 static constexpr uint32_t script_type = ColumnType::script_type::default_flags(); 714 static constexpr uint32_t name = ColumnType::name::default_flags(); 715 static constexpr uint32_t source = ColumnType::source::default_flags(); 716 }; 717 718 class RowNumber; 719 class ConstRowReference; 720 class RowReference; 721 722 class RowNumber : public macros_internal::AbstractRowNumber< 723 V8JsScriptTable, ConstRowReference, RowReference> { 724 public: RowNumber(uint32_t row_number)725 explicit RowNumber(uint32_t row_number) 726 : AbstractRowNumber(row_number) {} 727 }; 728 static_assert(std::is_trivially_destructible_v<RowNumber>, 729 "Inheritance used without trivial destruction"); 730 731 class ConstRowReference : public macros_internal::AbstractConstRowReference< 732 V8JsScriptTable, RowNumber> { 733 public: ConstRowReference(const V8JsScriptTable * table,uint32_t row_number)734 ConstRowReference(const V8JsScriptTable* table, uint32_t row_number) 735 : AbstractConstRowReference(table, row_number) {} 736 id()737 ColumnType::id::type id() const { 738 return table()->id()[row_number_]; 739 } type()740 ColumnType::type::type type() const { 741 return table()->type()[row_number_]; 742 } v8_isolate_id()743 ColumnType::v8_isolate_id::type v8_isolate_id() const { 744 return table()->v8_isolate_id()[row_number_]; 745 } internal_script_id()746 ColumnType::internal_script_id::type internal_script_id() const { 747 return table()->internal_script_id()[row_number_]; 748 } script_type()749 ColumnType::script_type::type script_type() const { 750 return table()->script_type()[row_number_]; 751 } name()752 ColumnType::name::type name() const { 753 return table()->name()[row_number_]; 754 } source()755 ColumnType::source::type source() const { 756 return table()->source()[row_number_]; 757 } 758 }; 759 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 760 "Inheritance used without trivial destruction"); 761 class RowReference : public ConstRowReference { 762 public: RowReference(const V8JsScriptTable * table,uint32_t row_number)763 RowReference(const V8JsScriptTable* table, uint32_t row_number) 764 : ConstRowReference(table, row_number) {} 765 set_v8_isolate_id(ColumnType::v8_isolate_id::non_optional_type v)766 void set_v8_isolate_id( 767 ColumnType::v8_isolate_id::non_optional_type v) { 768 return mutable_table()->mutable_v8_isolate_id()->Set(row_number_, v); 769 } set_internal_script_id(ColumnType::internal_script_id::non_optional_type v)770 void set_internal_script_id( 771 ColumnType::internal_script_id::non_optional_type v) { 772 return mutable_table()->mutable_internal_script_id()->Set(row_number_, v); 773 } set_script_type(ColumnType::script_type::non_optional_type v)774 void set_script_type( 775 ColumnType::script_type::non_optional_type v) { 776 return mutable_table()->mutable_script_type()->Set(row_number_, v); 777 } set_name(ColumnType::name::non_optional_type v)778 void set_name( 779 ColumnType::name::non_optional_type v) { 780 return mutable_table()->mutable_name()->Set(row_number_, v); 781 } set_source(ColumnType::source::non_optional_type v)782 void set_source( 783 ColumnType::source::non_optional_type v) { 784 return mutable_table()->mutable_source()->Set(row_number_, v); 785 } 786 787 private: mutable_table()788 V8JsScriptTable* mutable_table() const { 789 return const_cast<V8JsScriptTable*>(table()); 790 } 791 }; 792 static_assert(std::is_trivially_destructible_v<RowReference>, 793 "Inheritance used without trivial destruction"); 794 795 class ConstIterator; 796 class ConstIterator : public macros_internal::AbstractConstIterator< 797 ConstIterator, V8JsScriptTable, RowNumber, ConstRowReference> { 798 public: id()799 ColumnType::id::type id() const { 800 const auto& col = table()->id(); 801 return col.GetAtIdx( 802 iterator_.StorageIndexForColumn(col.index_in_table())); 803 } type()804 ColumnType::type::type type() const { 805 const auto& col = table()->type(); 806 return col.GetAtIdx( 807 iterator_.StorageIndexForColumn(col.index_in_table())); 808 } v8_isolate_id()809 ColumnType::v8_isolate_id::type v8_isolate_id() const { 810 const auto& col = table()->v8_isolate_id(); 811 return col.GetAtIdx( 812 iterator_.StorageIndexForColumn(col.index_in_table())); 813 } internal_script_id()814 ColumnType::internal_script_id::type internal_script_id() const { 815 const auto& col = table()->internal_script_id(); 816 return col.GetAtIdx( 817 iterator_.StorageIndexForColumn(col.index_in_table())); 818 } script_type()819 ColumnType::script_type::type script_type() const { 820 const auto& col = table()->script_type(); 821 return col.GetAtIdx( 822 iterator_.StorageIndexForColumn(col.index_in_table())); 823 } name()824 ColumnType::name::type name() const { 825 const auto& col = table()->name(); 826 return col.GetAtIdx( 827 iterator_.StorageIndexForColumn(col.index_in_table())); 828 } source()829 ColumnType::source::type source() const { 830 const auto& col = table()->source(); 831 return col.GetAtIdx( 832 iterator_.StorageIndexForColumn(col.index_in_table())); 833 } 834 835 protected: ConstIterator(const V8JsScriptTable * table,Table::Iterator iterator)836 explicit ConstIterator(const V8JsScriptTable* table, 837 Table::Iterator iterator) 838 : AbstractConstIterator(table, std::move(iterator)) {} 839 CurrentRowNumber()840 uint32_t CurrentRowNumber() const { 841 return iterator_.StorageIndexForLastOverlay(); 842 } 843 844 private: 845 friend class V8JsScriptTable; 846 friend class macros_internal::AbstractConstIterator< 847 ConstIterator, V8JsScriptTable, RowNumber, ConstRowReference>; 848 }; 849 class Iterator : public ConstIterator { 850 public: row_reference()851 RowReference row_reference() const { 852 return {const_cast<V8JsScriptTable*>(table()), CurrentRowNumber()}; 853 } 854 855 private: 856 friend class V8JsScriptTable; 857 Iterator(V8JsScriptTable * table,Table::Iterator iterator)858 explicit Iterator(V8JsScriptTable* table, Table::Iterator iterator) 859 : ConstIterator(table, std::move(iterator)) {} 860 }; 861 862 struct IdAndRow { 863 Id id; 864 uint32_t row; 865 RowReference row_reference; 866 RowNumber row_number; 867 }; 868 GetColumns(V8JsScriptTable * self,const macros_internal::MacroTable * parent)869 static std::vector<ColumnLegacy> GetColumns( 870 V8JsScriptTable* self, 871 const macros_internal::MacroTable* parent) { 872 std::vector<ColumnLegacy> columns = 873 CopyColumnsFromParentOrAddRootColumns(self, parent); 874 uint32_t olay_idx = OverlayCount(parent); 875 AddColumnToVector(columns, "v8_isolate_id", &self->v8_isolate_id_, ColumnFlag::v8_isolate_id, 876 static_cast<uint32_t>(columns.size()), olay_idx); 877 AddColumnToVector(columns, "internal_script_id", &self->internal_script_id_, ColumnFlag::internal_script_id, 878 static_cast<uint32_t>(columns.size()), olay_idx); 879 AddColumnToVector(columns, "script_type", &self->script_type_, ColumnFlag::script_type, 880 static_cast<uint32_t>(columns.size()), olay_idx); 881 AddColumnToVector(columns, "name", &self->name_, ColumnFlag::name, 882 static_cast<uint32_t>(columns.size()), olay_idx); 883 AddColumnToVector(columns, "source", &self->source_, ColumnFlag::source, 884 static_cast<uint32_t>(columns.size()), olay_idx); 885 return columns; 886 } 887 V8JsScriptTable(StringPool * pool)888 PERFETTO_NO_INLINE explicit V8JsScriptTable(StringPool* pool) 889 : macros_internal::MacroTable( 890 pool, 891 GetColumns(this, nullptr), 892 nullptr), 893 v8_isolate_id_(ColumnStorage<ColumnType::v8_isolate_id::stored_type>::Create<false>()), 894 internal_script_id_(ColumnStorage<ColumnType::internal_script_id::stored_type>::Create<false>()), 895 script_type_(ColumnStorage<ColumnType::script_type::stored_type>::Create<false>()), 896 name_(ColumnStorage<ColumnType::name::stored_type>::Create<false>()), 897 source_(ColumnStorage<ColumnType::source::stored_type>::Create<false>()) 898 , 899 id_storage_layer_(new column::IdStorage()), 900 type_storage_layer_( 901 new column::StringStorage(string_pool(), &type_.vector())), 902 v8_isolate_id_storage_layer_( 903 new column::NumericStorage<ColumnType::v8_isolate_id::non_optional_stored_type>( 904 &v8_isolate_id_.vector(), 905 ColumnTypeHelper<ColumnType::v8_isolate_id::stored_type>::ToColumnType(), 906 false)), 907 internal_script_id_storage_layer_( 908 new column::NumericStorage<ColumnType::internal_script_id::non_optional_stored_type>( 909 &internal_script_id_.vector(), 910 ColumnTypeHelper<ColumnType::internal_script_id::stored_type>::ToColumnType(), 911 false)), 912 script_type_storage_layer_( 913 new column::StringStorage(string_pool(), &script_type_.vector())), 914 name_storage_layer_( 915 new column::StringStorage(string_pool(), &name_.vector())), 916 source_storage_layer_( 917 new column::StringStorage(string_pool(), &source_.vector())) 918 { 919 static_assert( 920 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::v8_isolate_id::stored_type>( 921 ColumnFlag::v8_isolate_id), 922 "Column type and flag combination is not valid"); 923 static_assert( 924 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::internal_script_id::stored_type>( 925 ColumnFlag::internal_script_id), 926 "Column type and flag combination is not valid"); 927 static_assert( 928 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::script_type::stored_type>( 929 ColumnFlag::script_type), 930 "Column type and flag combination is not valid"); 931 static_assert( 932 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::name::stored_type>( 933 ColumnFlag::name), 934 "Column type and flag combination is not valid"); 935 static_assert( 936 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::source::stored_type>( 937 ColumnFlag::source), 938 "Column type and flag combination is not valid"); 939 OnConstructionCompletedRegularConstructor( 940 {id_storage_layer_,type_storage_layer_,v8_isolate_id_storage_layer_,internal_script_id_storage_layer_,script_type_storage_layer_,name_storage_layer_,source_storage_layer_}, 941 {{},{},{},{},{},{},{}}); 942 } 943 ~V8JsScriptTable() override; 944 Name()945 static const char* Name() { return "__intrinsic_v8_js_script"; } 946 ComputeStaticSchema()947 static Table::Schema ComputeStaticSchema() { 948 Table::Schema schema; 949 schema.columns.emplace_back(Table::Schema::Column{ 950 "id", SqlValue::Type::kLong, true, true, false, false}); 951 schema.columns.emplace_back(Table::Schema::Column{ 952 "type", SqlValue::Type::kString, false, false, false, false}); 953 schema.columns.emplace_back(Table::Schema::Column{ 954 "v8_isolate_id", ColumnType::v8_isolate_id::SqlValueType(), false, 955 false, 956 false, 957 false}); 958 schema.columns.emplace_back(Table::Schema::Column{ 959 "internal_script_id", ColumnType::internal_script_id::SqlValueType(), false, 960 false, 961 false, 962 false}); 963 schema.columns.emplace_back(Table::Schema::Column{ 964 "script_type", ColumnType::script_type::SqlValueType(), false, 965 false, 966 false, 967 false}); 968 schema.columns.emplace_back(Table::Schema::Column{ 969 "name", ColumnType::name::SqlValueType(), false, 970 false, 971 false, 972 false}); 973 schema.columns.emplace_back(Table::Schema::Column{ 974 "source", ColumnType::source::SqlValueType(), false, 975 false, 976 false, 977 false}); 978 return schema; 979 } 980 IterateRows()981 ConstIterator IterateRows() const { 982 return ConstIterator(this, Table::IterateRows()); 983 } 984 IterateRows()985 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 986 FilterToIterator(const Query & q)987 ConstIterator FilterToIterator(const Query& q) const { 988 return ConstIterator(this, QueryToIterator(q)); 989 } 990 FilterToIterator(const Query & q)991 Iterator FilterToIterator(const Query& q) { 992 return Iterator(this, QueryToIterator(q)); 993 } 994 ShrinkToFit()995 void ShrinkToFit() { 996 type_.ShrinkToFit(); 997 v8_isolate_id_.ShrinkToFit(); 998 internal_script_id_.ShrinkToFit(); 999 script_type_.ShrinkToFit(); 1000 name_.ShrinkToFit(); 1001 source_.ShrinkToFit(); 1002 } 1003 1004 ConstRowReference operator[](uint32_t r) const { 1005 return ConstRowReference(this, r); 1006 } 1007 RowReference operator[](uint32_t r) { return RowReference(this, r); } 1008 ConstRowReference operator[](RowNumber r) const { 1009 return ConstRowReference(this, r.row_number()); 1010 } 1011 RowReference operator[](RowNumber r) { 1012 return RowReference(this, r.row_number()); 1013 } 1014 FindById(Id find_id)1015 std::optional<ConstRowReference> FindById(Id find_id) const { 1016 std::optional<uint32_t> row = id().IndexOf(find_id); 1017 return row ? std::make_optional(ConstRowReference(this, *row)) 1018 : std::nullopt; 1019 } 1020 FindById(Id find_id)1021 std::optional<RowReference> FindById(Id find_id) { 1022 std::optional<uint32_t> row = id().IndexOf(find_id); 1023 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 1024 } 1025 Insert(const Row & row)1026 IdAndRow Insert(const Row& row) { 1027 uint32_t row_number = row_count(); 1028 Id id = Id{row_number}; 1029 type_.Append(string_pool()->InternString(row.type())); 1030 mutable_v8_isolate_id()->Append(row.v8_isolate_id); 1031 mutable_internal_script_id()->Append(row.internal_script_id); 1032 mutable_script_type()->Append(row.script_type); 1033 mutable_name()->Append(row.name); 1034 mutable_source()->Append(row.source); 1035 UpdateSelfOverlayAfterInsert(); 1036 return IdAndRow{id, row_number, RowReference(this, row_number), 1037 RowNumber(row_number)}; 1038 } 1039 1040 1041 id()1042 const IdColumn<V8JsScriptTable::Id>& id() const { 1043 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 1044 } type()1045 const TypedColumn<StringPool::Id>& type() const { 1046 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 1047 } v8_isolate_id()1048 const TypedColumn<V8IsolateTable::Id>& v8_isolate_id() const { 1049 return static_cast<const ColumnType::v8_isolate_id&>(columns()[ColumnIndex::v8_isolate_id]); 1050 } internal_script_id()1051 const TypedColumn<int32_t>& internal_script_id() const { 1052 return static_cast<const ColumnType::internal_script_id&>(columns()[ColumnIndex::internal_script_id]); 1053 } script_type()1054 const TypedColumn<StringPool::Id>& script_type() const { 1055 return static_cast<const ColumnType::script_type&>(columns()[ColumnIndex::script_type]); 1056 } name()1057 const TypedColumn<StringPool::Id>& name() const { 1058 return static_cast<const ColumnType::name&>(columns()[ColumnIndex::name]); 1059 } source()1060 const TypedColumn<std::optional<StringPool::Id>>& source() const { 1061 return static_cast<const ColumnType::source&>(columns()[ColumnIndex::source]); 1062 } 1063 mutable_v8_isolate_id()1064 TypedColumn<V8IsolateTable::Id>* mutable_v8_isolate_id() { 1065 return static_cast<ColumnType::v8_isolate_id*>( 1066 GetColumn(ColumnIndex::v8_isolate_id)); 1067 } mutable_internal_script_id()1068 TypedColumn<int32_t>* mutable_internal_script_id() { 1069 return static_cast<ColumnType::internal_script_id*>( 1070 GetColumn(ColumnIndex::internal_script_id)); 1071 } mutable_script_type()1072 TypedColumn<StringPool::Id>* mutable_script_type() { 1073 return static_cast<ColumnType::script_type*>( 1074 GetColumn(ColumnIndex::script_type)); 1075 } mutable_name()1076 TypedColumn<StringPool::Id>* mutable_name() { 1077 return static_cast<ColumnType::name*>( 1078 GetColumn(ColumnIndex::name)); 1079 } mutable_source()1080 TypedColumn<std::optional<StringPool::Id>>* mutable_source() { 1081 return static_cast<ColumnType::source*>( 1082 GetColumn(ColumnIndex::source)); 1083 } 1084 1085 private: 1086 1087 1088 ColumnStorage<ColumnType::v8_isolate_id::stored_type> v8_isolate_id_; 1089 ColumnStorage<ColumnType::internal_script_id::stored_type> internal_script_id_; 1090 ColumnStorage<ColumnType::script_type::stored_type> script_type_; 1091 ColumnStorage<ColumnType::name::stored_type> name_; 1092 ColumnStorage<ColumnType::source::stored_type> source_; 1093 1094 RefPtr<column::StorageLayer> id_storage_layer_; 1095 RefPtr<column::StorageLayer> type_storage_layer_; 1096 RefPtr<column::StorageLayer> v8_isolate_id_storage_layer_; 1097 RefPtr<column::StorageLayer> internal_script_id_storage_layer_; 1098 RefPtr<column::StorageLayer> script_type_storage_layer_; 1099 RefPtr<column::StorageLayer> name_storage_layer_; 1100 RefPtr<column::StorageLayer> source_storage_layer_; 1101 1102 1103 }; 1104 1105 1106 class V8WasmScriptTable : public macros_internal::MacroTable { 1107 public: 1108 static constexpr uint32_t kColumnCount = 6; 1109 1110 struct Id : public BaseId { 1111 Id() = default; IdId1112 explicit constexpr Id(uint32_t v) : BaseId(v) {} 1113 }; 1114 static_assert(std::is_trivially_destructible_v<Id>, 1115 "Inheritance used without trivial destruction"); 1116 1117 struct ColumnIndex { 1118 static constexpr uint32_t id = 0; 1119 static constexpr uint32_t type = 1; 1120 static constexpr uint32_t v8_isolate_id = 2; 1121 static constexpr uint32_t internal_script_id = 3; 1122 static constexpr uint32_t url = 4; 1123 static constexpr uint32_t source = 5; 1124 }; 1125 struct ColumnType { 1126 using id = IdColumn<V8WasmScriptTable::Id>; 1127 using type = TypedColumn<StringPool::Id>; 1128 using v8_isolate_id = TypedColumn<V8IsolateTable::Id>; 1129 using internal_script_id = TypedColumn<int32_t>; 1130 using url = TypedColumn<StringPool::Id>; 1131 using source = TypedColumn<std::optional<StringPool::Id>>; 1132 }; 1133 struct Row : public macros_internal::RootParentTable::Row { 1134 Row(V8IsolateTable::Id in_v8_isolate_id = {}, 1135 int32_t in_internal_script_id = {}, 1136 StringPool::Id in_url = {}, 1137 std::optional<StringPool::Id> in_source = {}, 1138 std::nullptr_t = nullptr) RowRow1139 : macros_internal::RootParentTable::Row(), 1140 v8_isolate_id(in_v8_isolate_id), 1141 internal_script_id(in_internal_script_id), 1142 url(in_url), 1143 source(in_source) { 1144 type_ = "__intrinsic_v8_wasm_script"; 1145 } 1146 V8IsolateTable::Id v8_isolate_id; 1147 int32_t internal_script_id; 1148 StringPool::Id url; 1149 std::optional<StringPool::Id> source; 1150 1151 bool operator==(const V8WasmScriptTable::Row& other) const { 1152 return type() == other.type() && ColumnType::v8_isolate_id::Equals(v8_isolate_id, other.v8_isolate_id) && 1153 ColumnType::internal_script_id::Equals(internal_script_id, other.internal_script_id) && 1154 ColumnType::url::Equals(url, other.url) && 1155 ColumnType::source::Equals(source, other.source); 1156 } 1157 }; 1158 struct ColumnFlag { 1159 static constexpr uint32_t v8_isolate_id = ColumnType::v8_isolate_id::default_flags(); 1160 static constexpr uint32_t internal_script_id = ColumnType::internal_script_id::default_flags(); 1161 static constexpr uint32_t url = ColumnType::url::default_flags(); 1162 static constexpr uint32_t source = ColumnType::source::default_flags(); 1163 }; 1164 1165 class RowNumber; 1166 class ConstRowReference; 1167 class RowReference; 1168 1169 class RowNumber : public macros_internal::AbstractRowNumber< 1170 V8WasmScriptTable, ConstRowReference, RowReference> { 1171 public: RowNumber(uint32_t row_number)1172 explicit RowNumber(uint32_t row_number) 1173 : AbstractRowNumber(row_number) {} 1174 }; 1175 static_assert(std::is_trivially_destructible_v<RowNumber>, 1176 "Inheritance used without trivial destruction"); 1177 1178 class ConstRowReference : public macros_internal::AbstractConstRowReference< 1179 V8WasmScriptTable, RowNumber> { 1180 public: ConstRowReference(const V8WasmScriptTable * table,uint32_t row_number)1181 ConstRowReference(const V8WasmScriptTable* table, uint32_t row_number) 1182 : AbstractConstRowReference(table, row_number) {} 1183 id()1184 ColumnType::id::type id() const { 1185 return table()->id()[row_number_]; 1186 } type()1187 ColumnType::type::type type() const { 1188 return table()->type()[row_number_]; 1189 } v8_isolate_id()1190 ColumnType::v8_isolate_id::type v8_isolate_id() const { 1191 return table()->v8_isolate_id()[row_number_]; 1192 } internal_script_id()1193 ColumnType::internal_script_id::type internal_script_id() const { 1194 return table()->internal_script_id()[row_number_]; 1195 } url()1196 ColumnType::url::type url() const { 1197 return table()->url()[row_number_]; 1198 } source()1199 ColumnType::source::type source() const { 1200 return table()->source()[row_number_]; 1201 } 1202 }; 1203 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 1204 "Inheritance used without trivial destruction"); 1205 class RowReference : public ConstRowReference { 1206 public: RowReference(const V8WasmScriptTable * table,uint32_t row_number)1207 RowReference(const V8WasmScriptTable* table, uint32_t row_number) 1208 : ConstRowReference(table, row_number) {} 1209 set_v8_isolate_id(ColumnType::v8_isolate_id::non_optional_type v)1210 void set_v8_isolate_id( 1211 ColumnType::v8_isolate_id::non_optional_type v) { 1212 return mutable_table()->mutable_v8_isolate_id()->Set(row_number_, v); 1213 } set_internal_script_id(ColumnType::internal_script_id::non_optional_type v)1214 void set_internal_script_id( 1215 ColumnType::internal_script_id::non_optional_type v) { 1216 return mutable_table()->mutable_internal_script_id()->Set(row_number_, v); 1217 } set_url(ColumnType::url::non_optional_type v)1218 void set_url( 1219 ColumnType::url::non_optional_type v) { 1220 return mutable_table()->mutable_url()->Set(row_number_, v); 1221 } set_source(ColumnType::source::non_optional_type v)1222 void set_source( 1223 ColumnType::source::non_optional_type v) { 1224 return mutable_table()->mutable_source()->Set(row_number_, v); 1225 } 1226 1227 private: mutable_table()1228 V8WasmScriptTable* mutable_table() const { 1229 return const_cast<V8WasmScriptTable*>(table()); 1230 } 1231 }; 1232 static_assert(std::is_trivially_destructible_v<RowReference>, 1233 "Inheritance used without trivial destruction"); 1234 1235 class ConstIterator; 1236 class ConstIterator : public macros_internal::AbstractConstIterator< 1237 ConstIterator, V8WasmScriptTable, RowNumber, ConstRowReference> { 1238 public: id()1239 ColumnType::id::type id() const { 1240 const auto& col = table()->id(); 1241 return col.GetAtIdx( 1242 iterator_.StorageIndexForColumn(col.index_in_table())); 1243 } type()1244 ColumnType::type::type type() const { 1245 const auto& col = table()->type(); 1246 return col.GetAtIdx( 1247 iterator_.StorageIndexForColumn(col.index_in_table())); 1248 } v8_isolate_id()1249 ColumnType::v8_isolate_id::type v8_isolate_id() const { 1250 const auto& col = table()->v8_isolate_id(); 1251 return col.GetAtIdx( 1252 iterator_.StorageIndexForColumn(col.index_in_table())); 1253 } internal_script_id()1254 ColumnType::internal_script_id::type internal_script_id() const { 1255 const auto& col = table()->internal_script_id(); 1256 return col.GetAtIdx( 1257 iterator_.StorageIndexForColumn(col.index_in_table())); 1258 } url()1259 ColumnType::url::type url() const { 1260 const auto& col = table()->url(); 1261 return col.GetAtIdx( 1262 iterator_.StorageIndexForColumn(col.index_in_table())); 1263 } source()1264 ColumnType::source::type source() const { 1265 const auto& col = table()->source(); 1266 return col.GetAtIdx( 1267 iterator_.StorageIndexForColumn(col.index_in_table())); 1268 } 1269 1270 protected: ConstIterator(const V8WasmScriptTable * table,Table::Iterator iterator)1271 explicit ConstIterator(const V8WasmScriptTable* table, 1272 Table::Iterator iterator) 1273 : AbstractConstIterator(table, std::move(iterator)) {} 1274 CurrentRowNumber()1275 uint32_t CurrentRowNumber() const { 1276 return iterator_.StorageIndexForLastOverlay(); 1277 } 1278 1279 private: 1280 friend class V8WasmScriptTable; 1281 friend class macros_internal::AbstractConstIterator< 1282 ConstIterator, V8WasmScriptTable, RowNumber, ConstRowReference>; 1283 }; 1284 class Iterator : public ConstIterator { 1285 public: row_reference()1286 RowReference row_reference() const { 1287 return {const_cast<V8WasmScriptTable*>(table()), CurrentRowNumber()}; 1288 } 1289 1290 private: 1291 friend class V8WasmScriptTable; 1292 Iterator(V8WasmScriptTable * table,Table::Iterator iterator)1293 explicit Iterator(V8WasmScriptTable* table, Table::Iterator iterator) 1294 : ConstIterator(table, std::move(iterator)) {} 1295 }; 1296 1297 struct IdAndRow { 1298 Id id; 1299 uint32_t row; 1300 RowReference row_reference; 1301 RowNumber row_number; 1302 }; 1303 GetColumns(V8WasmScriptTable * self,const macros_internal::MacroTable * parent)1304 static std::vector<ColumnLegacy> GetColumns( 1305 V8WasmScriptTable* self, 1306 const macros_internal::MacroTable* parent) { 1307 std::vector<ColumnLegacy> columns = 1308 CopyColumnsFromParentOrAddRootColumns(self, parent); 1309 uint32_t olay_idx = OverlayCount(parent); 1310 AddColumnToVector(columns, "v8_isolate_id", &self->v8_isolate_id_, ColumnFlag::v8_isolate_id, 1311 static_cast<uint32_t>(columns.size()), olay_idx); 1312 AddColumnToVector(columns, "internal_script_id", &self->internal_script_id_, ColumnFlag::internal_script_id, 1313 static_cast<uint32_t>(columns.size()), olay_idx); 1314 AddColumnToVector(columns, "url", &self->url_, ColumnFlag::url, 1315 static_cast<uint32_t>(columns.size()), olay_idx); 1316 AddColumnToVector(columns, "source", &self->source_, ColumnFlag::source, 1317 static_cast<uint32_t>(columns.size()), olay_idx); 1318 return columns; 1319 } 1320 V8WasmScriptTable(StringPool * pool)1321 PERFETTO_NO_INLINE explicit V8WasmScriptTable(StringPool* pool) 1322 : macros_internal::MacroTable( 1323 pool, 1324 GetColumns(this, nullptr), 1325 nullptr), 1326 v8_isolate_id_(ColumnStorage<ColumnType::v8_isolate_id::stored_type>::Create<false>()), 1327 internal_script_id_(ColumnStorage<ColumnType::internal_script_id::stored_type>::Create<false>()), 1328 url_(ColumnStorage<ColumnType::url::stored_type>::Create<false>()), 1329 source_(ColumnStorage<ColumnType::source::stored_type>::Create<false>()) 1330 , 1331 id_storage_layer_(new column::IdStorage()), 1332 type_storage_layer_( 1333 new column::StringStorage(string_pool(), &type_.vector())), 1334 v8_isolate_id_storage_layer_( 1335 new column::NumericStorage<ColumnType::v8_isolate_id::non_optional_stored_type>( 1336 &v8_isolate_id_.vector(), 1337 ColumnTypeHelper<ColumnType::v8_isolate_id::stored_type>::ToColumnType(), 1338 false)), 1339 internal_script_id_storage_layer_( 1340 new column::NumericStorage<ColumnType::internal_script_id::non_optional_stored_type>( 1341 &internal_script_id_.vector(), 1342 ColumnTypeHelper<ColumnType::internal_script_id::stored_type>::ToColumnType(), 1343 false)), 1344 url_storage_layer_( 1345 new column::StringStorage(string_pool(), &url_.vector())), 1346 source_storage_layer_( 1347 new column::StringStorage(string_pool(), &source_.vector())) 1348 { 1349 static_assert( 1350 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::v8_isolate_id::stored_type>( 1351 ColumnFlag::v8_isolate_id), 1352 "Column type and flag combination is not valid"); 1353 static_assert( 1354 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::internal_script_id::stored_type>( 1355 ColumnFlag::internal_script_id), 1356 "Column type and flag combination is not valid"); 1357 static_assert( 1358 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::url::stored_type>( 1359 ColumnFlag::url), 1360 "Column type and flag combination is not valid"); 1361 static_assert( 1362 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::source::stored_type>( 1363 ColumnFlag::source), 1364 "Column type and flag combination is not valid"); 1365 OnConstructionCompletedRegularConstructor( 1366 {id_storage_layer_,type_storage_layer_,v8_isolate_id_storage_layer_,internal_script_id_storage_layer_,url_storage_layer_,source_storage_layer_}, 1367 {{},{},{},{},{},{}}); 1368 } 1369 ~V8WasmScriptTable() override; 1370 Name()1371 static const char* Name() { return "__intrinsic_v8_wasm_script"; } 1372 ComputeStaticSchema()1373 static Table::Schema ComputeStaticSchema() { 1374 Table::Schema schema; 1375 schema.columns.emplace_back(Table::Schema::Column{ 1376 "id", SqlValue::Type::kLong, true, true, false, false}); 1377 schema.columns.emplace_back(Table::Schema::Column{ 1378 "type", SqlValue::Type::kString, false, false, false, false}); 1379 schema.columns.emplace_back(Table::Schema::Column{ 1380 "v8_isolate_id", ColumnType::v8_isolate_id::SqlValueType(), false, 1381 false, 1382 false, 1383 false}); 1384 schema.columns.emplace_back(Table::Schema::Column{ 1385 "internal_script_id", ColumnType::internal_script_id::SqlValueType(), false, 1386 false, 1387 false, 1388 false}); 1389 schema.columns.emplace_back(Table::Schema::Column{ 1390 "url", ColumnType::url::SqlValueType(), false, 1391 false, 1392 false, 1393 false}); 1394 schema.columns.emplace_back(Table::Schema::Column{ 1395 "source", ColumnType::source::SqlValueType(), false, 1396 false, 1397 false, 1398 false}); 1399 return schema; 1400 } 1401 IterateRows()1402 ConstIterator IterateRows() const { 1403 return ConstIterator(this, Table::IterateRows()); 1404 } 1405 IterateRows()1406 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 1407 FilterToIterator(const Query & q)1408 ConstIterator FilterToIterator(const Query& q) const { 1409 return ConstIterator(this, QueryToIterator(q)); 1410 } 1411 FilterToIterator(const Query & q)1412 Iterator FilterToIterator(const Query& q) { 1413 return Iterator(this, QueryToIterator(q)); 1414 } 1415 ShrinkToFit()1416 void ShrinkToFit() { 1417 type_.ShrinkToFit(); 1418 v8_isolate_id_.ShrinkToFit(); 1419 internal_script_id_.ShrinkToFit(); 1420 url_.ShrinkToFit(); 1421 source_.ShrinkToFit(); 1422 } 1423 1424 ConstRowReference operator[](uint32_t r) const { 1425 return ConstRowReference(this, r); 1426 } 1427 RowReference operator[](uint32_t r) { return RowReference(this, r); } 1428 ConstRowReference operator[](RowNumber r) const { 1429 return ConstRowReference(this, r.row_number()); 1430 } 1431 RowReference operator[](RowNumber r) { 1432 return RowReference(this, r.row_number()); 1433 } 1434 FindById(Id find_id)1435 std::optional<ConstRowReference> FindById(Id find_id) const { 1436 std::optional<uint32_t> row = id().IndexOf(find_id); 1437 return row ? std::make_optional(ConstRowReference(this, *row)) 1438 : std::nullopt; 1439 } 1440 FindById(Id find_id)1441 std::optional<RowReference> FindById(Id find_id) { 1442 std::optional<uint32_t> row = id().IndexOf(find_id); 1443 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 1444 } 1445 Insert(const Row & row)1446 IdAndRow Insert(const Row& row) { 1447 uint32_t row_number = row_count(); 1448 Id id = Id{row_number}; 1449 type_.Append(string_pool()->InternString(row.type())); 1450 mutable_v8_isolate_id()->Append(row.v8_isolate_id); 1451 mutable_internal_script_id()->Append(row.internal_script_id); 1452 mutable_url()->Append(row.url); 1453 mutable_source()->Append(row.source); 1454 UpdateSelfOverlayAfterInsert(); 1455 return IdAndRow{id, row_number, RowReference(this, row_number), 1456 RowNumber(row_number)}; 1457 } 1458 1459 1460 id()1461 const IdColumn<V8WasmScriptTable::Id>& id() const { 1462 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 1463 } type()1464 const TypedColumn<StringPool::Id>& type() const { 1465 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 1466 } v8_isolate_id()1467 const TypedColumn<V8IsolateTable::Id>& v8_isolate_id() const { 1468 return static_cast<const ColumnType::v8_isolate_id&>(columns()[ColumnIndex::v8_isolate_id]); 1469 } internal_script_id()1470 const TypedColumn<int32_t>& internal_script_id() const { 1471 return static_cast<const ColumnType::internal_script_id&>(columns()[ColumnIndex::internal_script_id]); 1472 } url()1473 const TypedColumn<StringPool::Id>& url() const { 1474 return static_cast<const ColumnType::url&>(columns()[ColumnIndex::url]); 1475 } source()1476 const TypedColumn<std::optional<StringPool::Id>>& source() const { 1477 return static_cast<const ColumnType::source&>(columns()[ColumnIndex::source]); 1478 } 1479 mutable_v8_isolate_id()1480 TypedColumn<V8IsolateTable::Id>* mutable_v8_isolate_id() { 1481 return static_cast<ColumnType::v8_isolate_id*>( 1482 GetColumn(ColumnIndex::v8_isolate_id)); 1483 } mutable_internal_script_id()1484 TypedColumn<int32_t>* mutable_internal_script_id() { 1485 return static_cast<ColumnType::internal_script_id*>( 1486 GetColumn(ColumnIndex::internal_script_id)); 1487 } mutable_url()1488 TypedColumn<StringPool::Id>* mutable_url() { 1489 return static_cast<ColumnType::url*>( 1490 GetColumn(ColumnIndex::url)); 1491 } mutable_source()1492 TypedColumn<std::optional<StringPool::Id>>* mutable_source() { 1493 return static_cast<ColumnType::source*>( 1494 GetColumn(ColumnIndex::source)); 1495 } 1496 1497 private: 1498 1499 1500 ColumnStorage<ColumnType::v8_isolate_id::stored_type> v8_isolate_id_; 1501 ColumnStorage<ColumnType::internal_script_id::stored_type> internal_script_id_; 1502 ColumnStorage<ColumnType::url::stored_type> url_; 1503 ColumnStorage<ColumnType::source::stored_type> source_; 1504 1505 RefPtr<column::StorageLayer> id_storage_layer_; 1506 RefPtr<column::StorageLayer> type_storage_layer_; 1507 RefPtr<column::StorageLayer> v8_isolate_id_storage_layer_; 1508 RefPtr<column::StorageLayer> internal_script_id_storage_layer_; 1509 RefPtr<column::StorageLayer> url_storage_layer_; 1510 RefPtr<column::StorageLayer> source_storage_layer_; 1511 1512 1513 }; 1514 1515 1516 class V8JsFunctionTable : public macros_internal::MacroTable { 1517 public: 1518 static constexpr uint32_t kColumnCount = 8; 1519 1520 struct Id : public BaseId { 1521 Id() = default; IdId1522 explicit constexpr Id(uint32_t v) : BaseId(v) {} 1523 }; 1524 static_assert(std::is_trivially_destructible_v<Id>, 1525 "Inheritance used without trivial destruction"); 1526 1527 struct ColumnIndex { 1528 static constexpr uint32_t id = 0; 1529 static constexpr uint32_t type = 1; 1530 static constexpr uint32_t name = 2; 1531 static constexpr uint32_t v8_js_script_id = 3; 1532 static constexpr uint32_t is_toplevel = 4; 1533 static constexpr uint32_t kind = 5; 1534 static constexpr uint32_t line = 6; 1535 static constexpr uint32_t col = 7; 1536 }; 1537 struct ColumnType { 1538 using id = IdColumn<V8JsFunctionTable::Id>; 1539 using type = TypedColumn<StringPool::Id>; 1540 using name = TypedColumn<StringPool::Id>; 1541 using v8_js_script_id = TypedColumn<V8JsScriptTable::Id>; 1542 using is_toplevel = TypedColumn<uint32_t>; 1543 using kind = TypedColumn<StringPool::Id>; 1544 using line = TypedColumn<std::optional<uint32_t>>; 1545 using col = TypedColumn<std::optional<uint32_t>>; 1546 }; 1547 struct Row : public macros_internal::RootParentTable::Row { 1548 Row(StringPool::Id in_name = {}, 1549 V8JsScriptTable::Id in_v8_js_script_id = {}, 1550 uint32_t in_is_toplevel = {}, 1551 StringPool::Id in_kind = {}, 1552 std::optional<uint32_t> in_line = {}, 1553 std::optional<uint32_t> in_col = {}, 1554 std::nullptr_t = nullptr) RowRow1555 : macros_internal::RootParentTable::Row(), 1556 name(in_name), 1557 v8_js_script_id(in_v8_js_script_id), 1558 is_toplevel(in_is_toplevel), 1559 kind(in_kind), 1560 line(in_line), 1561 col(in_col) { 1562 type_ = "__intrinsic_v8_js_function"; 1563 } 1564 StringPool::Id name; 1565 V8JsScriptTable::Id v8_js_script_id; 1566 uint32_t is_toplevel; 1567 StringPool::Id kind; 1568 std::optional<uint32_t> line; 1569 std::optional<uint32_t> col; 1570 1571 bool operator==(const V8JsFunctionTable::Row& other) const { 1572 return type() == other.type() && ColumnType::name::Equals(name, other.name) && 1573 ColumnType::v8_js_script_id::Equals(v8_js_script_id, other.v8_js_script_id) && 1574 ColumnType::is_toplevel::Equals(is_toplevel, other.is_toplevel) && 1575 ColumnType::kind::Equals(kind, other.kind) && 1576 ColumnType::line::Equals(line, other.line) && 1577 ColumnType::col::Equals(col, other.col); 1578 } 1579 }; 1580 struct ColumnFlag { 1581 static constexpr uint32_t name = ColumnType::name::default_flags(); 1582 static constexpr uint32_t v8_js_script_id = ColumnType::v8_js_script_id::default_flags(); 1583 static constexpr uint32_t is_toplevel = ColumnType::is_toplevel::default_flags(); 1584 static constexpr uint32_t kind = ColumnType::kind::default_flags(); 1585 static constexpr uint32_t line = ColumnType::line::default_flags(); 1586 static constexpr uint32_t col = ColumnType::col::default_flags(); 1587 }; 1588 1589 class RowNumber; 1590 class ConstRowReference; 1591 class RowReference; 1592 1593 class RowNumber : public macros_internal::AbstractRowNumber< 1594 V8JsFunctionTable, ConstRowReference, RowReference> { 1595 public: RowNumber(uint32_t row_number)1596 explicit RowNumber(uint32_t row_number) 1597 : AbstractRowNumber(row_number) {} 1598 }; 1599 static_assert(std::is_trivially_destructible_v<RowNumber>, 1600 "Inheritance used without trivial destruction"); 1601 1602 class ConstRowReference : public macros_internal::AbstractConstRowReference< 1603 V8JsFunctionTable, RowNumber> { 1604 public: ConstRowReference(const V8JsFunctionTable * table,uint32_t row_number)1605 ConstRowReference(const V8JsFunctionTable* table, uint32_t row_number) 1606 : AbstractConstRowReference(table, row_number) {} 1607 id()1608 ColumnType::id::type id() const { 1609 return table()->id()[row_number_]; 1610 } type()1611 ColumnType::type::type type() const { 1612 return table()->type()[row_number_]; 1613 } name()1614 ColumnType::name::type name() const { 1615 return table()->name()[row_number_]; 1616 } v8_js_script_id()1617 ColumnType::v8_js_script_id::type v8_js_script_id() const { 1618 return table()->v8_js_script_id()[row_number_]; 1619 } is_toplevel()1620 ColumnType::is_toplevel::type is_toplevel() const { 1621 return table()->is_toplevel()[row_number_]; 1622 } kind()1623 ColumnType::kind::type kind() const { 1624 return table()->kind()[row_number_]; 1625 } line()1626 ColumnType::line::type line() const { 1627 return table()->line()[row_number_]; 1628 } col()1629 ColumnType::col::type col() const { 1630 return table()->col()[row_number_]; 1631 } 1632 }; 1633 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 1634 "Inheritance used without trivial destruction"); 1635 class RowReference : public ConstRowReference { 1636 public: RowReference(const V8JsFunctionTable * table,uint32_t row_number)1637 RowReference(const V8JsFunctionTable* table, uint32_t row_number) 1638 : ConstRowReference(table, row_number) {} 1639 set_name(ColumnType::name::non_optional_type v)1640 void set_name( 1641 ColumnType::name::non_optional_type v) { 1642 return mutable_table()->mutable_name()->Set(row_number_, v); 1643 } set_v8_js_script_id(ColumnType::v8_js_script_id::non_optional_type v)1644 void set_v8_js_script_id( 1645 ColumnType::v8_js_script_id::non_optional_type v) { 1646 return mutable_table()->mutable_v8_js_script_id()->Set(row_number_, v); 1647 } set_is_toplevel(ColumnType::is_toplevel::non_optional_type v)1648 void set_is_toplevel( 1649 ColumnType::is_toplevel::non_optional_type v) { 1650 return mutable_table()->mutable_is_toplevel()->Set(row_number_, v); 1651 } set_kind(ColumnType::kind::non_optional_type v)1652 void set_kind( 1653 ColumnType::kind::non_optional_type v) { 1654 return mutable_table()->mutable_kind()->Set(row_number_, v); 1655 } set_line(ColumnType::line::non_optional_type v)1656 void set_line( 1657 ColumnType::line::non_optional_type v) { 1658 return mutable_table()->mutable_line()->Set(row_number_, v); 1659 } set_col(ColumnType::col::non_optional_type v)1660 void set_col( 1661 ColumnType::col::non_optional_type v) { 1662 return mutable_table()->mutable_col()->Set(row_number_, v); 1663 } 1664 1665 private: mutable_table()1666 V8JsFunctionTable* mutable_table() const { 1667 return const_cast<V8JsFunctionTable*>(table()); 1668 } 1669 }; 1670 static_assert(std::is_trivially_destructible_v<RowReference>, 1671 "Inheritance used without trivial destruction"); 1672 1673 class ConstIterator; 1674 class ConstIterator : public macros_internal::AbstractConstIterator< 1675 ConstIterator, V8JsFunctionTable, RowNumber, ConstRowReference> { 1676 public: id()1677 ColumnType::id::type id() const { 1678 const auto& col = table()->id(); 1679 return col.GetAtIdx( 1680 iterator_.StorageIndexForColumn(col.index_in_table())); 1681 } type()1682 ColumnType::type::type type() const { 1683 const auto& col = table()->type(); 1684 return col.GetAtIdx( 1685 iterator_.StorageIndexForColumn(col.index_in_table())); 1686 } name()1687 ColumnType::name::type name() const { 1688 const auto& col = table()->name(); 1689 return col.GetAtIdx( 1690 iterator_.StorageIndexForColumn(col.index_in_table())); 1691 } v8_js_script_id()1692 ColumnType::v8_js_script_id::type v8_js_script_id() const { 1693 const auto& col = table()->v8_js_script_id(); 1694 return col.GetAtIdx( 1695 iterator_.StorageIndexForColumn(col.index_in_table())); 1696 } is_toplevel()1697 ColumnType::is_toplevel::type is_toplevel() const { 1698 const auto& col = table()->is_toplevel(); 1699 return col.GetAtIdx( 1700 iterator_.StorageIndexForColumn(col.index_in_table())); 1701 } kind()1702 ColumnType::kind::type kind() const { 1703 const auto& col = table()->kind(); 1704 return col.GetAtIdx( 1705 iterator_.StorageIndexForColumn(col.index_in_table())); 1706 } line()1707 ColumnType::line::type line() const { 1708 const auto& col = table()->line(); 1709 return col.GetAtIdx( 1710 iterator_.StorageIndexForColumn(col.index_in_table())); 1711 } col()1712 ColumnType::col::type col() const { 1713 const auto& col = table()->col(); 1714 return col.GetAtIdx( 1715 iterator_.StorageIndexForColumn(col.index_in_table())); 1716 } 1717 1718 protected: ConstIterator(const V8JsFunctionTable * table,Table::Iterator iterator)1719 explicit ConstIterator(const V8JsFunctionTable* table, 1720 Table::Iterator iterator) 1721 : AbstractConstIterator(table, std::move(iterator)) {} 1722 CurrentRowNumber()1723 uint32_t CurrentRowNumber() const { 1724 return iterator_.StorageIndexForLastOverlay(); 1725 } 1726 1727 private: 1728 friend class V8JsFunctionTable; 1729 friend class macros_internal::AbstractConstIterator< 1730 ConstIterator, V8JsFunctionTable, RowNumber, ConstRowReference>; 1731 }; 1732 class Iterator : public ConstIterator { 1733 public: row_reference()1734 RowReference row_reference() const { 1735 return {const_cast<V8JsFunctionTable*>(table()), CurrentRowNumber()}; 1736 } 1737 1738 private: 1739 friend class V8JsFunctionTable; 1740 Iterator(V8JsFunctionTable * table,Table::Iterator iterator)1741 explicit Iterator(V8JsFunctionTable* table, Table::Iterator iterator) 1742 : ConstIterator(table, std::move(iterator)) {} 1743 }; 1744 1745 struct IdAndRow { 1746 Id id; 1747 uint32_t row; 1748 RowReference row_reference; 1749 RowNumber row_number; 1750 }; 1751 GetColumns(V8JsFunctionTable * self,const macros_internal::MacroTable * parent)1752 static std::vector<ColumnLegacy> GetColumns( 1753 V8JsFunctionTable* self, 1754 const macros_internal::MacroTable* parent) { 1755 std::vector<ColumnLegacy> columns = 1756 CopyColumnsFromParentOrAddRootColumns(self, parent); 1757 uint32_t olay_idx = OverlayCount(parent); 1758 AddColumnToVector(columns, "name", &self->name_, ColumnFlag::name, 1759 static_cast<uint32_t>(columns.size()), olay_idx); 1760 AddColumnToVector(columns, "v8_js_script_id", &self->v8_js_script_id_, ColumnFlag::v8_js_script_id, 1761 static_cast<uint32_t>(columns.size()), olay_idx); 1762 AddColumnToVector(columns, "is_toplevel", &self->is_toplevel_, ColumnFlag::is_toplevel, 1763 static_cast<uint32_t>(columns.size()), olay_idx); 1764 AddColumnToVector(columns, "kind", &self->kind_, ColumnFlag::kind, 1765 static_cast<uint32_t>(columns.size()), olay_idx); 1766 AddColumnToVector(columns, "line", &self->line_, ColumnFlag::line, 1767 static_cast<uint32_t>(columns.size()), olay_idx); 1768 AddColumnToVector(columns, "col", &self->col_, ColumnFlag::col, 1769 static_cast<uint32_t>(columns.size()), olay_idx); 1770 return columns; 1771 } 1772 V8JsFunctionTable(StringPool * pool)1773 PERFETTO_NO_INLINE explicit V8JsFunctionTable(StringPool* pool) 1774 : macros_internal::MacroTable( 1775 pool, 1776 GetColumns(this, nullptr), 1777 nullptr), 1778 name_(ColumnStorage<ColumnType::name::stored_type>::Create<false>()), 1779 v8_js_script_id_(ColumnStorage<ColumnType::v8_js_script_id::stored_type>::Create<false>()), 1780 is_toplevel_(ColumnStorage<ColumnType::is_toplevel::stored_type>::Create<false>()), 1781 kind_(ColumnStorage<ColumnType::kind::stored_type>::Create<false>()), 1782 line_(ColumnStorage<ColumnType::line::stored_type>::Create<false>()), 1783 col_(ColumnStorage<ColumnType::col::stored_type>::Create<false>()) 1784 , 1785 id_storage_layer_(new column::IdStorage()), 1786 type_storage_layer_( 1787 new column::StringStorage(string_pool(), &type_.vector())), 1788 name_storage_layer_( 1789 new column::StringStorage(string_pool(), &name_.vector())), 1790 v8_js_script_id_storage_layer_( 1791 new column::NumericStorage<ColumnType::v8_js_script_id::non_optional_stored_type>( 1792 &v8_js_script_id_.vector(), 1793 ColumnTypeHelper<ColumnType::v8_js_script_id::stored_type>::ToColumnType(), 1794 false)), 1795 is_toplevel_storage_layer_( 1796 new column::NumericStorage<ColumnType::is_toplevel::non_optional_stored_type>( 1797 &is_toplevel_.vector(), 1798 ColumnTypeHelper<ColumnType::is_toplevel::stored_type>::ToColumnType(), 1799 false)), 1800 kind_storage_layer_( 1801 new column::StringStorage(string_pool(), &kind_.vector())), 1802 line_storage_layer_( 1803 new column::NumericStorage<ColumnType::line::non_optional_stored_type>( 1804 &line_.non_null_vector(), 1805 ColumnTypeHelper<ColumnType::line::stored_type>::ToColumnType(), 1806 false)), 1807 col_storage_layer_( 1808 new column::NumericStorage<ColumnType::col::non_optional_stored_type>( 1809 &col_.non_null_vector(), 1810 ColumnTypeHelper<ColumnType::col::stored_type>::ToColumnType(), 1811 false)) 1812 , 1813 line_null_layer_(new column::NullOverlay(line_.bv())), 1814 col_null_layer_(new column::NullOverlay(col_.bv())) { 1815 static_assert( 1816 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::name::stored_type>( 1817 ColumnFlag::name), 1818 "Column type and flag combination is not valid"); 1819 static_assert( 1820 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::v8_js_script_id::stored_type>( 1821 ColumnFlag::v8_js_script_id), 1822 "Column type and flag combination is not valid"); 1823 static_assert( 1824 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::is_toplevel::stored_type>( 1825 ColumnFlag::is_toplevel), 1826 "Column type and flag combination is not valid"); 1827 static_assert( 1828 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::kind::stored_type>( 1829 ColumnFlag::kind), 1830 "Column type and flag combination is not valid"); 1831 static_assert( 1832 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::line::stored_type>( 1833 ColumnFlag::line), 1834 "Column type and flag combination is not valid"); 1835 static_assert( 1836 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::col::stored_type>( 1837 ColumnFlag::col), 1838 "Column type and flag combination is not valid"); 1839 OnConstructionCompletedRegularConstructor( 1840 {id_storage_layer_,type_storage_layer_,name_storage_layer_,v8_js_script_id_storage_layer_,is_toplevel_storage_layer_,kind_storage_layer_,line_storage_layer_,col_storage_layer_}, 1841 {{},{},{},{},{},{},line_null_layer_,col_null_layer_}); 1842 } 1843 ~V8JsFunctionTable() override; 1844 Name()1845 static const char* Name() { return "__intrinsic_v8_js_function"; } 1846 ComputeStaticSchema()1847 static Table::Schema ComputeStaticSchema() { 1848 Table::Schema schema; 1849 schema.columns.emplace_back(Table::Schema::Column{ 1850 "id", SqlValue::Type::kLong, true, true, false, false}); 1851 schema.columns.emplace_back(Table::Schema::Column{ 1852 "type", SqlValue::Type::kString, false, false, false, false}); 1853 schema.columns.emplace_back(Table::Schema::Column{ 1854 "name", ColumnType::name::SqlValueType(), false, 1855 false, 1856 false, 1857 false}); 1858 schema.columns.emplace_back(Table::Schema::Column{ 1859 "v8_js_script_id", ColumnType::v8_js_script_id::SqlValueType(), false, 1860 false, 1861 false, 1862 false}); 1863 schema.columns.emplace_back(Table::Schema::Column{ 1864 "is_toplevel", ColumnType::is_toplevel::SqlValueType(), false, 1865 false, 1866 false, 1867 false}); 1868 schema.columns.emplace_back(Table::Schema::Column{ 1869 "kind", ColumnType::kind::SqlValueType(), false, 1870 false, 1871 false, 1872 false}); 1873 schema.columns.emplace_back(Table::Schema::Column{ 1874 "line", ColumnType::line::SqlValueType(), false, 1875 false, 1876 false, 1877 false}); 1878 schema.columns.emplace_back(Table::Schema::Column{ 1879 "col", ColumnType::col::SqlValueType(), false, 1880 false, 1881 false, 1882 false}); 1883 return schema; 1884 } 1885 IterateRows()1886 ConstIterator IterateRows() const { 1887 return ConstIterator(this, Table::IterateRows()); 1888 } 1889 IterateRows()1890 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 1891 FilterToIterator(const Query & q)1892 ConstIterator FilterToIterator(const Query& q) const { 1893 return ConstIterator(this, QueryToIterator(q)); 1894 } 1895 FilterToIterator(const Query & q)1896 Iterator FilterToIterator(const Query& q) { 1897 return Iterator(this, QueryToIterator(q)); 1898 } 1899 ShrinkToFit()1900 void ShrinkToFit() { 1901 type_.ShrinkToFit(); 1902 name_.ShrinkToFit(); 1903 v8_js_script_id_.ShrinkToFit(); 1904 is_toplevel_.ShrinkToFit(); 1905 kind_.ShrinkToFit(); 1906 line_.ShrinkToFit(); 1907 col_.ShrinkToFit(); 1908 } 1909 1910 ConstRowReference operator[](uint32_t r) const { 1911 return ConstRowReference(this, r); 1912 } 1913 RowReference operator[](uint32_t r) { return RowReference(this, r); } 1914 ConstRowReference operator[](RowNumber r) const { 1915 return ConstRowReference(this, r.row_number()); 1916 } 1917 RowReference operator[](RowNumber r) { 1918 return RowReference(this, r.row_number()); 1919 } 1920 FindById(Id find_id)1921 std::optional<ConstRowReference> FindById(Id find_id) const { 1922 std::optional<uint32_t> row = id().IndexOf(find_id); 1923 return row ? std::make_optional(ConstRowReference(this, *row)) 1924 : std::nullopt; 1925 } 1926 FindById(Id find_id)1927 std::optional<RowReference> FindById(Id find_id) { 1928 std::optional<uint32_t> row = id().IndexOf(find_id); 1929 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 1930 } 1931 Insert(const Row & row)1932 IdAndRow Insert(const Row& row) { 1933 uint32_t row_number = row_count(); 1934 Id id = Id{row_number}; 1935 type_.Append(string_pool()->InternString(row.type())); 1936 mutable_name()->Append(row.name); 1937 mutable_v8_js_script_id()->Append(row.v8_js_script_id); 1938 mutable_is_toplevel()->Append(row.is_toplevel); 1939 mutable_kind()->Append(row.kind); 1940 mutable_line()->Append(row.line); 1941 mutable_col()->Append(row.col); 1942 UpdateSelfOverlayAfterInsert(); 1943 return IdAndRow{id, row_number, RowReference(this, row_number), 1944 RowNumber(row_number)}; 1945 } 1946 1947 1948 id()1949 const IdColumn<V8JsFunctionTable::Id>& id() const { 1950 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 1951 } type()1952 const TypedColumn<StringPool::Id>& type() const { 1953 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 1954 } name()1955 const TypedColumn<StringPool::Id>& name() const { 1956 return static_cast<const ColumnType::name&>(columns()[ColumnIndex::name]); 1957 } v8_js_script_id()1958 const TypedColumn<V8JsScriptTable::Id>& v8_js_script_id() const { 1959 return static_cast<const ColumnType::v8_js_script_id&>(columns()[ColumnIndex::v8_js_script_id]); 1960 } is_toplevel()1961 const TypedColumn<uint32_t>& is_toplevel() const { 1962 return static_cast<const ColumnType::is_toplevel&>(columns()[ColumnIndex::is_toplevel]); 1963 } kind()1964 const TypedColumn<StringPool::Id>& kind() const { 1965 return static_cast<const ColumnType::kind&>(columns()[ColumnIndex::kind]); 1966 } line()1967 const TypedColumn<std::optional<uint32_t>>& line() const { 1968 return static_cast<const ColumnType::line&>(columns()[ColumnIndex::line]); 1969 } col()1970 const TypedColumn<std::optional<uint32_t>>& col() const { 1971 return static_cast<const ColumnType::col&>(columns()[ColumnIndex::col]); 1972 } 1973 mutable_name()1974 TypedColumn<StringPool::Id>* mutable_name() { 1975 return static_cast<ColumnType::name*>( 1976 GetColumn(ColumnIndex::name)); 1977 } mutable_v8_js_script_id()1978 TypedColumn<V8JsScriptTable::Id>* mutable_v8_js_script_id() { 1979 return static_cast<ColumnType::v8_js_script_id*>( 1980 GetColumn(ColumnIndex::v8_js_script_id)); 1981 } mutable_is_toplevel()1982 TypedColumn<uint32_t>* mutable_is_toplevel() { 1983 return static_cast<ColumnType::is_toplevel*>( 1984 GetColumn(ColumnIndex::is_toplevel)); 1985 } mutable_kind()1986 TypedColumn<StringPool::Id>* mutable_kind() { 1987 return static_cast<ColumnType::kind*>( 1988 GetColumn(ColumnIndex::kind)); 1989 } mutable_line()1990 TypedColumn<std::optional<uint32_t>>* mutable_line() { 1991 return static_cast<ColumnType::line*>( 1992 GetColumn(ColumnIndex::line)); 1993 } mutable_col()1994 TypedColumn<std::optional<uint32_t>>* mutable_col() { 1995 return static_cast<ColumnType::col*>( 1996 GetColumn(ColumnIndex::col)); 1997 } 1998 1999 private: 2000 2001 2002 ColumnStorage<ColumnType::name::stored_type> name_; 2003 ColumnStorage<ColumnType::v8_js_script_id::stored_type> v8_js_script_id_; 2004 ColumnStorage<ColumnType::is_toplevel::stored_type> is_toplevel_; 2005 ColumnStorage<ColumnType::kind::stored_type> kind_; 2006 ColumnStorage<ColumnType::line::stored_type> line_; 2007 ColumnStorage<ColumnType::col::stored_type> col_; 2008 2009 RefPtr<column::StorageLayer> id_storage_layer_; 2010 RefPtr<column::StorageLayer> type_storage_layer_; 2011 RefPtr<column::StorageLayer> name_storage_layer_; 2012 RefPtr<column::StorageLayer> v8_js_script_id_storage_layer_; 2013 RefPtr<column::StorageLayer> is_toplevel_storage_layer_; 2014 RefPtr<column::StorageLayer> kind_storage_layer_; 2015 RefPtr<column::StorageLayer> line_storage_layer_; 2016 RefPtr<column::StorageLayer> col_storage_layer_; 2017 2018 RefPtr<column::OverlayLayer> line_null_layer_; 2019 RefPtr<column::OverlayLayer> col_null_layer_; 2020 }; 2021 2022 2023 class V8JsCodeTable : public macros_internal::MacroTable { 2024 public: 2025 static constexpr uint32_t kColumnCount = 6; 2026 2027 struct Id : public BaseId { 2028 Id() = default; IdId2029 explicit constexpr Id(uint32_t v) : BaseId(v) {} 2030 }; 2031 static_assert(std::is_trivially_destructible_v<Id>, 2032 "Inheritance used without trivial destruction"); 2033 2034 struct ColumnIndex { 2035 static constexpr uint32_t id = 0; 2036 static constexpr uint32_t type = 1; 2037 static constexpr uint32_t jit_code_id = 2; 2038 static constexpr uint32_t v8_js_function_id = 3; 2039 static constexpr uint32_t tier = 4; 2040 static constexpr uint32_t bytecode_base64 = 5; 2041 }; 2042 struct ColumnType { 2043 using id = IdColumn<V8JsCodeTable::Id>; 2044 using type = TypedColumn<StringPool::Id>; 2045 using jit_code_id = TypedColumn<std::optional<JitCodeTable::Id>>; 2046 using v8_js_function_id = TypedColumn<V8JsFunctionTable::Id>; 2047 using tier = TypedColumn<StringPool::Id>; 2048 using bytecode_base64 = TypedColumn<std::optional<StringPool::Id>>; 2049 }; 2050 struct Row : public macros_internal::RootParentTable::Row { 2051 Row(std::optional<JitCodeTable::Id> in_jit_code_id = {}, 2052 V8JsFunctionTable::Id in_v8_js_function_id = {}, 2053 StringPool::Id in_tier = {}, 2054 std::optional<StringPool::Id> in_bytecode_base64 = {}, 2055 std::nullptr_t = nullptr) RowRow2056 : macros_internal::RootParentTable::Row(), 2057 jit_code_id(in_jit_code_id), 2058 v8_js_function_id(in_v8_js_function_id), 2059 tier(in_tier), 2060 bytecode_base64(in_bytecode_base64) { 2061 type_ = "__intrinsic_v8_js_code"; 2062 } 2063 std::optional<JitCodeTable::Id> jit_code_id; 2064 V8JsFunctionTable::Id v8_js_function_id; 2065 StringPool::Id tier; 2066 std::optional<StringPool::Id> bytecode_base64; 2067 2068 bool operator==(const V8JsCodeTable::Row& other) const { 2069 return type() == other.type() && ColumnType::jit_code_id::Equals(jit_code_id, other.jit_code_id) && 2070 ColumnType::v8_js_function_id::Equals(v8_js_function_id, other.v8_js_function_id) && 2071 ColumnType::tier::Equals(tier, other.tier) && 2072 ColumnType::bytecode_base64::Equals(bytecode_base64, other.bytecode_base64); 2073 } 2074 }; 2075 struct ColumnFlag { 2076 static constexpr uint32_t jit_code_id = ColumnType::jit_code_id::default_flags(); 2077 static constexpr uint32_t v8_js_function_id = ColumnType::v8_js_function_id::default_flags(); 2078 static constexpr uint32_t tier = ColumnType::tier::default_flags(); 2079 static constexpr uint32_t bytecode_base64 = ColumnType::bytecode_base64::default_flags(); 2080 }; 2081 2082 class RowNumber; 2083 class ConstRowReference; 2084 class RowReference; 2085 2086 class RowNumber : public macros_internal::AbstractRowNumber< 2087 V8JsCodeTable, ConstRowReference, RowReference> { 2088 public: RowNumber(uint32_t row_number)2089 explicit RowNumber(uint32_t row_number) 2090 : AbstractRowNumber(row_number) {} 2091 }; 2092 static_assert(std::is_trivially_destructible_v<RowNumber>, 2093 "Inheritance used without trivial destruction"); 2094 2095 class ConstRowReference : public macros_internal::AbstractConstRowReference< 2096 V8JsCodeTable, RowNumber> { 2097 public: ConstRowReference(const V8JsCodeTable * table,uint32_t row_number)2098 ConstRowReference(const V8JsCodeTable* table, uint32_t row_number) 2099 : AbstractConstRowReference(table, row_number) {} 2100 id()2101 ColumnType::id::type id() const { 2102 return table()->id()[row_number_]; 2103 } type()2104 ColumnType::type::type type() const { 2105 return table()->type()[row_number_]; 2106 } jit_code_id()2107 ColumnType::jit_code_id::type jit_code_id() const { 2108 return table()->jit_code_id()[row_number_]; 2109 } v8_js_function_id()2110 ColumnType::v8_js_function_id::type v8_js_function_id() const { 2111 return table()->v8_js_function_id()[row_number_]; 2112 } tier()2113 ColumnType::tier::type tier() const { 2114 return table()->tier()[row_number_]; 2115 } bytecode_base64()2116 ColumnType::bytecode_base64::type bytecode_base64() const { 2117 return table()->bytecode_base64()[row_number_]; 2118 } 2119 }; 2120 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 2121 "Inheritance used without trivial destruction"); 2122 class RowReference : public ConstRowReference { 2123 public: RowReference(const V8JsCodeTable * table,uint32_t row_number)2124 RowReference(const V8JsCodeTable* table, uint32_t row_number) 2125 : ConstRowReference(table, row_number) {} 2126 set_jit_code_id(ColumnType::jit_code_id::non_optional_type v)2127 void set_jit_code_id( 2128 ColumnType::jit_code_id::non_optional_type v) { 2129 return mutable_table()->mutable_jit_code_id()->Set(row_number_, v); 2130 } set_v8_js_function_id(ColumnType::v8_js_function_id::non_optional_type v)2131 void set_v8_js_function_id( 2132 ColumnType::v8_js_function_id::non_optional_type v) { 2133 return mutable_table()->mutable_v8_js_function_id()->Set(row_number_, v); 2134 } set_tier(ColumnType::tier::non_optional_type v)2135 void set_tier( 2136 ColumnType::tier::non_optional_type v) { 2137 return mutable_table()->mutable_tier()->Set(row_number_, v); 2138 } set_bytecode_base64(ColumnType::bytecode_base64::non_optional_type v)2139 void set_bytecode_base64( 2140 ColumnType::bytecode_base64::non_optional_type v) { 2141 return mutable_table()->mutable_bytecode_base64()->Set(row_number_, v); 2142 } 2143 2144 private: mutable_table()2145 V8JsCodeTable* mutable_table() const { 2146 return const_cast<V8JsCodeTable*>(table()); 2147 } 2148 }; 2149 static_assert(std::is_trivially_destructible_v<RowReference>, 2150 "Inheritance used without trivial destruction"); 2151 2152 class ConstIterator; 2153 class ConstIterator : public macros_internal::AbstractConstIterator< 2154 ConstIterator, V8JsCodeTable, RowNumber, ConstRowReference> { 2155 public: id()2156 ColumnType::id::type id() const { 2157 const auto& col = table()->id(); 2158 return col.GetAtIdx( 2159 iterator_.StorageIndexForColumn(col.index_in_table())); 2160 } type()2161 ColumnType::type::type type() const { 2162 const auto& col = table()->type(); 2163 return col.GetAtIdx( 2164 iterator_.StorageIndexForColumn(col.index_in_table())); 2165 } jit_code_id()2166 ColumnType::jit_code_id::type jit_code_id() const { 2167 const auto& col = table()->jit_code_id(); 2168 return col.GetAtIdx( 2169 iterator_.StorageIndexForColumn(col.index_in_table())); 2170 } v8_js_function_id()2171 ColumnType::v8_js_function_id::type v8_js_function_id() const { 2172 const auto& col = table()->v8_js_function_id(); 2173 return col.GetAtIdx( 2174 iterator_.StorageIndexForColumn(col.index_in_table())); 2175 } tier()2176 ColumnType::tier::type tier() const { 2177 const auto& col = table()->tier(); 2178 return col.GetAtIdx( 2179 iterator_.StorageIndexForColumn(col.index_in_table())); 2180 } bytecode_base64()2181 ColumnType::bytecode_base64::type bytecode_base64() const { 2182 const auto& col = table()->bytecode_base64(); 2183 return col.GetAtIdx( 2184 iterator_.StorageIndexForColumn(col.index_in_table())); 2185 } 2186 2187 protected: ConstIterator(const V8JsCodeTable * table,Table::Iterator iterator)2188 explicit ConstIterator(const V8JsCodeTable* table, 2189 Table::Iterator iterator) 2190 : AbstractConstIterator(table, std::move(iterator)) {} 2191 CurrentRowNumber()2192 uint32_t CurrentRowNumber() const { 2193 return iterator_.StorageIndexForLastOverlay(); 2194 } 2195 2196 private: 2197 friend class V8JsCodeTable; 2198 friend class macros_internal::AbstractConstIterator< 2199 ConstIterator, V8JsCodeTable, RowNumber, ConstRowReference>; 2200 }; 2201 class Iterator : public ConstIterator { 2202 public: row_reference()2203 RowReference row_reference() const { 2204 return {const_cast<V8JsCodeTable*>(table()), CurrentRowNumber()}; 2205 } 2206 2207 private: 2208 friend class V8JsCodeTable; 2209 Iterator(V8JsCodeTable * table,Table::Iterator iterator)2210 explicit Iterator(V8JsCodeTable* table, Table::Iterator iterator) 2211 : ConstIterator(table, std::move(iterator)) {} 2212 }; 2213 2214 struct IdAndRow { 2215 Id id; 2216 uint32_t row; 2217 RowReference row_reference; 2218 RowNumber row_number; 2219 }; 2220 GetColumns(V8JsCodeTable * self,const macros_internal::MacroTable * parent)2221 static std::vector<ColumnLegacy> GetColumns( 2222 V8JsCodeTable* self, 2223 const macros_internal::MacroTable* parent) { 2224 std::vector<ColumnLegacy> columns = 2225 CopyColumnsFromParentOrAddRootColumns(self, parent); 2226 uint32_t olay_idx = OverlayCount(parent); 2227 AddColumnToVector(columns, "jit_code_id", &self->jit_code_id_, ColumnFlag::jit_code_id, 2228 static_cast<uint32_t>(columns.size()), olay_idx); 2229 AddColumnToVector(columns, "v8_js_function_id", &self->v8_js_function_id_, ColumnFlag::v8_js_function_id, 2230 static_cast<uint32_t>(columns.size()), olay_idx); 2231 AddColumnToVector(columns, "tier", &self->tier_, ColumnFlag::tier, 2232 static_cast<uint32_t>(columns.size()), olay_idx); 2233 AddColumnToVector(columns, "bytecode_base64", &self->bytecode_base64_, ColumnFlag::bytecode_base64, 2234 static_cast<uint32_t>(columns.size()), olay_idx); 2235 return columns; 2236 } 2237 V8JsCodeTable(StringPool * pool)2238 PERFETTO_NO_INLINE explicit V8JsCodeTable(StringPool* pool) 2239 : macros_internal::MacroTable( 2240 pool, 2241 GetColumns(this, nullptr), 2242 nullptr), 2243 jit_code_id_(ColumnStorage<ColumnType::jit_code_id::stored_type>::Create<false>()), 2244 v8_js_function_id_(ColumnStorage<ColumnType::v8_js_function_id::stored_type>::Create<false>()), 2245 tier_(ColumnStorage<ColumnType::tier::stored_type>::Create<false>()), 2246 bytecode_base64_(ColumnStorage<ColumnType::bytecode_base64::stored_type>::Create<false>()) 2247 , 2248 id_storage_layer_(new column::IdStorage()), 2249 type_storage_layer_( 2250 new column::StringStorage(string_pool(), &type_.vector())), 2251 jit_code_id_storage_layer_( 2252 new column::NumericStorage<ColumnType::jit_code_id::non_optional_stored_type>( 2253 &jit_code_id_.non_null_vector(), 2254 ColumnTypeHelper<ColumnType::jit_code_id::stored_type>::ToColumnType(), 2255 false)), 2256 v8_js_function_id_storage_layer_( 2257 new column::NumericStorage<ColumnType::v8_js_function_id::non_optional_stored_type>( 2258 &v8_js_function_id_.vector(), 2259 ColumnTypeHelper<ColumnType::v8_js_function_id::stored_type>::ToColumnType(), 2260 false)), 2261 tier_storage_layer_( 2262 new column::StringStorage(string_pool(), &tier_.vector())), 2263 bytecode_base64_storage_layer_( 2264 new column::StringStorage(string_pool(), &bytecode_base64_.vector())) 2265 , 2266 jit_code_id_null_layer_(new column::NullOverlay(jit_code_id_.bv())) { 2267 static_assert( 2268 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::jit_code_id::stored_type>( 2269 ColumnFlag::jit_code_id), 2270 "Column type and flag combination is not valid"); 2271 static_assert( 2272 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::v8_js_function_id::stored_type>( 2273 ColumnFlag::v8_js_function_id), 2274 "Column type and flag combination is not valid"); 2275 static_assert( 2276 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::tier::stored_type>( 2277 ColumnFlag::tier), 2278 "Column type and flag combination is not valid"); 2279 static_assert( 2280 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::bytecode_base64::stored_type>( 2281 ColumnFlag::bytecode_base64), 2282 "Column type and flag combination is not valid"); 2283 OnConstructionCompletedRegularConstructor( 2284 {id_storage_layer_,type_storage_layer_,jit_code_id_storage_layer_,v8_js_function_id_storage_layer_,tier_storage_layer_,bytecode_base64_storage_layer_}, 2285 {{},{},jit_code_id_null_layer_,{},{},{}}); 2286 } 2287 ~V8JsCodeTable() override; 2288 Name()2289 static const char* Name() { return "__intrinsic_v8_js_code"; } 2290 ComputeStaticSchema()2291 static Table::Schema ComputeStaticSchema() { 2292 Table::Schema schema; 2293 schema.columns.emplace_back(Table::Schema::Column{ 2294 "id", SqlValue::Type::kLong, true, true, false, false}); 2295 schema.columns.emplace_back(Table::Schema::Column{ 2296 "type", SqlValue::Type::kString, false, false, false, false}); 2297 schema.columns.emplace_back(Table::Schema::Column{ 2298 "jit_code_id", ColumnType::jit_code_id::SqlValueType(), false, 2299 false, 2300 false, 2301 false}); 2302 schema.columns.emplace_back(Table::Schema::Column{ 2303 "v8_js_function_id", ColumnType::v8_js_function_id::SqlValueType(), false, 2304 false, 2305 false, 2306 false}); 2307 schema.columns.emplace_back(Table::Schema::Column{ 2308 "tier", ColumnType::tier::SqlValueType(), false, 2309 false, 2310 false, 2311 false}); 2312 schema.columns.emplace_back(Table::Schema::Column{ 2313 "bytecode_base64", ColumnType::bytecode_base64::SqlValueType(), false, 2314 false, 2315 false, 2316 false}); 2317 return schema; 2318 } 2319 IterateRows()2320 ConstIterator IterateRows() const { 2321 return ConstIterator(this, Table::IterateRows()); 2322 } 2323 IterateRows()2324 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 2325 FilterToIterator(const Query & q)2326 ConstIterator FilterToIterator(const Query& q) const { 2327 return ConstIterator(this, QueryToIterator(q)); 2328 } 2329 FilterToIterator(const Query & q)2330 Iterator FilterToIterator(const Query& q) { 2331 return Iterator(this, QueryToIterator(q)); 2332 } 2333 ShrinkToFit()2334 void ShrinkToFit() { 2335 type_.ShrinkToFit(); 2336 jit_code_id_.ShrinkToFit(); 2337 v8_js_function_id_.ShrinkToFit(); 2338 tier_.ShrinkToFit(); 2339 bytecode_base64_.ShrinkToFit(); 2340 } 2341 2342 ConstRowReference operator[](uint32_t r) const { 2343 return ConstRowReference(this, r); 2344 } 2345 RowReference operator[](uint32_t r) { return RowReference(this, r); } 2346 ConstRowReference operator[](RowNumber r) const { 2347 return ConstRowReference(this, r.row_number()); 2348 } 2349 RowReference operator[](RowNumber r) { 2350 return RowReference(this, r.row_number()); 2351 } 2352 FindById(Id find_id)2353 std::optional<ConstRowReference> FindById(Id find_id) const { 2354 std::optional<uint32_t> row = id().IndexOf(find_id); 2355 return row ? std::make_optional(ConstRowReference(this, *row)) 2356 : std::nullopt; 2357 } 2358 FindById(Id find_id)2359 std::optional<RowReference> FindById(Id find_id) { 2360 std::optional<uint32_t> row = id().IndexOf(find_id); 2361 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 2362 } 2363 Insert(const Row & row)2364 IdAndRow Insert(const Row& row) { 2365 uint32_t row_number = row_count(); 2366 Id id = Id{row_number}; 2367 type_.Append(string_pool()->InternString(row.type())); 2368 mutable_jit_code_id()->Append(row.jit_code_id); 2369 mutable_v8_js_function_id()->Append(row.v8_js_function_id); 2370 mutable_tier()->Append(row.tier); 2371 mutable_bytecode_base64()->Append(row.bytecode_base64); 2372 UpdateSelfOverlayAfterInsert(); 2373 return IdAndRow{id, row_number, RowReference(this, row_number), 2374 RowNumber(row_number)}; 2375 } 2376 2377 2378 id()2379 const IdColumn<V8JsCodeTable::Id>& id() const { 2380 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 2381 } type()2382 const TypedColumn<StringPool::Id>& type() const { 2383 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 2384 } jit_code_id()2385 const TypedColumn<std::optional<JitCodeTable::Id>>& jit_code_id() const { 2386 return static_cast<const ColumnType::jit_code_id&>(columns()[ColumnIndex::jit_code_id]); 2387 } v8_js_function_id()2388 const TypedColumn<V8JsFunctionTable::Id>& v8_js_function_id() const { 2389 return static_cast<const ColumnType::v8_js_function_id&>(columns()[ColumnIndex::v8_js_function_id]); 2390 } tier()2391 const TypedColumn<StringPool::Id>& tier() const { 2392 return static_cast<const ColumnType::tier&>(columns()[ColumnIndex::tier]); 2393 } bytecode_base64()2394 const TypedColumn<std::optional<StringPool::Id>>& bytecode_base64() const { 2395 return static_cast<const ColumnType::bytecode_base64&>(columns()[ColumnIndex::bytecode_base64]); 2396 } 2397 mutable_jit_code_id()2398 TypedColumn<std::optional<JitCodeTable::Id>>* mutable_jit_code_id() { 2399 return static_cast<ColumnType::jit_code_id*>( 2400 GetColumn(ColumnIndex::jit_code_id)); 2401 } mutable_v8_js_function_id()2402 TypedColumn<V8JsFunctionTable::Id>* mutable_v8_js_function_id() { 2403 return static_cast<ColumnType::v8_js_function_id*>( 2404 GetColumn(ColumnIndex::v8_js_function_id)); 2405 } mutable_tier()2406 TypedColumn<StringPool::Id>* mutable_tier() { 2407 return static_cast<ColumnType::tier*>( 2408 GetColumn(ColumnIndex::tier)); 2409 } mutable_bytecode_base64()2410 TypedColumn<std::optional<StringPool::Id>>* mutable_bytecode_base64() { 2411 return static_cast<ColumnType::bytecode_base64*>( 2412 GetColumn(ColumnIndex::bytecode_base64)); 2413 } 2414 2415 private: 2416 2417 2418 ColumnStorage<ColumnType::jit_code_id::stored_type> jit_code_id_; 2419 ColumnStorage<ColumnType::v8_js_function_id::stored_type> v8_js_function_id_; 2420 ColumnStorage<ColumnType::tier::stored_type> tier_; 2421 ColumnStorage<ColumnType::bytecode_base64::stored_type> bytecode_base64_; 2422 2423 RefPtr<column::StorageLayer> id_storage_layer_; 2424 RefPtr<column::StorageLayer> type_storage_layer_; 2425 RefPtr<column::StorageLayer> jit_code_id_storage_layer_; 2426 RefPtr<column::StorageLayer> v8_js_function_id_storage_layer_; 2427 RefPtr<column::StorageLayer> tier_storage_layer_; 2428 RefPtr<column::StorageLayer> bytecode_base64_storage_layer_; 2429 2430 RefPtr<column::OverlayLayer> jit_code_id_null_layer_; 2431 }; 2432 2433 2434 class V8InternalCodeTable : public macros_internal::MacroTable { 2435 public: 2436 static constexpr uint32_t kColumnCount = 6; 2437 2438 struct Id : public BaseId { 2439 Id() = default; IdId2440 explicit constexpr Id(uint32_t v) : BaseId(v) {} 2441 }; 2442 static_assert(std::is_trivially_destructible_v<Id>, 2443 "Inheritance used without trivial destruction"); 2444 2445 struct ColumnIndex { 2446 static constexpr uint32_t id = 0; 2447 static constexpr uint32_t type = 1; 2448 static constexpr uint32_t jit_code_id = 2; 2449 static constexpr uint32_t v8_isolate_id = 3; 2450 static constexpr uint32_t function_name = 4; 2451 static constexpr uint32_t code_type = 5; 2452 }; 2453 struct ColumnType { 2454 using id = IdColumn<V8InternalCodeTable::Id>; 2455 using type = TypedColumn<StringPool::Id>; 2456 using jit_code_id = TypedColumn<JitCodeTable::Id>; 2457 using v8_isolate_id = TypedColumn<V8IsolateTable::Id>; 2458 using function_name = TypedColumn<StringPool::Id>; 2459 using code_type = TypedColumn<StringPool::Id>; 2460 }; 2461 struct Row : public macros_internal::RootParentTable::Row { 2462 Row(JitCodeTable::Id in_jit_code_id = {}, 2463 V8IsolateTable::Id in_v8_isolate_id = {}, 2464 StringPool::Id in_function_name = {}, 2465 StringPool::Id in_code_type = {}, 2466 std::nullptr_t = nullptr) RowRow2467 : macros_internal::RootParentTable::Row(), 2468 jit_code_id(in_jit_code_id), 2469 v8_isolate_id(in_v8_isolate_id), 2470 function_name(in_function_name), 2471 code_type(in_code_type) { 2472 type_ = "__intrinsic_v8_internal_code"; 2473 } 2474 JitCodeTable::Id jit_code_id; 2475 V8IsolateTable::Id v8_isolate_id; 2476 StringPool::Id function_name; 2477 StringPool::Id code_type; 2478 2479 bool operator==(const V8InternalCodeTable::Row& other) const { 2480 return type() == other.type() && ColumnType::jit_code_id::Equals(jit_code_id, other.jit_code_id) && 2481 ColumnType::v8_isolate_id::Equals(v8_isolate_id, other.v8_isolate_id) && 2482 ColumnType::function_name::Equals(function_name, other.function_name) && 2483 ColumnType::code_type::Equals(code_type, other.code_type); 2484 } 2485 }; 2486 struct ColumnFlag { 2487 static constexpr uint32_t jit_code_id = ColumnType::jit_code_id::default_flags(); 2488 static constexpr uint32_t v8_isolate_id = ColumnType::v8_isolate_id::default_flags(); 2489 static constexpr uint32_t function_name = ColumnType::function_name::default_flags(); 2490 static constexpr uint32_t code_type = ColumnType::code_type::default_flags(); 2491 }; 2492 2493 class RowNumber; 2494 class ConstRowReference; 2495 class RowReference; 2496 2497 class RowNumber : public macros_internal::AbstractRowNumber< 2498 V8InternalCodeTable, ConstRowReference, RowReference> { 2499 public: RowNumber(uint32_t row_number)2500 explicit RowNumber(uint32_t row_number) 2501 : AbstractRowNumber(row_number) {} 2502 }; 2503 static_assert(std::is_trivially_destructible_v<RowNumber>, 2504 "Inheritance used without trivial destruction"); 2505 2506 class ConstRowReference : public macros_internal::AbstractConstRowReference< 2507 V8InternalCodeTable, RowNumber> { 2508 public: ConstRowReference(const V8InternalCodeTable * table,uint32_t row_number)2509 ConstRowReference(const V8InternalCodeTable* table, uint32_t row_number) 2510 : AbstractConstRowReference(table, row_number) {} 2511 id()2512 ColumnType::id::type id() const { 2513 return table()->id()[row_number_]; 2514 } type()2515 ColumnType::type::type type() const { 2516 return table()->type()[row_number_]; 2517 } jit_code_id()2518 ColumnType::jit_code_id::type jit_code_id() const { 2519 return table()->jit_code_id()[row_number_]; 2520 } v8_isolate_id()2521 ColumnType::v8_isolate_id::type v8_isolate_id() const { 2522 return table()->v8_isolate_id()[row_number_]; 2523 } function_name()2524 ColumnType::function_name::type function_name() const { 2525 return table()->function_name()[row_number_]; 2526 } code_type()2527 ColumnType::code_type::type code_type() const { 2528 return table()->code_type()[row_number_]; 2529 } 2530 }; 2531 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 2532 "Inheritance used without trivial destruction"); 2533 class RowReference : public ConstRowReference { 2534 public: RowReference(const V8InternalCodeTable * table,uint32_t row_number)2535 RowReference(const V8InternalCodeTable* table, uint32_t row_number) 2536 : ConstRowReference(table, row_number) {} 2537 set_jit_code_id(ColumnType::jit_code_id::non_optional_type v)2538 void set_jit_code_id( 2539 ColumnType::jit_code_id::non_optional_type v) { 2540 return mutable_table()->mutable_jit_code_id()->Set(row_number_, v); 2541 } set_v8_isolate_id(ColumnType::v8_isolate_id::non_optional_type v)2542 void set_v8_isolate_id( 2543 ColumnType::v8_isolate_id::non_optional_type v) { 2544 return mutable_table()->mutable_v8_isolate_id()->Set(row_number_, v); 2545 } set_function_name(ColumnType::function_name::non_optional_type v)2546 void set_function_name( 2547 ColumnType::function_name::non_optional_type v) { 2548 return mutable_table()->mutable_function_name()->Set(row_number_, v); 2549 } set_code_type(ColumnType::code_type::non_optional_type v)2550 void set_code_type( 2551 ColumnType::code_type::non_optional_type v) { 2552 return mutable_table()->mutable_code_type()->Set(row_number_, v); 2553 } 2554 2555 private: mutable_table()2556 V8InternalCodeTable* mutable_table() const { 2557 return const_cast<V8InternalCodeTable*>(table()); 2558 } 2559 }; 2560 static_assert(std::is_trivially_destructible_v<RowReference>, 2561 "Inheritance used without trivial destruction"); 2562 2563 class ConstIterator; 2564 class ConstIterator : public macros_internal::AbstractConstIterator< 2565 ConstIterator, V8InternalCodeTable, RowNumber, ConstRowReference> { 2566 public: id()2567 ColumnType::id::type id() const { 2568 const auto& col = table()->id(); 2569 return col.GetAtIdx( 2570 iterator_.StorageIndexForColumn(col.index_in_table())); 2571 } type()2572 ColumnType::type::type type() const { 2573 const auto& col = table()->type(); 2574 return col.GetAtIdx( 2575 iterator_.StorageIndexForColumn(col.index_in_table())); 2576 } jit_code_id()2577 ColumnType::jit_code_id::type jit_code_id() const { 2578 const auto& col = table()->jit_code_id(); 2579 return col.GetAtIdx( 2580 iterator_.StorageIndexForColumn(col.index_in_table())); 2581 } v8_isolate_id()2582 ColumnType::v8_isolate_id::type v8_isolate_id() const { 2583 const auto& col = table()->v8_isolate_id(); 2584 return col.GetAtIdx( 2585 iterator_.StorageIndexForColumn(col.index_in_table())); 2586 } function_name()2587 ColumnType::function_name::type function_name() const { 2588 const auto& col = table()->function_name(); 2589 return col.GetAtIdx( 2590 iterator_.StorageIndexForColumn(col.index_in_table())); 2591 } code_type()2592 ColumnType::code_type::type code_type() const { 2593 const auto& col = table()->code_type(); 2594 return col.GetAtIdx( 2595 iterator_.StorageIndexForColumn(col.index_in_table())); 2596 } 2597 2598 protected: ConstIterator(const V8InternalCodeTable * table,Table::Iterator iterator)2599 explicit ConstIterator(const V8InternalCodeTable* table, 2600 Table::Iterator iterator) 2601 : AbstractConstIterator(table, std::move(iterator)) {} 2602 CurrentRowNumber()2603 uint32_t CurrentRowNumber() const { 2604 return iterator_.StorageIndexForLastOverlay(); 2605 } 2606 2607 private: 2608 friend class V8InternalCodeTable; 2609 friend class macros_internal::AbstractConstIterator< 2610 ConstIterator, V8InternalCodeTable, RowNumber, ConstRowReference>; 2611 }; 2612 class Iterator : public ConstIterator { 2613 public: row_reference()2614 RowReference row_reference() const { 2615 return {const_cast<V8InternalCodeTable*>(table()), CurrentRowNumber()}; 2616 } 2617 2618 private: 2619 friend class V8InternalCodeTable; 2620 Iterator(V8InternalCodeTable * table,Table::Iterator iterator)2621 explicit Iterator(V8InternalCodeTable* table, Table::Iterator iterator) 2622 : ConstIterator(table, std::move(iterator)) {} 2623 }; 2624 2625 struct IdAndRow { 2626 Id id; 2627 uint32_t row; 2628 RowReference row_reference; 2629 RowNumber row_number; 2630 }; 2631 GetColumns(V8InternalCodeTable * self,const macros_internal::MacroTable * parent)2632 static std::vector<ColumnLegacy> GetColumns( 2633 V8InternalCodeTable* self, 2634 const macros_internal::MacroTable* parent) { 2635 std::vector<ColumnLegacy> columns = 2636 CopyColumnsFromParentOrAddRootColumns(self, parent); 2637 uint32_t olay_idx = OverlayCount(parent); 2638 AddColumnToVector(columns, "jit_code_id", &self->jit_code_id_, ColumnFlag::jit_code_id, 2639 static_cast<uint32_t>(columns.size()), olay_idx); 2640 AddColumnToVector(columns, "v8_isolate_id", &self->v8_isolate_id_, ColumnFlag::v8_isolate_id, 2641 static_cast<uint32_t>(columns.size()), olay_idx); 2642 AddColumnToVector(columns, "function_name", &self->function_name_, ColumnFlag::function_name, 2643 static_cast<uint32_t>(columns.size()), olay_idx); 2644 AddColumnToVector(columns, "code_type", &self->code_type_, ColumnFlag::code_type, 2645 static_cast<uint32_t>(columns.size()), olay_idx); 2646 return columns; 2647 } 2648 V8InternalCodeTable(StringPool * pool)2649 PERFETTO_NO_INLINE explicit V8InternalCodeTable(StringPool* pool) 2650 : macros_internal::MacroTable( 2651 pool, 2652 GetColumns(this, nullptr), 2653 nullptr), 2654 jit_code_id_(ColumnStorage<ColumnType::jit_code_id::stored_type>::Create<false>()), 2655 v8_isolate_id_(ColumnStorage<ColumnType::v8_isolate_id::stored_type>::Create<false>()), 2656 function_name_(ColumnStorage<ColumnType::function_name::stored_type>::Create<false>()), 2657 code_type_(ColumnStorage<ColumnType::code_type::stored_type>::Create<false>()) 2658 , 2659 id_storage_layer_(new column::IdStorage()), 2660 type_storage_layer_( 2661 new column::StringStorage(string_pool(), &type_.vector())), 2662 jit_code_id_storage_layer_( 2663 new column::NumericStorage<ColumnType::jit_code_id::non_optional_stored_type>( 2664 &jit_code_id_.vector(), 2665 ColumnTypeHelper<ColumnType::jit_code_id::stored_type>::ToColumnType(), 2666 false)), 2667 v8_isolate_id_storage_layer_( 2668 new column::NumericStorage<ColumnType::v8_isolate_id::non_optional_stored_type>( 2669 &v8_isolate_id_.vector(), 2670 ColumnTypeHelper<ColumnType::v8_isolate_id::stored_type>::ToColumnType(), 2671 false)), 2672 function_name_storage_layer_( 2673 new column::StringStorage(string_pool(), &function_name_.vector())), 2674 code_type_storage_layer_( 2675 new column::StringStorage(string_pool(), &code_type_.vector())) 2676 { 2677 static_assert( 2678 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::jit_code_id::stored_type>( 2679 ColumnFlag::jit_code_id), 2680 "Column type and flag combination is not valid"); 2681 static_assert( 2682 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::v8_isolate_id::stored_type>( 2683 ColumnFlag::v8_isolate_id), 2684 "Column type and flag combination is not valid"); 2685 static_assert( 2686 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::function_name::stored_type>( 2687 ColumnFlag::function_name), 2688 "Column type and flag combination is not valid"); 2689 static_assert( 2690 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::code_type::stored_type>( 2691 ColumnFlag::code_type), 2692 "Column type and flag combination is not valid"); 2693 OnConstructionCompletedRegularConstructor( 2694 {id_storage_layer_,type_storage_layer_,jit_code_id_storage_layer_,v8_isolate_id_storage_layer_,function_name_storage_layer_,code_type_storage_layer_}, 2695 {{},{},{},{},{},{}}); 2696 } 2697 ~V8InternalCodeTable() override; 2698 Name()2699 static const char* Name() { return "__intrinsic_v8_internal_code"; } 2700 ComputeStaticSchema()2701 static Table::Schema ComputeStaticSchema() { 2702 Table::Schema schema; 2703 schema.columns.emplace_back(Table::Schema::Column{ 2704 "id", SqlValue::Type::kLong, true, true, false, false}); 2705 schema.columns.emplace_back(Table::Schema::Column{ 2706 "type", SqlValue::Type::kString, false, false, false, false}); 2707 schema.columns.emplace_back(Table::Schema::Column{ 2708 "jit_code_id", ColumnType::jit_code_id::SqlValueType(), false, 2709 false, 2710 false, 2711 false}); 2712 schema.columns.emplace_back(Table::Schema::Column{ 2713 "v8_isolate_id", ColumnType::v8_isolate_id::SqlValueType(), false, 2714 false, 2715 false, 2716 false}); 2717 schema.columns.emplace_back(Table::Schema::Column{ 2718 "function_name", ColumnType::function_name::SqlValueType(), false, 2719 false, 2720 false, 2721 false}); 2722 schema.columns.emplace_back(Table::Schema::Column{ 2723 "code_type", ColumnType::code_type::SqlValueType(), false, 2724 false, 2725 false, 2726 false}); 2727 return schema; 2728 } 2729 IterateRows()2730 ConstIterator IterateRows() const { 2731 return ConstIterator(this, Table::IterateRows()); 2732 } 2733 IterateRows()2734 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 2735 FilterToIterator(const Query & q)2736 ConstIterator FilterToIterator(const Query& q) const { 2737 return ConstIterator(this, QueryToIterator(q)); 2738 } 2739 FilterToIterator(const Query & q)2740 Iterator FilterToIterator(const Query& q) { 2741 return Iterator(this, QueryToIterator(q)); 2742 } 2743 ShrinkToFit()2744 void ShrinkToFit() { 2745 type_.ShrinkToFit(); 2746 jit_code_id_.ShrinkToFit(); 2747 v8_isolate_id_.ShrinkToFit(); 2748 function_name_.ShrinkToFit(); 2749 code_type_.ShrinkToFit(); 2750 } 2751 2752 ConstRowReference operator[](uint32_t r) const { 2753 return ConstRowReference(this, r); 2754 } 2755 RowReference operator[](uint32_t r) { return RowReference(this, r); } 2756 ConstRowReference operator[](RowNumber r) const { 2757 return ConstRowReference(this, r.row_number()); 2758 } 2759 RowReference operator[](RowNumber r) { 2760 return RowReference(this, r.row_number()); 2761 } 2762 FindById(Id find_id)2763 std::optional<ConstRowReference> FindById(Id find_id) const { 2764 std::optional<uint32_t> row = id().IndexOf(find_id); 2765 return row ? std::make_optional(ConstRowReference(this, *row)) 2766 : std::nullopt; 2767 } 2768 FindById(Id find_id)2769 std::optional<RowReference> FindById(Id find_id) { 2770 std::optional<uint32_t> row = id().IndexOf(find_id); 2771 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 2772 } 2773 Insert(const Row & row)2774 IdAndRow Insert(const Row& row) { 2775 uint32_t row_number = row_count(); 2776 Id id = Id{row_number}; 2777 type_.Append(string_pool()->InternString(row.type())); 2778 mutable_jit_code_id()->Append(row.jit_code_id); 2779 mutable_v8_isolate_id()->Append(row.v8_isolate_id); 2780 mutable_function_name()->Append(row.function_name); 2781 mutable_code_type()->Append(row.code_type); 2782 UpdateSelfOverlayAfterInsert(); 2783 return IdAndRow{id, row_number, RowReference(this, row_number), 2784 RowNumber(row_number)}; 2785 } 2786 2787 2788 id()2789 const IdColumn<V8InternalCodeTable::Id>& id() const { 2790 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 2791 } type()2792 const TypedColumn<StringPool::Id>& type() const { 2793 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 2794 } jit_code_id()2795 const TypedColumn<JitCodeTable::Id>& jit_code_id() const { 2796 return static_cast<const ColumnType::jit_code_id&>(columns()[ColumnIndex::jit_code_id]); 2797 } v8_isolate_id()2798 const TypedColumn<V8IsolateTable::Id>& v8_isolate_id() const { 2799 return static_cast<const ColumnType::v8_isolate_id&>(columns()[ColumnIndex::v8_isolate_id]); 2800 } function_name()2801 const TypedColumn<StringPool::Id>& function_name() const { 2802 return static_cast<const ColumnType::function_name&>(columns()[ColumnIndex::function_name]); 2803 } code_type()2804 const TypedColumn<StringPool::Id>& code_type() const { 2805 return static_cast<const ColumnType::code_type&>(columns()[ColumnIndex::code_type]); 2806 } 2807 mutable_jit_code_id()2808 TypedColumn<JitCodeTable::Id>* mutable_jit_code_id() { 2809 return static_cast<ColumnType::jit_code_id*>( 2810 GetColumn(ColumnIndex::jit_code_id)); 2811 } mutable_v8_isolate_id()2812 TypedColumn<V8IsolateTable::Id>* mutable_v8_isolate_id() { 2813 return static_cast<ColumnType::v8_isolate_id*>( 2814 GetColumn(ColumnIndex::v8_isolate_id)); 2815 } mutable_function_name()2816 TypedColumn<StringPool::Id>* mutable_function_name() { 2817 return static_cast<ColumnType::function_name*>( 2818 GetColumn(ColumnIndex::function_name)); 2819 } mutable_code_type()2820 TypedColumn<StringPool::Id>* mutable_code_type() { 2821 return static_cast<ColumnType::code_type*>( 2822 GetColumn(ColumnIndex::code_type)); 2823 } 2824 2825 private: 2826 2827 2828 ColumnStorage<ColumnType::jit_code_id::stored_type> jit_code_id_; 2829 ColumnStorage<ColumnType::v8_isolate_id::stored_type> v8_isolate_id_; 2830 ColumnStorage<ColumnType::function_name::stored_type> function_name_; 2831 ColumnStorage<ColumnType::code_type::stored_type> code_type_; 2832 2833 RefPtr<column::StorageLayer> id_storage_layer_; 2834 RefPtr<column::StorageLayer> type_storage_layer_; 2835 RefPtr<column::StorageLayer> jit_code_id_storage_layer_; 2836 RefPtr<column::StorageLayer> v8_isolate_id_storage_layer_; 2837 RefPtr<column::StorageLayer> function_name_storage_layer_; 2838 RefPtr<column::StorageLayer> code_type_storage_layer_; 2839 2840 2841 }; 2842 2843 2844 class V8WasmCodeTable : public macros_internal::MacroTable { 2845 public: 2846 static constexpr uint32_t kColumnCount = 8; 2847 2848 struct Id : public BaseId { 2849 Id() = default; IdId2850 explicit constexpr Id(uint32_t v) : BaseId(v) {} 2851 }; 2852 static_assert(std::is_trivially_destructible_v<Id>, 2853 "Inheritance used without trivial destruction"); 2854 2855 struct ColumnIndex { 2856 static constexpr uint32_t id = 0; 2857 static constexpr uint32_t type = 1; 2858 static constexpr uint32_t jit_code_id = 2; 2859 static constexpr uint32_t v8_isolate_id = 3; 2860 static constexpr uint32_t v8_wasm_script_id = 4; 2861 static constexpr uint32_t function_name = 5; 2862 static constexpr uint32_t tier = 6; 2863 static constexpr uint32_t code_offset_in_module = 7; 2864 }; 2865 struct ColumnType { 2866 using id = IdColumn<V8WasmCodeTable::Id>; 2867 using type = TypedColumn<StringPool::Id>; 2868 using jit_code_id = TypedColumn<JitCodeTable::Id>; 2869 using v8_isolate_id = TypedColumn<V8IsolateTable::Id>; 2870 using v8_wasm_script_id = TypedColumn<V8WasmScriptTable::Id>; 2871 using function_name = TypedColumn<StringPool::Id>; 2872 using tier = TypedColumn<StringPool::Id>; 2873 using code_offset_in_module = TypedColumn<int32_t>; 2874 }; 2875 struct Row : public macros_internal::RootParentTable::Row { 2876 Row(JitCodeTable::Id in_jit_code_id = {}, 2877 V8IsolateTable::Id in_v8_isolate_id = {}, 2878 V8WasmScriptTable::Id in_v8_wasm_script_id = {}, 2879 StringPool::Id in_function_name = {}, 2880 StringPool::Id in_tier = {}, 2881 int32_t in_code_offset_in_module = {}, 2882 std::nullptr_t = nullptr) RowRow2883 : macros_internal::RootParentTable::Row(), 2884 jit_code_id(in_jit_code_id), 2885 v8_isolate_id(in_v8_isolate_id), 2886 v8_wasm_script_id(in_v8_wasm_script_id), 2887 function_name(in_function_name), 2888 tier(in_tier), 2889 code_offset_in_module(in_code_offset_in_module) { 2890 type_ = "__intrinsic_v8_wasm_code"; 2891 } 2892 JitCodeTable::Id jit_code_id; 2893 V8IsolateTable::Id v8_isolate_id; 2894 V8WasmScriptTable::Id v8_wasm_script_id; 2895 StringPool::Id function_name; 2896 StringPool::Id tier; 2897 int32_t code_offset_in_module; 2898 2899 bool operator==(const V8WasmCodeTable::Row& other) const { 2900 return type() == other.type() && ColumnType::jit_code_id::Equals(jit_code_id, other.jit_code_id) && 2901 ColumnType::v8_isolate_id::Equals(v8_isolate_id, other.v8_isolate_id) && 2902 ColumnType::v8_wasm_script_id::Equals(v8_wasm_script_id, other.v8_wasm_script_id) && 2903 ColumnType::function_name::Equals(function_name, other.function_name) && 2904 ColumnType::tier::Equals(tier, other.tier) && 2905 ColumnType::code_offset_in_module::Equals(code_offset_in_module, other.code_offset_in_module); 2906 } 2907 }; 2908 struct ColumnFlag { 2909 static constexpr uint32_t jit_code_id = ColumnType::jit_code_id::default_flags(); 2910 static constexpr uint32_t v8_isolate_id = ColumnType::v8_isolate_id::default_flags(); 2911 static constexpr uint32_t v8_wasm_script_id = ColumnType::v8_wasm_script_id::default_flags(); 2912 static constexpr uint32_t function_name = ColumnType::function_name::default_flags(); 2913 static constexpr uint32_t tier = ColumnType::tier::default_flags(); 2914 static constexpr uint32_t code_offset_in_module = ColumnType::code_offset_in_module::default_flags(); 2915 }; 2916 2917 class RowNumber; 2918 class ConstRowReference; 2919 class RowReference; 2920 2921 class RowNumber : public macros_internal::AbstractRowNumber< 2922 V8WasmCodeTable, ConstRowReference, RowReference> { 2923 public: RowNumber(uint32_t row_number)2924 explicit RowNumber(uint32_t row_number) 2925 : AbstractRowNumber(row_number) {} 2926 }; 2927 static_assert(std::is_trivially_destructible_v<RowNumber>, 2928 "Inheritance used without trivial destruction"); 2929 2930 class ConstRowReference : public macros_internal::AbstractConstRowReference< 2931 V8WasmCodeTable, RowNumber> { 2932 public: ConstRowReference(const V8WasmCodeTable * table,uint32_t row_number)2933 ConstRowReference(const V8WasmCodeTable* table, uint32_t row_number) 2934 : AbstractConstRowReference(table, row_number) {} 2935 id()2936 ColumnType::id::type id() const { 2937 return table()->id()[row_number_]; 2938 } type()2939 ColumnType::type::type type() const { 2940 return table()->type()[row_number_]; 2941 } jit_code_id()2942 ColumnType::jit_code_id::type jit_code_id() const { 2943 return table()->jit_code_id()[row_number_]; 2944 } v8_isolate_id()2945 ColumnType::v8_isolate_id::type v8_isolate_id() const { 2946 return table()->v8_isolate_id()[row_number_]; 2947 } v8_wasm_script_id()2948 ColumnType::v8_wasm_script_id::type v8_wasm_script_id() const { 2949 return table()->v8_wasm_script_id()[row_number_]; 2950 } function_name()2951 ColumnType::function_name::type function_name() const { 2952 return table()->function_name()[row_number_]; 2953 } tier()2954 ColumnType::tier::type tier() const { 2955 return table()->tier()[row_number_]; 2956 } code_offset_in_module()2957 ColumnType::code_offset_in_module::type code_offset_in_module() const { 2958 return table()->code_offset_in_module()[row_number_]; 2959 } 2960 }; 2961 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 2962 "Inheritance used without trivial destruction"); 2963 class RowReference : public ConstRowReference { 2964 public: RowReference(const V8WasmCodeTable * table,uint32_t row_number)2965 RowReference(const V8WasmCodeTable* table, uint32_t row_number) 2966 : ConstRowReference(table, row_number) {} 2967 set_jit_code_id(ColumnType::jit_code_id::non_optional_type v)2968 void set_jit_code_id( 2969 ColumnType::jit_code_id::non_optional_type v) { 2970 return mutable_table()->mutable_jit_code_id()->Set(row_number_, v); 2971 } set_v8_isolate_id(ColumnType::v8_isolate_id::non_optional_type v)2972 void set_v8_isolate_id( 2973 ColumnType::v8_isolate_id::non_optional_type v) { 2974 return mutable_table()->mutable_v8_isolate_id()->Set(row_number_, v); 2975 } set_v8_wasm_script_id(ColumnType::v8_wasm_script_id::non_optional_type v)2976 void set_v8_wasm_script_id( 2977 ColumnType::v8_wasm_script_id::non_optional_type v) { 2978 return mutable_table()->mutable_v8_wasm_script_id()->Set(row_number_, v); 2979 } set_function_name(ColumnType::function_name::non_optional_type v)2980 void set_function_name( 2981 ColumnType::function_name::non_optional_type v) { 2982 return mutable_table()->mutable_function_name()->Set(row_number_, v); 2983 } set_tier(ColumnType::tier::non_optional_type v)2984 void set_tier( 2985 ColumnType::tier::non_optional_type v) { 2986 return mutable_table()->mutable_tier()->Set(row_number_, v); 2987 } set_code_offset_in_module(ColumnType::code_offset_in_module::non_optional_type v)2988 void set_code_offset_in_module( 2989 ColumnType::code_offset_in_module::non_optional_type v) { 2990 return mutable_table()->mutable_code_offset_in_module()->Set(row_number_, v); 2991 } 2992 2993 private: mutable_table()2994 V8WasmCodeTable* mutable_table() const { 2995 return const_cast<V8WasmCodeTable*>(table()); 2996 } 2997 }; 2998 static_assert(std::is_trivially_destructible_v<RowReference>, 2999 "Inheritance used without trivial destruction"); 3000 3001 class ConstIterator; 3002 class ConstIterator : public macros_internal::AbstractConstIterator< 3003 ConstIterator, V8WasmCodeTable, RowNumber, ConstRowReference> { 3004 public: id()3005 ColumnType::id::type id() const { 3006 const auto& col = table()->id(); 3007 return col.GetAtIdx( 3008 iterator_.StorageIndexForColumn(col.index_in_table())); 3009 } type()3010 ColumnType::type::type type() const { 3011 const auto& col = table()->type(); 3012 return col.GetAtIdx( 3013 iterator_.StorageIndexForColumn(col.index_in_table())); 3014 } jit_code_id()3015 ColumnType::jit_code_id::type jit_code_id() const { 3016 const auto& col = table()->jit_code_id(); 3017 return col.GetAtIdx( 3018 iterator_.StorageIndexForColumn(col.index_in_table())); 3019 } v8_isolate_id()3020 ColumnType::v8_isolate_id::type v8_isolate_id() const { 3021 const auto& col = table()->v8_isolate_id(); 3022 return col.GetAtIdx( 3023 iterator_.StorageIndexForColumn(col.index_in_table())); 3024 } v8_wasm_script_id()3025 ColumnType::v8_wasm_script_id::type v8_wasm_script_id() const { 3026 const auto& col = table()->v8_wasm_script_id(); 3027 return col.GetAtIdx( 3028 iterator_.StorageIndexForColumn(col.index_in_table())); 3029 } function_name()3030 ColumnType::function_name::type function_name() const { 3031 const auto& col = table()->function_name(); 3032 return col.GetAtIdx( 3033 iterator_.StorageIndexForColumn(col.index_in_table())); 3034 } tier()3035 ColumnType::tier::type tier() const { 3036 const auto& col = table()->tier(); 3037 return col.GetAtIdx( 3038 iterator_.StorageIndexForColumn(col.index_in_table())); 3039 } code_offset_in_module()3040 ColumnType::code_offset_in_module::type code_offset_in_module() const { 3041 const auto& col = table()->code_offset_in_module(); 3042 return col.GetAtIdx( 3043 iterator_.StorageIndexForColumn(col.index_in_table())); 3044 } 3045 3046 protected: ConstIterator(const V8WasmCodeTable * table,Table::Iterator iterator)3047 explicit ConstIterator(const V8WasmCodeTable* table, 3048 Table::Iterator iterator) 3049 : AbstractConstIterator(table, std::move(iterator)) {} 3050 CurrentRowNumber()3051 uint32_t CurrentRowNumber() const { 3052 return iterator_.StorageIndexForLastOverlay(); 3053 } 3054 3055 private: 3056 friend class V8WasmCodeTable; 3057 friend class macros_internal::AbstractConstIterator< 3058 ConstIterator, V8WasmCodeTable, RowNumber, ConstRowReference>; 3059 }; 3060 class Iterator : public ConstIterator { 3061 public: row_reference()3062 RowReference row_reference() const { 3063 return {const_cast<V8WasmCodeTable*>(table()), CurrentRowNumber()}; 3064 } 3065 3066 private: 3067 friend class V8WasmCodeTable; 3068 Iterator(V8WasmCodeTable * table,Table::Iterator iterator)3069 explicit Iterator(V8WasmCodeTable* table, Table::Iterator iterator) 3070 : ConstIterator(table, std::move(iterator)) {} 3071 }; 3072 3073 struct IdAndRow { 3074 Id id; 3075 uint32_t row; 3076 RowReference row_reference; 3077 RowNumber row_number; 3078 }; 3079 GetColumns(V8WasmCodeTable * self,const macros_internal::MacroTable * parent)3080 static std::vector<ColumnLegacy> GetColumns( 3081 V8WasmCodeTable* self, 3082 const macros_internal::MacroTable* parent) { 3083 std::vector<ColumnLegacy> columns = 3084 CopyColumnsFromParentOrAddRootColumns(self, parent); 3085 uint32_t olay_idx = OverlayCount(parent); 3086 AddColumnToVector(columns, "jit_code_id", &self->jit_code_id_, ColumnFlag::jit_code_id, 3087 static_cast<uint32_t>(columns.size()), olay_idx); 3088 AddColumnToVector(columns, "v8_isolate_id", &self->v8_isolate_id_, ColumnFlag::v8_isolate_id, 3089 static_cast<uint32_t>(columns.size()), olay_idx); 3090 AddColumnToVector(columns, "v8_wasm_script_id", &self->v8_wasm_script_id_, ColumnFlag::v8_wasm_script_id, 3091 static_cast<uint32_t>(columns.size()), olay_idx); 3092 AddColumnToVector(columns, "function_name", &self->function_name_, ColumnFlag::function_name, 3093 static_cast<uint32_t>(columns.size()), olay_idx); 3094 AddColumnToVector(columns, "tier", &self->tier_, ColumnFlag::tier, 3095 static_cast<uint32_t>(columns.size()), olay_idx); 3096 AddColumnToVector(columns, "code_offset_in_module", &self->code_offset_in_module_, ColumnFlag::code_offset_in_module, 3097 static_cast<uint32_t>(columns.size()), olay_idx); 3098 return columns; 3099 } 3100 V8WasmCodeTable(StringPool * pool)3101 PERFETTO_NO_INLINE explicit V8WasmCodeTable(StringPool* pool) 3102 : macros_internal::MacroTable( 3103 pool, 3104 GetColumns(this, nullptr), 3105 nullptr), 3106 jit_code_id_(ColumnStorage<ColumnType::jit_code_id::stored_type>::Create<false>()), 3107 v8_isolate_id_(ColumnStorage<ColumnType::v8_isolate_id::stored_type>::Create<false>()), 3108 v8_wasm_script_id_(ColumnStorage<ColumnType::v8_wasm_script_id::stored_type>::Create<false>()), 3109 function_name_(ColumnStorage<ColumnType::function_name::stored_type>::Create<false>()), 3110 tier_(ColumnStorage<ColumnType::tier::stored_type>::Create<false>()), 3111 code_offset_in_module_(ColumnStorage<ColumnType::code_offset_in_module::stored_type>::Create<false>()) 3112 , 3113 id_storage_layer_(new column::IdStorage()), 3114 type_storage_layer_( 3115 new column::StringStorage(string_pool(), &type_.vector())), 3116 jit_code_id_storage_layer_( 3117 new column::NumericStorage<ColumnType::jit_code_id::non_optional_stored_type>( 3118 &jit_code_id_.vector(), 3119 ColumnTypeHelper<ColumnType::jit_code_id::stored_type>::ToColumnType(), 3120 false)), 3121 v8_isolate_id_storage_layer_( 3122 new column::NumericStorage<ColumnType::v8_isolate_id::non_optional_stored_type>( 3123 &v8_isolate_id_.vector(), 3124 ColumnTypeHelper<ColumnType::v8_isolate_id::stored_type>::ToColumnType(), 3125 false)), 3126 v8_wasm_script_id_storage_layer_( 3127 new column::NumericStorage<ColumnType::v8_wasm_script_id::non_optional_stored_type>( 3128 &v8_wasm_script_id_.vector(), 3129 ColumnTypeHelper<ColumnType::v8_wasm_script_id::stored_type>::ToColumnType(), 3130 false)), 3131 function_name_storage_layer_( 3132 new column::StringStorage(string_pool(), &function_name_.vector())), 3133 tier_storage_layer_( 3134 new column::StringStorage(string_pool(), &tier_.vector())), 3135 code_offset_in_module_storage_layer_( 3136 new column::NumericStorage<ColumnType::code_offset_in_module::non_optional_stored_type>( 3137 &code_offset_in_module_.vector(), 3138 ColumnTypeHelper<ColumnType::code_offset_in_module::stored_type>::ToColumnType(), 3139 false)) 3140 { 3141 static_assert( 3142 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::jit_code_id::stored_type>( 3143 ColumnFlag::jit_code_id), 3144 "Column type and flag combination is not valid"); 3145 static_assert( 3146 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::v8_isolate_id::stored_type>( 3147 ColumnFlag::v8_isolate_id), 3148 "Column type and flag combination is not valid"); 3149 static_assert( 3150 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::v8_wasm_script_id::stored_type>( 3151 ColumnFlag::v8_wasm_script_id), 3152 "Column type and flag combination is not valid"); 3153 static_assert( 3154 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::function_name::stored_type>( 3155 ColumnFlag::function_name), 3156 "Column type and flag combination is not valid"); 3157 static_assert( 3158 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::tier::stored_type>( 3159 ColumnFlag::tier), 3160 "Column type and flag combination is not valid"); 3161 static_assert( 3162 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::code_offset_in_module::stored_type>( 3163 ColumnFlag::code_offset_in_module), 3164 "Column type and flag combination is not valid"); 3165 OnConstructionCompletedRegularConstructor( 3166 {id_storage_layer_,type_storage_layer_,jit_code_id_storage_layer_,v8_isolate_id_storage_layer_,v8_wasm_script_id_storage_layer_,function_name_storage_layer_,tier_storage_layer_,code_offset_in_module_storage_layer_}, 3167 {{},{},{},{},{},{},{},{}}); 3168 } 3169 ~V8WasmCodeTable() override; 3170 Name()3171 static const char* Name() { return "__intrinsic_v8_wasm_code"; } 3172 ComputeStaticSchema()3173 static Table::Schema ComputeStaticSchema() { 3174 Table::Schema schema; 3175 schema.columns.emplace_back(Table::Schema::Column{ 3176 "id", SqlValue::Type::kLong, true, true, false, false}); 3177 schema.columns.emplace_back(Table::Schema::Column{ 3178 "type", SqlValue::Type::kString, false, false, false, false}); 3179 schema.columns.emplace_back(Table::Schema::Column{ 3180 "jit_code_id", ColumnType::jit_code_id::SqlValueType(), false, 3181 false, 3182 false, 3183 false}); 3184 schema.columns.emplace_back(Table::Schema::Column{ 3185 "v8_isolate_id", ColumnType::v8_isolate_id::SqlValueType(), false, 3186 false, 3187 false, 3188 false}); 3189 schema.columns.emplace_back(Table::Schema::Column{ 3190 "v8_wasm_script_id", ColumnType::v8_wasm_script_id::SqlValueType(), false, 3191 false, 3192 false, 3193 false}); 3194 schema.columns.emplace_back(Table::Schema::Column{ 3195 "function_name", ColumnType::function_name::SqlValueType(), false, 3196 false, 3197 false, 3198 false}); 3199 schema.columns.emplace_back(Table::Schema::Column{ 3200 "tier", ColumnType::tier::SqlValueType(), false, 3201 false, 3202 false, 3203 false}); 3204 schema.columns.emplace_back(Table::Schema::Column{ 3205 "code_offset_in_module", ColumnType::code_offset_in_module::SqlValueType(), false, 3206 false, 3207 false, 3208 false}); 3209 return schema; 3210 } 3211 IterateRows()3212 ConstIterator IterateRows() const { 3213 return ConstIterator(this, Table::IterateRows()); 3214 } 3215 IterateRows()3216 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 3217 FilterToIterator(const Query & q)3218 ConstIterator FilterToIterator(const Query& q) const { 3219 return ConstIterator(this, QueryToIterator(q)); 3220 } 3221 FilterToIterator(const Query & q)3222 Iterator FilterToIterator(const Query& q) { 3223 return Iterator(this, QueryToIterator(q)); 3224 } 3225 ShrinkToFit()3226 void ShrinkToFit() { 3227 type_.ShrinkToFit(); 3228 jit_code_id_.ShrinkToFit(); 3229 v8_isolate_id_.ShrinkToFit(); 3230 v8_wasm_script_id_.ShrinkToFit(); 3231 function_name_.ShrinkToFit(); 3232 tier_.ShrinkToFit(); 3233 code_offset_in_module_.ShrinkToFit(); 3234 } 3235 3236 ConstRowReference operator[](uint32_t r) const { 3237 return ConstRowReference(this, r); 3238 } 3239 RowReference operator[](uint32_t r) { return RowReference(this, r); } 3240 ConstRowReference operator[](RowNumber r) const { 3241 return ConstRowReference(this, r.row_number()); 3242 } 3243 RowReference operator[](RowNumber r) { 3244 return RowReference(this, r.row_number()); 3245 } 3246 FindById(Id find_id)3247 std::optional<ConstRowReference> FindById(Id find_id) const { 3248 std::optional<uint32_t> row = id().IndexOf(find_id); 3249 return row ? std::make_optional(ConstRowReference(this, *row)) 3250 : std::nullopt; 3251 } 3252 FindById(Id find_id)3253 std::optional<RowReference> FindById(Id find_id) { 3254 std::optional<uint32_t> row = id().IndexOf(find_id); 3255 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 3256 } 3257 Insert(const Row & row)3258 IdAndRow Insert(const Row& row) { 3259 uint32_t row_number = row_count(); 3260 Id id = Id{row_number}; 3261 type_.Append(string_pool()->InternString(row.type())); 3262 mutable_jit_code_id()->Append(row.jit_code_id); 3263 mutable_v8_isolate_id()->Append(row.v8_isolate_id); 3264 mutable_v8_wasm_script_id()->Append(row.v8_wasm_script_id); 3265 mutable_function_name()->Append(row.function_name); 3266 mutable_tier()->Append(row.tier); 3267 mutable_code_offset_in_module()->Append(row.code_offset_in_module); 3268 UpdateSelfOverlayAfterInsert(); 3269 return IdAndRow{id, row_number, RowReference(this, row_number), 3270 RowNumber(row_number)}; 3271 } 3272 3273 3274 id()3275 const IdColumn<V8WasmCodeTable::Id>& id() const { 3276 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 3277 } type()3278 const TypedColumn<StringPool::Id>& type() const { 3279 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 3280 } jit_code_id()3281 const TypedColumn<JitCodeTable::Id>& jit_code_id() const { 3282 return static_cast<const ColumnType::jit_code_id&>(columns()[ColumnIndex::jit_code_id]); 3283 } v8_isolate_id()3284 const TypedColumn<V8IsolateTable::Id>& v8_isolate_id() const { 3285 return static_cast<const ColumnType::v8_isolate_id&>(columns()[ColumnIndex::v8_isolate_id]); 3286 } v8_wasm_script_id()3287 const TypedColumn<V8WasmScriptTable::Id>& v8_wasm_script_id() const { 3288 return static_cast<const ColumnType::v8_wasm_script_id&>(columns()[ColumnIndex::v8_wasm_script_id]); 3289 } function_name()3290 const TypedColumn<StringPool::Id>& function_name() const { 3291 return static_cast<const ColumnType::function_name&>(columns()[ColumnIndex::function_name]); 3292 } tier()3293 const TypedColumn<StringPool::Id>& tier() const { 3294 return static_cast<const ColumnType::tier&>(columns()[ColumnIndex::tier]); 3295 } code_offset_in_module()3296 const TypedColumn<int32_t>& code_offset_in_module() const { 3297 return static_cast<const ColumnType::code_offset_in_module&>(columns()[ColumnIndex::code_offset_in_module]); 3298 } 3299 mutable_jit_code_id()3300 TypedColumn<JitCodeTable::Id>* mutable_jit_code_id() { 3301 return static_cast<ColumnType::jit_code_id*>( 3302 GetColumn(ColumnIndex::jit_code_id)); 3303 } mutable_v8_isolate_id()3304 TypedColumn<V8IsolateTable::Id>* mutable_v8_isolate_id() { 3305 return static_cast<ColumnType::v8_isolate_id*>( 3306 GetColumn(ColumnIndex::v8_isolate_id)); 3307 } mutable_v8_wasm_script_id()3308 TypedColumn<V8WasmScriptTable::Id>* mutable_v8_wasm_script_id() { 3309 return static_cast<ColumnType::v8_wasm_script_id*>( 3310 GetColumn(ColumnIndex::v8_wasm_script_id)); 3311 } mutable_function_name()3312 TypedColumn<StringPool::Id>* mutable_function_name() { 3313 return static_cast<ColumnType::function_name*>( 3314 GetColumn(ColumnIndex::function_name)); 3315 } mutable_tier()3316 TypedColumn<StringPool::Id>* mutable_tier() { 3317 return static_cast<ColumnType::tier*>( 3318 GetColumn(ColumnIndex::tier)); 3319 } mutable_code_offset_in_module()3320 TypedColumn<int32_t>* mutable_code_offset_in_module() { 3321 return static_cast<ColumnType::code_offset_in_module*>( 3322 GetColumn(ColumnIndex::code_offset_in_module)); 3323 } 3324 3325 private: 3326 3327 3328 ColumnStorage<ColumnType::jit_code_id::stored_type> jit_code_id_; 3329 ColumnStorage<ColumnType::v8_isolate_id::stored_type> v8_isolate_id_; 3330 ColumnStorage<ColumnType::v8_wasm_script_id::stored_type> v8_wasm_script_id_; 3331 ColumnStorage<ColumnType::function_name::stored_type> function_name_; 3332 ColumnStorage<ColumnType::tier::stored_type> tier_; 3333 ColumnStorage<ColumnType::code_offset_in_module::stored_type> code_offset_in_module_; 3334 3335 RefPtr<column::StorageLayer> id_storage_layer_; 3336 RefPtr<column::StorageLayer> type_storage_layer_; 3337 RefPtr<column::StorageLayer> jit_code_id_storage_layer_; 3338 RefPtr<column::StorageLayer> v8_isolate_id_storage_layer_; 3339 RefPtr<column::StorageLayer> v8_wasm_script_id_storage_layer_; 3340 RefPtr<column::StorageLayer> function_name_storage_layer_; 3341 RefPtr<column::StorageLayer> tier_storage_layer_; 3342 RefPtr<column::StorageLayer> code_offset_in_module_storage_layer_; 3343 3344 3345 }; 3346 3347 3348 class V8RegexpCodeTable : public macros_internal::MacroTable { 3349 public: 3350 static constexpr uint32_t kColumnCount = 5; 3351 3352 struct Id : public BaseId { 3353 Id() = default; IdId3354 explicit constexpr Id(uint32_t v) : BaseId(v) {} 3355 }; 3356 static_assert(std::is_trivially_destructible_v<Id>, 3357 "Inheritance used without trivial destruction"); 3358 3359 struct ColumnIndex { 3360 static constexpr uint32_t id = 0; 3361 static constexpr uint32_t type = 1; 3362 static constexpr uint32_t jit_code_id = 2; 3363 static constexpr uint32_t v8_isolate_id = 3; 3364 static constexpr uint32_t pattern = 4; 3365 }; 3366 struct ColumnType { 3367 using id = IdColumn<V8RegexpCodeTable::Id>; 3368 using type = TypedColumn<StringPool::Id>; 3369 using jit_code_id = TypedColumn<JitCodeTable::Id>; 3370 using v8_isolate_id = TypedColumn<V8IsolateTable::Id>; 3371 using pattern = TypedColumn<StringPool::Id>; 3372 }; 3373 struct Row : public macros_internal::RootParentTable::Row { 3374 Row(JitCodeTable::Id in_jit_code_id = {}, 3375 V8IsolateTable::Id in_v8_isolate_id = {}, 3376 StringPool::Id in_pattern = {}, 3377 std::nullptr_t = nullptr) RowRow3378 : macros_internal::RootParentTable::Row(), 3379 jit_code_id(in_jit_code_id), 3380 v8_isolate_id(in_v8_isolate_id), 3381 pattern(in_pattern) { 3382 type_ = "__intrinsic_v8_regexp_code"; 3383 } 3384 JitCodeTable::Id jit_code_id; 3385 V8IsolateTable::Id v8_isolate_id; 3386 StringPool::Id pattern; 3387 3388 bool operator==(const V8RegexpCodeTable::Row& other) const { 3389 return type() == other.type() && ColumnType::jit_code_id::Equals(jit_code_id, other.jit_code_id) && 3390 ColumnType::v8_isolate_id::Equals(v8_isolate_id, other.v8_isolate_id) && 3391 ColumnType::pattern::Equals(pattern, other.pattern); 3392 } 3393 }; 3394 struct ColumnFlag { 3395 static constexpr uint32_t jit_code_id = ColumnType::jit_code_id::default_flags(); 3396 static constexpr uint32_t v8_isolate_id = ColumnType::v8_isolate_id::default_flags(); 3397 static constexpr uint32_t pattern = ColumnType::pattern::default_flags(); 3398 }; 3399 3400 class RowNumber; 3401 class ConstRowReference; 3402 class RowReference; 3403 3404 class RowNumber : public macros_internal::AbstractRowNumber< 3405 V8RegexpCodeTable, ConstRowReference, RowReference> { 3406 public: RowNumber(uint32_t row_number)3407 explicit RowNumber(uint32_t row_number) 3408 : AbstractRowNumber(row_number) {} 3409 }; 3410 static_assert(std::is_trivially_destructible_v<RowNumber>, 3411 "Inheritance used without trivial destruction"); 3412 3413 class ConstRowReference : public macros_internal::AbstractConstRowReference< 3414 V8RegexpCodeTable, RowNumber> { 3415 public: ConstRowReference(const V8RegexpCodeTable * table,uint32_t row_number)3416 ConstRowReference(const V8RegexpCodeTable* table, uint32_t row_number) 3417 : AbstractConstRowReference(table, row_number) {} 3418 id()3419 ColumnType::id::type id() const { 3420 return table()->id()[row_number_]; 3421 } type()3422 ColumnType::type::type type() const { 3423 return table()->type()[row_number_]; 3424 } jit_code_id()3425 ColumnType::jit_code_id::type jit_code_id() const { 3426 return table()->jit_code_id()[row_number_]; 3427 } v8_isolate_id()3428 ColumnType::v8_isolate_id::type v8_isolate_id() const { 3429 return table()->v8_isolate_id()[row_number_]; 3430 } pattern()3431 ColumnType::pattern::type pattern() const { 3432 return table()->pattern()[row_number_]; 3433 } 3434 }; 3435 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 3436 "Inheritance used without trivial destruction"); 3437 class RowReference : public ConstRowReference { 3438 public: RowReference(const V8RegexpCodeTable * table,uint32_t row_number)3439 RowReference(const V8RegexpCodeTable* table, uint32_t row_number) 3440 : ConstRowReference(table, row_number) {} 3441 set_jit_code_id(ColumnType::jit_code_id::non_optional_type v)3442 void set_jit_code_id( 3443 ColumnType::jit_code_id::non_optional_type v) { 3444 return mutable_table()->mutable_jit_code_id()->Set(row_number_, v); 3445 } set_v8_isolate_id(ColumnType::v8_isolate_id::non_optional_type v)3446 void set_v8_isolate_id( 3447 ColumnType::v8_isolate_id::non_optional_type v) { 3448 return mutable_table()->mutable_v8_isolate_id()->Set(row_number_, v); 3449 } set_pattern(ColumnType::pattern::non_optional_type v)3450 void set_pattern( 3451 ColumnType::pattern::non_optional_type v) { 3452 return mutable_table()->mutable_pattern()->Set(row_number_, v); 3453 } 3454 3455 private: mutable_table()3456 V8RegexpCodeTable* mutable_table() const { 3457 return const_cast<V8RegexpCodeTable*>(table()); 3458 } 3459 }; 3460 static_assert(std::is_trivially_destructible_v<RowReference>, 3461 "Inheritance used without trivial destruction"); 3462 3463 class ConstIterator; 3464 class ConstIterator : public macros_internal::AbstractConstIterator< 3465 ConstIterator, V8RegexpCodeTable, RowNumber, ConstRowReference> { 3466 public: id()3467 ColumnType::id::type id() const { 3468 const auto& col = table()->id(); 3469 return col.GetAtIdx( 3470 iterator_.StorageIndexForColumn(col.index_in_table())); 3471 } type()3472 ColumnType::type::type type() const { 3473 const auto& col = table()->type(); 3474 return col.GetAtIdx( 3475 iterator_.StorageIndexForColumn(col.index_in_table())); 3476 } jit_code_id()3477 ColumnType::jit_code_id::type jit_code_id() const { 3478 const auto& col = table()->jit_code_id(); 3479 return col.GetAtIdx( 3480 iterator_.StorageIndexForColumn(col.index_in_table())); 3481 } v8_isolate_id()3482 ColumnType::v8_isolate_id::type v8_isolate_id() const { 3483 const auto& col = table()->v8_isolate_id(); 3484 return col.GetAtIdx( 3485 iterator_.StorageIndexForColumn(col.index_in_table())); 3486 } pattern()3487 ColumnType::pattern::type pattern() const { 3488 const auto& col = table()->pattern(); 3489 return col.GetAtIdx( 3490 iterator_.StorageIndexForColumn(col.index_in_table())); 3491 } 3492 3493 protected: ConstIterator(const V8RegexpCodeTable * table,Table::Iterator iterator)3494 explicit ConstIterator(const V8RegexpCodeTable* table, 3495 Table::Iterator iterator) 3496 : AbstractConstIterator(table, std::move(iterator)) {} 3497 CurrentRowNumber()3498 uint32_t CurrentRowNumber() const { 3499 return iterator_.StorageIndexForLastOverlay(); 3500 } 3501 3502 private: 3503 friend class V8RegexpCodeTable; 3504 friend class macros_internal::AbstractConstIterator< 3505 ConstIterator, V8RegexpCodeTable, RowNumber, ConstRowReference>; 3506 }; 3507 class Iterator : public ConstIterator { 3508 public: row_reference()3509 RowReference row_reference() const { 3510 return {const_cast<V8RegexpCodeTable*>(table()), CurrentRowNumber()}; 3511 } 3512 3513 private: 3514 friend class V8RegexpCodeTable; 3515 Iterator(V8RegexpCodeTable * table,Table::Iterator iterator)3516 explicit Iterator(V8RegexpCodeTable* table, Table::Iterator iterator) 3517 : ConstIterator(table, std::move(iterator)) {} 3518 }; 3519 3520 struct IdAndRow { 3521 Id id; 3522 uint32_t row; 3523 RowReference row_reference; 3524 RowNumber row_number; 3525 }; 3526 GetColumns(V8RegexpCodeTable * self,const macros_internal::MacroTable * parent)3527 static std::vector<ColumnLegacy> GetColumns( 3528 V8RegexpCodeTable* self, 3529 const macros_internal::MacroTable* parent) { 3530 std::vector<ColumnLegacy> columns = 3531 CopyColumnsFromParentOrAddRootColumns(self, parent); 3532 uint32_t olay_idx = OverlayCount(parent); 3533 AddColumnToVector(columns, "jit_code_id", &self->jit_code_id_, ColumnFlag::jit_code_id, 3534 static_cast<uint32_t>(columns.size()), olay_idx); 3535 AddColumnToVector(columns, "v8_isolate_id", &self->v8_isolate_id_, ColumnFlag::v8_isolate_id, 3536 static_cast<uint32_t>(columns.size()), olay_idx); 3537 AddColumnToVector(columns, "pattern", &self->pattern_, ColumnFlag::pattern, 3538 static_cast<uint32_t>(columns.size()), olay_idx); 3539 return columns; 3540 } 3541 V8RegexpCodeTable(StringPool * pool)3542 PERFETTO_NO_INLINE explicit V8RegexpCodeTable(StringPool* pool) 3543 : macros_internal::MacroTable( 3544 pool, 3545 GetColumns(this, nullptr), 3546 nullptr), 3547 jit_code_id_(ColumnStorage<ColumnType::jit_code_id::stored_type>::Create<false>()), 3548 v8_isolate_id_(ColumnStorage<ColumnType::v8_isolate_id::stored_type>::Create<false>()), 3549 pattern_(ColumnStorage<ColumnType::pattern::stored_type>::Create<false>()) 3550 , 3551 id_storage_layer_(new column::IdStorage()), 3552 type_storage_layer_( 3553 new column::StringStorage(string_pool(), &type_.vector())), 3554 jit_code_id_storage_layer_( 3555 new column::NumericStorage<ColumnType::jit_code_id::non_optional_stored_type>( 3556 &jit_code_id_.vector(), 3557 ColumnTypeHelper<ColumnType::jit_code_id::stored_type>::ToColumnType(), 3558 false)), 3559 v8_isolate_id_storage_layer_( 3560 new column::NumericStorage<ColumnType::v8_isolate_id::non_optional_stored_type>( 3561 &v8_isolate_id_.vector(), 3562 ColumnTypeHelper<ColumnType::v8_isolate_id::stored_type>::ToColumnType(), 3563 false)), 3564 pattern_storage_layer_( 3565 new column::StringStorage(string_pool(), &pattern_.vector())) 3566 { 3567 static_assert( 3568 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::jit_code_id::stored_type>( 3569 ColumnFlag::jit_code_id), 3570 "Column type and flag combination is not valid"); 3571 static_assert( 3572 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::v8_isolate_id::stored_type>( 3573 ColumnFlag::v8_isolate_id), 3574 "Column type and flag combination is not valid"); 3575 static_assert( 3576 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::pattern::stored_type>( 3577 ColumnFlag::pattern), 3578 "Column type and flag combination is not valid"); 3579 OnConstructionCompletedRegularConstructor( 3580 {id_storage_layer_,type_storage_layer_,jit_code_id_storage_layer_,v8_isolate_id_storage_layer_,pattern_storage_layer_}, 3581 {{},{},{},{},{}}); 3582 } 3583 ~V8RegexpCodeTable() override; 3584 Name()3585 static const char* Name() { return "__intrinsic_v8_regexp_code"; } 3586 ComputeStaticSchema()3587 static Table::Schema ComputeStaticSchema() { 3588 Table::Schema schema; 3589 schema.columns.emplace_back(Table::Schema::Column{ 3590 "id", SqlValue::Type::kLong, true, true, false, false}); 3591 schema.columns.emplace_back(Table::Schema::Column{ 3592 "type", SqlValue::Type::kString, false, false, false, false}); 3593 schema.columns.emplace_back(Table::Schema::Column{ 3594 "jit_code_id", ColumnType::jit_code_id::SqlValueType(), false, 3595 false, 3596 false, 3597 false}); 3598 schema.columns.emplace_back(Table::Schema::Column{ 3599 "v8_isolate_id", ColumnType::v8_isolate_id::SqlValueType(), false, 3600 false, 3601 false, 3602 false}); 3603 schema.columns.emplace_back(Table::Schema::Column{ 3604 "pattern", ColumnType::pattern::SqlValueType(), false, 3605 false, 3606 false, 3607 false}); 3608 return schema; 3609 } 3610 IterateRows()3611 ConstIterator IterateRows() const { 3612 return ConstIterator(this, Table::IterateRows()); 3613 } 3614 IterateRows()3615 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 3616 FilterToIterator(const Query & q)3617 ConstIterator FilterToIterator(const Query& q) const { 3618 return ConstIterator(this, QueryToIterator(q)); 3619 } 3620 FilterToIterator(const Query & q)3621 Iterator FilterToIterator(const Query& q) { 3622 return Iterator(this, QueryToIterator(q)); 3623 } 3624 ShrinkToFit()3625 void ShrinkToFit() { 3626 type_.ShrinkToFit(); 3627 jit_code_id_.ShrinkToFit(); 3628 v8_isolate_id_.ShrinkToFit(); 3629 pattern_.ShrinkToFit(); 3630 } 3631 3632 ConstRowReference operator[](uint32_t r) const { 3633 return ConstRowReference(this, r); 3634 } 3635 RowReference operator[](uint32_t r) { return RowReference(this, r); } 3636 ConstRowReference operator[](RowNumber r) const { 3637 return ConstRowReference(this, r.row_number()); 3638 } 3639 RowReference operator[](RowNumber r) { 3640 return RowReference(this, r.row_number()); 3641 } 3642 FindById(Id find_id)3643 std::optional<ConstRowReference> FindById(Id find_id) const { 3644 std::optional<uint32_t> row = id().IndexOf(find_id); 3645 return row ? std::make_optional(ConstRowReference(this, *row)) 3646 : std::nullopt; 3647 } 3648 FindById(Id find_id)3649 std::optional<RowReference> FindById(Id find_id) { 3650 std::optional<uint32_t> row = id().IndexOf(find_id); 3651 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 3652 } 3653 Insert(const Row & row)3654 IdAndRow Insert(const Row& row) { 3655 uint32_t row_number = row_count(); 3656 Id id = Id{row_number}; 3657 type_.Append(string_pool()->InternString(row.type())); 3658 mutable_jit_code_id()->Append(row.jit_code_id); 3659 mutable_v8_isolate_id()->Append(row.v8_isolate_id); 3660 mutable_pattern()->Append(row.pattern); 3661 UpdateSelfOverlayAfterInsert(); 3662 return IdAndRow{id, row_number, RowReference(this, row_number), 3663 RowNumber(row_number)}; 3664 } 3665 3666 3667 id()3668 const IdColumn<V8RegexpCodeTable::Id>& id() const { 3669 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 3670 } type()3671 const TypedColumn<StringPool::Id>& type() const { 3672 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 3673 } jit_code_id()3674 const TypedColumn<JitCodeTable::Id>& jit_code_id() const { 3675 return static_cast<const ColumnType::jit_code_id&>(columns()[ColumnIndex::jit_code_id]); 3676 } v8_isolate_id()3677 const TypedColumn<V8IsolateTable::Id>& v8_isolate_id() const { 3678 return static_cast<const ColumnType::v8_isolate_id&>(columns()[ColumnIndex::v8_isolate_id]); 3679 } pattern()3680 const TypedColumn<StringPool::Id>& pattern() const { 3681 return static_cast<const ColumnType::pattern&>(columns()[ColumnIndex::pattern]); 3682 } 3683 mutable_jit_code_id()3684 TypedColumn<JitCodeTable::Id>* mutable_jit_code_id() { 3685 return static_cast<ColumnType::jit_code_id*>( 3686 GetColumn(ColumnIndex::jit_code_id)); 3687 } mutable_v8_isolate_id()3688 TypedColumn<V8IsolateTable::Id>* mutable_v8_isolate_id() { 3689 return static_cast<ColumnType::v8_isolate_id*>( 3690 GetColumn(ColumnIndex::v8_isolate_id)); 3691 } mutable_pattern()3692 TypedColumn<StringPool::Id>* mutable_pattern() { 3693 return static_cast<ColumnType::pattern*>( 3694 GetColumn(ColumnIndex::pattern)); 3695 } 3696 3697 private: 3698 3699 3700 ColumnStorage<ColumnType::jit_code_id::stored_type> jit_code_id_; 3701 ColumnStorage<ColumnType::v8_isolate_id::stored_type> v8_isolate_id_; 3702 ColumnStorage<ColumnType::pattern::stored_type> pattern_; 3703 3704 RefPtr<column::StorageLayer> id_storage_layer_; 3705 RefPtr<column::StorageLayer> type_storage_layer_; 3706 RefPtr<column::StorageLayer> jit_code_id_storage_layer_; 3707 RefPtr<column::StorageLayer> v8_isolate_id_storage_layer_; 3708 RefPtr<column::StorageLayer> pattern_storage_layer_; 3709 3710 3711 }; 3712 3713 } // namespace perfetto 3714 3715 #endif // SRC_TRACE_PROCESSOR_TABLES_V8_TABLES_PY_H_ 3716