From 4e3cd07e47c70f9515160dbb0197fd5a83a4e50d Mon Sep 17 00:00:00 2001 From: Jeremy Koritzinsky Date: Thu, 17 Oct 2024 14:42:48 -0700 Subject: [PATCH] Change the DNMD APIs to act on single rows and bring other perf improvements from the CoreCLR + DNMD experiment to DNMD. Port of https://github.com/AaronRobinsonMSFT/DNMD/pull/55 --- src/native/dnmd/src/dnmd/access.c | 120 +++-- src/native/dnmd/src/dnmd/bytes.c | 115 ++++- src/native/dnmd/src/dnmd/deltas.c | 22 +- src/native/dnmd/src/dnmd/entry.c | 100 ++-- src/native/dnmd/src/dnmd/internal.h | 42 +- src/native/dnmd/src/dnmd/pdb_blobs.c | 6 +- src/native/dnmd/src/dnmd/query.c | 411 +++++++++-------- src/native/dnmd/src/dnmd/write.c | 428 ++++++++---------- src/native/dnmd/src/inc/dnmd.h | 33 +- src/native/dnmd/src/interfaces/dispenser.cpp | 2 +- src/native/dnmd/src/interfaces/hcorenum.cpp | 7 +- .../dnmd/src/interfaces/importhelpers.cpp | 218 ++++----- .../dnmd/src/interfaces/metadataemit.cpp | 420 ++++++++--------- .../dnmd/src/interfaces/metadataimport.cpp | 294 ++++++------ src/native/dnmd/src/interfaces/signatures.cpp | 67 +-- src/native/dnmd/src/interfaces/signatures.hpp | 119 ++++- 16 files changed, 1334 insertions(+), 1070 deletions(-) diff --git a/src/native/dnmd/src/dnmd/access.c b/src/native/dnmd/src/dnmd/access.c index 3a4da9ac66f24..479747f94e604 100644 --- a/src/native/dnmd/src/dnmd/access.c +++ b/src/native/dnmd/src/dnmd/access.c @@ -1,8 +1,7 @@ #include "internal.h" -bool create_access_context(mdcursor_t* cursor, col_index_t col_idx, uint32_t row_count, bool make_writable, access_cxt_t* acxt) +bool create_access_context(mdcursor_t* cursor, col_index_t col_idx, bool make_writable, access_cxt_t* acxt) { - assert(acxt != NULL); mdtable_t* table = CursorTable(cursor); if (table == NULL) return false; @@ -16,22 +15,90 @@ bool create_access_context(mdcursor_t* cursor, col_index_t col_idx, uint32_t row // Metadata row indexing is 1-based. row--; - acxt->table = table; - acxt->col_details = table->column_details[idx]; - // Compute the offset into the first row. - uint32_t offset = ExtractOffset(acxt->col_details); + mdtcol_t col = table->column_details[idx]; + uint32_t offset_to_table_data = row * table->row_size_bytes + ExtractOffset(col); +#ifndef NDEBUG + size_t len = (col & mdtc_b2) ? 2 : 4; + assert(offset_to_table_data + len <= table->data.size); +#endif + + acxt->table = table; + acxt->data = table->data.ptr + offset_to_table_data; + acxt->col_details = col; if (make_writable) { - acxt->writable_data = get_writable_table_data(table, make_writable); - acxt->writable_data = acxt->writable_data + (row * table->row_size_bytes) + offset; + acxt->writable_data = get_writable_table_data(table, make_writable) + offset_to_table_data; } else { acxt->writable_data = NULL; } - + return true; +} + +bool read_column_data(access_cxt_t* acxt, uint32_t* data) +{ + assert(acxt != NULL && acxt->data != NULL && data != NULL); + + uint8_t const* table_data = acxt->data; + + if ((acxt->col_details & mdtc_b4) == mdtc_b4) + { + size_t len = 4; + return read_u32(&table_data, &len, data); + } + else + { + size_t len = 2; + uint16_t value; + if (!read_u16(&table_data, &len, &value)) + return false; + + *data = value; + return true; + } +} + +bool write_column_data(access_cxt_t* acxt, uint32_t data) +{ + assert(acxt != NULL && acxt->writable_data != NULL); + uint8_t* table_data = acxt->writable_data; + if ((acxt->col_details & mdtc_b4) == mdtc_b4) + { + size_t len = 4; + return write_u32(&table_data, &len, data); + } + else + { + size_t len = 2; + return write_u16(&table_data, &len, (uint16_t)data); + } +} + +bool create_bulk_access_context(mdcursor_t* cursor, col_index_t col_idx, uint32_t row_count, bulk_access_cxt_t* acxt) +{ + assert(acxt != NULL); + mdtable_t* table = CursorTable(cursor); + if (table == NULL) + return false; + + uint32_t row = CursorRow(cursor); + if (row == 0 || row > table->row_count) + return false; + + uint8_t idx = col_to_index(col_idx, table); + assert(idx < table->column_count); + + // Metadata row indexing is 1-based. + row--; + acxt->table = table; + acxt->col_details = table->column_details[idx]; + + // Compute the offset into the first row. + uint32_t offset = ExtractOffset(acxt->col_details); + acxt->start = acxt->data = table->data.ptr + (row * table->row_size_bytes) + offset; // Compute the beginning of the row after the last valid row. @@ -50,40 +117,33 @@ bool create_access_context(mdcursor_t* cursor, col_index_t col_idx, uint32_t row return true; } -bool read_column_data(access_cxt_t* acxt, uint32_t* data) +bool read_column_data_and_advance(bulk_access_cxt_t* acxt, uint32_t* data) { assert(acxt != NULL && data != NULL); *data = 0; - if (acxt->writable_data != NULL) - acxt->writable_data += (acxt->col_details & mdtc_b2) ? 2 : 4; - - return (acxt->col_details & mdtc_b2) - ? read_u16(&acxt->data, &acxt->data_len, (uint16_t*)data) - : read_u32(&acxt->data, &acxt->data_len, data); -} - -bool write_column_data(access_cxt_t* acxt, uint32_t data) -{ - assert(acxt != NULL && acxt->writable_data != NULL); - - acxt->data += (acxt->col_details & mdtc_b2) ? 2 : 4; + if ((acxt->col_details & mdtc_b4) == mdtc_b4) + { + return read_u32(&acxt->data, &acxt->data_len, data); + } + else + { + uint16_t value; + if (!read_u16(&acxt->data, &acxt->data_len, &value)) + return false; - return (acxt->col_details & mdtc_b2) - ? write_u16(&acxt->writable_data, &acxt->data_len, (uint16_t)data) - : write_u32(&acxt->writable_data, &acxt->data_len, data); + *data = value; + return true; + } } -bool next_row(access_cxt_t* acxt) +bool next_row(bulk_access_cxt_t* acxt) { assert(acxt != NULL); // We will only traverse correctly if we've already read the column in this row. assert(acxt->data_len == 0); acxt->data += acxt->next_row_stride; - if (acxt->writable_data != NULL) - acxt->writable_data += acxt->next_row_stride; - // Restore the data length of the column data. acxt->data_len = acxt->data_len_col; return acxt->data < acxt->end; diff --git a/src/native/dnmd/src/dnmd/bytes.c b/src/native/dnmd/src/dnmd/bytes.c index a9c3a9f4b9d2b..811afe409c86d 100644 --- a/src/native/dnmd/src/dnmd/bytes.c +++ b/src/native/dnmd/src/dnmd/bytes.c @@ -129,6 +129,9 @@ bool read_i8(uint8_t const** data, size_t* data_len, int8_t* o) return read_le(data, data_len, o, sizeof(*o)); } +// MSVC doesn't optimize away the implementation on Little-Endian platforms, +// so manually provide an optimized implementation for MSVC. +#ifndef _MSC_VER bool read_u16(uint8_t const** data, size_t* data_len, uint16_t* o) { return read_le(data, data_len, o, sizeof(*o)); @@ -159,6 +162,75 @@ bool read_i64(uint8_t const** data, size_t* data_len, int64_t* o) return read_le(data, data_len, o, sizeof(*o)); } +#else +bool read_u16(uint8_t const** data, size_t* data_len, uint16_t* o) +{ + if (*data_len < sizeof(*o)) + return false; + + memcpy(o, *data, sizeof(*o)); + *data += sizeof(*o); + *data_len -= sizeof(*o); + return true; +} + +bool read_i16(uint8_t const** data, size_t* data_len, int16_t* o) +{ + if (*data_len < sizeof(*o)) + return false; + + memcpy(o, *data, sizeof(*o)); + *data += sizeof(*o); + *data_len -= sizeof(*o); + return true; +} + +bool read_u32(uint8_t const** data, size_t* data_len, uint32_t* o) +{ + if (*data_len < sizeof(*o)) + return false; + + memcpy(o, *data, sizeof(*o)); + *data += sizeof(*o); + *data_len -= sizeof(*o); + return true; +} + +bool read_i32(uint8_t const** data, size_t* data_len, int32_t* o) +{ + if (*data_len < sizeof(*o)) + return false; + + memcpy(o, *data, sizeof(*o)); + *data += sizeof(*o); + *data_len -= sizeof(*o); + return true; +} + +bool read_u64(uint8_t const** data, size_t* data_len, uint64_t* o) +{ + if (*data_len < sizeof(*o)) + return false; + + memcpy(o, *data, sizeof(*o)); + *data += sizeof(*o); + *data_len -= sizeof(*o); + return true; +} + +bool read_i64(uint8_t const** data, size_t* data_len, int64_t* o) +{ + if (*data_len < sizeof(*o)) + return false; + + memcpy(o, *data, sizeof(*o)); + *data += sizeof(*o); + *data_len -= sizeof(*o); + return true; +} + +#endif + bool write_u8(uint8_t** data, size_t* data_len, uint8_t o) { return write_le(data, data_len, o, sizeof(o)); @@ -208,35 +280,42 @@ bool decompress_u32(uint8_t const** data, size_t* data_len, uint32_t* o) assert(s != NULL); uint32_t val; - switch (*s & 0xc0) + + // The valid leading bits are 00, 10, and 110. + // All others are invalid. + // PERF: Check for 00 vs 10 first as we get better codegen + // on Intel/AMD processors (shorter instruction sequences and better branch prediction). + if ((*s & 0x80) == 0x00) { - case 0xc0: - if (*data_len < 4) + if (*data_len < 1) return false; - *data_len -= 4; - val = ((*s++ & 0x1f) << 24); - val |= (*s++ << 16); - val |= (*s++ << 8); - val |= *s++; - break; - - case 0x80: + *data_len -= 1; + val = *s++; + } + else if ((*s & 0xC0) == 0x80) + { if (*data_len < 2) return false; *data_len -= 2; val = ((*s++ & 0x3f) << 8); val |= *s++; - break; - - default: - if (*data_len < 1) + } + else if ((*s & 0xE0) == 0xC0) + { + if (*data_len < 4) return false; - *data_len -= 1; - val = *s++; - break; + *data_len -= 4; + val = ((*s++ & 0x1f) << 24); + val |= (*s++ << 16); + val |= (*s++ << 8); + val |= *s++; + } + else + { + return false; } *o = val; diff --git a/src/native/dnmd/src/dnmd/deltas.c b/src/native/dnmd/src/dnmd/deltas.c index dd8efee994e8c..f636592cf7a79 100644 --- a/src/native/dnmd/src/dnmd/deltas.c +++ b/src/native/dnmd/src/dnmd/deltas.c @@ -69,7 +69,7 @@ static bool initialize_token_map(mdtable_t* map, enc_token_map_t* token_map) for (uint32_t i = 0; i < map->row_count; (void)md_cursor_next(&map_cur), ++i) { mdToken tk; - if (1 != md_get_column_value_as_constant(map_cur, mdtENCMap_Token, 1, &tk)) + if (!md_get_column_value_as_constant(map_cur, mdtENCMap_Token, &tk)) return false; mdtable_id_t table_id = ExtractTokenType(RemoveRecordBit(tk)); @@ -122,7 +122,7 @@ static bool resolve_token(enc_token_map_t* token_map, mdToken referenced_token, for (uint32_t i = 0; i < token_map->map_cur_by_table[type].count; md_cursor_next(&map_record), i++) { mdToken mappedToken; - if (1 != md_get_column_value_as_constant(map_record, mdtENCMap_Token, 1, &mappedToken)) + if (!md_get_column_value_as_constant(map_record, mdtENCMap_Token, &mappedToken)) return false; assert((mdtable_id_t)ExtractTokenType(RemoveRecordBit(mappedToken)) == type); @@ -165,8 +165,8 @@ static bool process_log(mdcxt_t* cxt, mdcxt_t* delta) { mdToken tk; uint32_t op; - if (1 != md_get_column_value_as_constant(log_cur, mdtENCLog_Token, 1, &tk) - || 1 != md_get_column_value_as_constant(log_cur, mdtENCLog_Op, 1, &op)) + if (!md_get_column_value_as_constant(log_cur, mdtENCLog_Token, &tk) + || !md_get_column_value_as_constant(log_cur, mdtENCLog_Op, &op)) { return false; } @@ -343,11 +343,11 @@ bool merge_in_delta(mdcxt_t* cxt, mdcxt_t* delta) mdcursor_t delta_module = create_cursor(&delta->tables[mdtid_Module], 1); mdguid_t base_mvid; - if (1 != md_get_column_value_as_guid(base_module, mdtModule_Mvid, 1, &base_mvid)) + if (!md_get_column_value_as_guid(base_module, mdtModule_Mvid, &base_mvid)) return false; mdguid_t delta_mvid; - if (1 != md_get_column_value_as_guid(delta_module, mdtModule_Mvid, 1, &delta_mvid)) + if (!md_get_column_value_as_guid(delta_module, mdtModule_Mvid, &delta_mvid)) return false; // MVIDs must match between base and delta images. @@ -358,8 +358,8 @@ bool merge_in_delta(mdcxt_t* cxt, mdcxt_t* delta) // This ensures that we are applying deltas in order. mdguid_t enc_id; mdguid_t delta_enc_base_id; - if (1 != md_get_column_value_as_guid(base_module, mdtModule_EncId, 1, &enc_id) - || 1 != md_get_column_value_as_guid(delta_module, mdtModule_EncBaseId, 1, &delta_enc_base_id) + if (!md_get_column_value_as_guid(base_module, mdtModule_EncId, &enc_id) + || !md_get_column_value_as_guid(delta_module, mdtModule_EncBaseId, &delta_enc_base_id) || memcmp(&enc_id, &delta_enc_base_id, sizeof(mdguid_t)) != 0) { return false; @@ -382,10 +382,10 @@ bool merge_in_delta(mdcxt_t* cxt, mdcxt_t* delta) // We don't want to manipulate the heap sizes, so we'll pull the heap offset directly from the delta and use that // in the base image. uint32_t new_enc_base_id_offset; - if (1 != get_column_value_as_heap_offset(delta_module, mdtModule_EncId, 1, &new_enc_base_id_offset)) + if (!get_column_value_as_heap_offset(delta_module, mdtModule_EncId, &new_enc_base_id_offset)) return false; - if (1 != set_column_value_as_heap_offset(base_module, mdtModule_EncId, 1, &new_enc_base_id_offset)) + if (!set_column_value_as_heap_offset(base_module, mdtModule_EncId, new_enc_base_id_offset)) return false; return true; -} \ No newline at end of file +} diff --git a/src/native/dnmd/src/dnmd/entry.c b/src/native/dnmd/src/dnmd/entry.c index ffe71352f2c30..e7b1516d80a87 100644 --- a/src/native/dnmd/src/dnmd/entry.c +++ b/src/native/dnmd/src/dnmd/entry.c @@ -258,25 +258,25 @@ static bool initialize_minimal_table_rows(mdcxt_t* cxt) mdcursor_t module_cursor; if (!md_append_row(cxt, mdtid_Module, &module_cursor)) return false; - + // Set the Generation to 0 uint32_t generation = 0; - if (1 != md_set_column_value_as_constant(module_cursor, mdtModule_Generation, 1, &generation)) + if (!md_set_column_value_as_constant(module_cursor, mdtModule_Generation, generation)) return false; - + // Use the 0 index to specify the NULL guid as the guids for the image. uint32_t guid_heap_offset = 0; - if (1 != set_column_value_as_heap_offset(module_cursor, mdtModule_Mvid, 1, &guid_heap_offset) - || 1 != set_column_value_as_heap_offset(module_cursor, mdtModule_EncBaseId, 1, &guid_heap_offset) - || 1 != set_column_value_as_heap_offset(module_cursor, mdtModule_EncId, 1, &guid_heap_offset)) + if (!set_column_value_as_heap_offset(module_cursor, mdtModule_Mvid, guid_heap_offset) + || !set_column_value_as_heap_offset(module_cursor, mdtModule_EncBaseId, guid_heap_offset) + || !set_column_value_as_heap_offset(module_cursor, mdtModule_EncId, guid_heap_offset)) { return false; } char const* name = ""; - if (1 != md_set_column_value_as_utf8(module_cursor, mdtModule_Name, 1, &name)) + if (!md_set_column_value_as_utf8(module_cursor, mdtModule_Name, name)) return false; - + // Mark that we're done adding the Module row. md_commit_row_add(module_cursor); @@ -286,19 +286,19 @@ static bool initialize_minimal_table_rows(mdcxt_t* cxt) return false; uint32_t flags = 0; - if (1 != md_set_column_value_as_constant(global_type_cursor, mdtTypeDef_Flags, 1, &flags)) + if (!md_set_column_value_as_constant(global_type_cursor, mdtTypeDef_Flags, flags)) return false; - + char const* global_type_name = ""; // Defined in ECMA-335 II.10.8 - if (1 != md_set_column_value_as_utf8(global_type_cursor, mdtTypeDef_TypeName, 1, &global_type_name)) + if (!md_set_column_value_as_utf8(global_type_cursor, mdtTypeDef_TypeName, global_type_name)) return false; - + char const* namespace = ""; - if (1 != md_set_column_value_as_utf8(global_type_cursor, mdtTypeDef_TypeNamespace, 1, &namespace)) + if (!md_set_column_value_as_utf8(global_type_cursor, mdtTypeDef_TypeNamespace, namespace)) return false; - + mdToken nil_typedef = CreateTokenType(mdtid_TypeDef); - if (1 != md_set_column_value_as_token(global_type_cursor, mdtTypeDef_Extends, 1, &nil_typedef)) + if (!md_set_column_value_as_token(global_type_cursor, mdtTypeDef_Extends, nil_typedef)) return false; // Mark that we're done adding the TypeDef row. @@ -326,7 +326,7 @@ mdhandle_t md_create_new_handle() mdcxt_t* pcxt = allocate_full_context(&cxt); if (pcxt == NULL) return NULL; - + if (!initialize_minimal_table_rows(pcxt)) { free(pcxt); @@ -451,7 +451,7 @@ static bool dump_table_rows(mdtable_t* table) assert(table->column_count <= ARRAY_SIZE(to_get)); uint32_t raw_values[ARRAY_SIZE(to_get)]; -#define IF_NOT_ONE_REPORT_RAW(exp) if (1 != (exp)) { printf("Invalid (%u) [%#x]|", j, raw_values[j]); continue; } +#define IF_NOT_REPORT_RAW(exp) if (!(exp)) { printf("Invalid (%u) [%#x]|", j, raw_values[j]); continue; } #define IF_INVALID_BLOB_REPORT_RAW(parse_fn, handle_or_cursor, blob_type, result_buf, result_buf_len) \ { \ result_buf = NULL; \ @@ -478,12 +478,12 @@ static bool dump_table_rows(mdtable_t* table) { if (table->column_details[j] & mdtc_hstring) { - IF_NOT_ONE_REPORT_RAW(md_get_column_value_as_utf8(cursor, IDX(j), 1, &str)); + IF_NOT_REPORT_RAW(md_get_column_value_as_utf8(cursor, IDX(j), &str)); printf("'%s' [%#x]|", str, raw_values[j]); } else if (table->column_details[j] & mdtc_hguid) { - IF_NOT_ONE_REPORT_RAW(md_get_column_value_as_guid(cursor, IDX(j), 1, &guid)); + IF_NOT_REPORT_RAW(md_get_column_value_as_guid(cursor, IDX(j), &guid)); printf("{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x} [%#x]|", guid.data1, guid.data2, guid.data3, guid.data4[0], guid.data4[1], @@ -497,8 +497,8 @@ static bool dump_table_rows(mdtable_t* table) #ifdef DNMD_PORTABLE_PDB if (table->table_id == mdtid_Document && col == mdtDocument_Name) { - IF_NOT_ONE_REPORT_RAW(md_get_column_value_as_blob(cursor, col, 1, &blob, &blob_len)); - + IF_NOT_REPORT_RAW(md_get_column_value_as_blob(cursor, col, &blob, &blob_len)); + char* document_name; size_t name_len; IF_INVALID_BLOB_REPORT_RAW(md_parse_document_name, table->cxt, "DocumentName", document_name, name_len); @@ -508,8 +508,8 @@ static bool dump_table_rows(mdtable_t* table) } else if (table->table_id == mdtid_MethodDebugInformation && col == mdtMethodDebugInformation_SequencePoints) { - IF_NOT_ONE_REPORT_RAW(md_get_column_value_as_blob(cursor, col, 1, &blob, &blob_len)); - + IF_NOT_REPORT_RAW(md_get_column_value_as_blob(cursor, col, &blob, &blob_len)); + if (blob_len == 0) { printf("Empty SequencePoints: Offset: %zu (len: %u) [%#x]|", (blob - table->cxt->blob_heap.ptr), blob_len, raw_values[j]); @@ -556,7 +556,7 @@ static bool dump_table_rows(mdtable_t* table) assert(!"Invalid sequence point record kind."); } } - + printf(" } [%#x]|", raw_values[j]); free(sequence_points); @@ -564,7 +564,7 @@ static bool dump_table_rows(mdtable_t* table) } else if (table->table_id == mdtid_LocalConstant && col == mdtLocalConstant_Signature) { - IF_NOT_ONE_REPORT_RAW(md_get_column_value_as_blob(cursor, col, 1, &blob, &blob_len)); + IF_NOT_REPORT_RAW(md_get_column_value_as_blob(cursor, col, &blob, &blob_len)); md_local_constant_sig_t* local_constant_sig; size_t local_constant_sig_len; IF_INVALID_BLOB_REPORT_RAW(md_parse_local_constant_sig, table->cxt, "LocalConstantSig", local_constant_sig, local_constant_sig_len); @@ -591,14 +591,14 @@ static bool dump_table_rows(mdtable_t* table) assert(!"Invalid constant kind."); } printf("Value Offset: %zu (len: %zu) [%#x]|", local_constant_sig->value_blob - table->cxt->blob_heap.ptr, local_constant_sig->value_len, raw_values[j]); - + free(local_constant_sig); continue; } else if (table->table_id == mdtid_ImportScope && col == mdtImportScope_Imports) { - IF_NOT_ONE_REPORT_RAW(md_get_column_value_as_blob(cursor, col, 1, &blob, &blob_len)); - + IF_NOT_REPORT_RAW(md_get_column_value_as_blob(cursor, col, &blob, &blob_len)); + if (blob_len == 0) { printf("Empty Imports: Offset: %zu (len: %u) [%#x]|", (blob - table->cxt->blob_heap.ptr), blob_len, raw_values[j]); @@ -651,30 +651,30 @@ static bool dump_table_rows(mdtable_t* table) break; } } - + printf(" } [%#x]|", raw_values[j]); free(imports); continue; } #endif - IF_NOT_ONE_REPORT_RAW(md_get_column_value_as_blob(cursor, col, 1, &blob, &blob_len)); + IF_NOT_REPORT_RAW(md_get_column_value_as_blob(cursor, col, &blob, &blob_len)); printf("Offset: %zu (len: %u) [%#x]|", (blob - table->cxt->blob_heap.ptr), blob_len, raw_values[j]); } else if (table->column_details[j] & mdtc_hus) { - IF_NOT_ONE_REPORT_RAW(md_get_column_value_as_userstring(cursor, IDX(j), 1, &user_string)); + IF_NOT_REPORT_RAW(md_get_column_value_as_userstring(cursor, IDX(j), &user_string)); printf("UTF-16 string (%u bytes) [%#x]|", user_string.str_bytes, raw_values[j]); } else if (table->column_details[j] & (mdtc_idx_table | mdtc_idx_coded)) { - IF_NOT_ONE_REPORT_RAW(md_get_column_value_as_token(cursor, IDX(j), 1, &tk)); + IF_NOT_REPORT_RAW(md_get_column_value_as_token(cursor, IDX(j), &tk)); printf("0x%08x (mdToken) [%#x]|", tk, raw_values[j]); } else { assert(table->column_details[j] & mdtc_constant); - IF_NOT_ONE_REPORT_RAW(md_get_column_value_as_constant(cursor, IDX(j), 1, &constant)); + IF_NOT_REPORT_RAW(md_get_column_value_as_constant(cursor, IDX(j), &constant)); printf("0x%08x [%#x]|", constant, raw_values[j]); } } @@ -683,7 +683,7 @@ static bool dump_table_rows(mdtable_t* table) return false; } printf("\n"); -#undef IF_NOT_ONE_REPORT_RAW +#undef IF_NOT_REPORT_RAW #undef IF_INVALID_BLOB_REPORT_RAW return true; @@ -803,7 +803,7 @@ static size_t get_stream_header_and_contents_size(char const* heap_name, size_t static size_t get_table_stream_size(mdcxt_t* cxt) { // II.24.2.6 #~ stream - size_t const table_stream_header_size = + size_t const table_stream_header_size = + sizeof(uint32_t) // Reserved + sizeof(uint8_t) // MajorVersion + sizeof(uint8_t) // MinorVersion @@ -813,9 +813,9 @@ static size_t get_table_stream_size(mdcxt_t* cxt) + sizeof(uint64_t) // Sorted tables // Rows and Tables entries are both variable length and calculated below ; - + size_t save_size = table_stream_header_size; - + for (uint8_t i = 0; i < MDTABLE_MAX_COUNT; ++i) { if (cxt->tables[i].cxt != NULL && cxt->tables[i].row_count != 0) @@ -824,15 +824,15 @@ static size_t get_table_stream_size(mdcxt_t* cxt) save_size += cxt->tables[i].data.size; // Table data } } - + return save_size; } static size_t get_image_size(mdcxt_t* cxt) -{ +{ if (cxt->editor == NULL) return cxt->raw_metadata.size; - + // II.24.2.1 Metadata Root size size_t const image_header_size = sizeof(uint32_t) // Signature @@ -844,7 +844,7 @@ static size_t get_image_size(mdcxt_t* cxt) + sizeof(uint16_t) // Flags + sizeof(uint16_t) // Streams (number of streams) ; - + size_t save_size = image_header_size; if (cxt->blob_heap.size != 0) @@ -858,7 +858,7 @@ static size_t get_image_size(mdcxt_t* cxt) if (cxt->context_flags & mdc_minimal_delta) save_size += get_stream_header_and_contents_size("#JTD", 0); - + // All names of the tables stream are the same length, // so pick the one in the standard. save_size += get_stream_header_and_contents_size("#~", get_table_stream_size(cxt)); @@ -918,7 +918,7 @@ bool md_write_to_buffer(mdhandle_t handle, uint8_t* buffer, size_t* len) memcpy(buffer, cxt->raw_metadata.ptr, cxt->raw_metadata.size); return true; } - + if (buffer == NULL || full_buffer_len < image_size) { *len = image_size; @@ -934,16 +934,16 @@ bool md_write_to_buffer(mdhandle_t handle, uint8_t* buffer, size_t* len) { return false; } - + size_t version_str_len = strlen(cxt->version); uint32_t version_buf_len = align_to((uint32_t)version_str_len + 1, 4); if (!write_u32(&buffer, &remaining_buffer_len, (uint32_t)version_buf_len)) return false; - + if (remaining_buffer_len < version_buf_len) return false; - + memcpy(buffer, cxt->version, version_str_len + 1); // Pad the version string to a 4-byte boundary. memset(buffer + version_str_len + 1, 0, version_buf_len - version_str_len - 1); @@ -951,7 +951,7 @@ bool md_write_to_buffer(mdhandle_t handle, uint8_t* buffer, size_t* len) if (!write_u16(&buffer, &remaining_buffer_len, cxt->flags)) return false; - + uint16_t stream_count = 0; if (cxt->blob_heap.size != 0) stream_count++; @@ -983,7 +983,7 @@ bool md_write_to_buffer(mdhandle_t handle, uint8_t* buffer, size_t* len) valid_tables |= (1ULL << i); if (cxt->tables[i].is_sorted) sorted_tables |= (1ULL << i); - + // Indirect tables only exist in images that use the uncompresed stream. if (table_is_indirect_table((mdtable_id_t)i)) tables_stream_name = "#-"; @@ -992,7 +992,7 @@ bool md_write_to_buffer(mdhandle_t handle, uint8_t* buffer, size_t* len) // The tables stream is always included. stream_count++; - + if (!write_u16(&buffer, &remaining_buffer_len, stream_count)) return false; @@ -1011,7 +1011,7 @@ bool md_write_to_buffer(mdhandle_t handle, uint8_t* buffer, size_t* len) mddata_t offset_space; if (!write_stream_header("#JTD", 0, &offset_space, &buffer, &remaining_buffer_len)) return false; - + // Set the stream offset to the location of the stream header. // There's no content in this stream, but the offset must be valid. write_u32(&offset_space.ptr, &offset_space.size, (uint32_t)((uint8_t*)offset_space.ptr - buffer_start)); diff --git a/src/native/dnmd/src/dnmd/internal.h b/src/native/dnmd/src/dnmd/internal.h index 58b6c98072796..129236fa069cb 100644 --- a/src/native/dnmd/src/dnmd/internal.h +++ b/src/native/dnmd/src/dnmd/internal.h @@ -20,6 +20,18 @@ typedef size_t rsize_t; #define ARRAY_SIZE(a) (sizeof(a) / sizeof(*a)) +#ifndef NDEBUG +#define ASSERT_ASSUME(x) assert(x) +#elif defined(_MSC_VER) +#define ASSERT_ASSUME(x) __assume(x) +#elif defined(__clang__) +#define ASSERT_ASSUME(x) __builtin_assume(x) +#elif defined(__GNUC__) +#define ASSERT_ASSUME(x) do { if (!(x)) __builtin_unreachable(); } while (0) +#else +#define ASSERT_ASSUME(x) (void)(x) +#endif + // Mutable data typedef struct mddata__ { @@ -349,29 +361,39 @@ static col_index_t index_to_col(uint8_t idx, mdtable_id_t table_id) // Copy data from a cursor to one row to a cursor to another row. bool copy_cursor(mdcursor_t dest, mdcursor_t src); -// Raw table data access - +// Single column access typedef struct access_cxt__ { mdtable_t* table; mdtcol_t col_details; - uint8_t const* start; uint8_t const* data; uint8_t* writable_data; +} access_cxt_t; + +bool create_access_context(mdcursor_t* cursor, col_index_t col_idx, bool make_writable, access_cxt_t* rcxt); +bool write_column_data(access_cxt_t* acxt, uint32_t data); +bool read_column_data(access_cxt_t* acxt, uint32_t* data); + +// Raw bulk table access +typedef struct bulk_access_cxt__ +{ + mdtable_t* table; + mdtcol_t col_details; + uint8_t const* start; + uint8_t const* data; uint8_t const* end; size_t data_len; uint32_t data_len_col; uint32_t next_row_stride; -} access_cxt_t; +} bulk_access_cxt_t; -bool create_access_context(mdcursor_t* cursor, col_index_t col_idx, uint32_t row_count, bool make_writable, access_cxt_t* acxt); -bool read_column_data(access_cxt_t* acxt, uint32_t* data); -bool write_column_data(access_cxt_t* acxt, uint32_t data); -bool next_row(access_cxt_t* acxt); +bool create_bulk_access_context(mdcursor_t* cursor, col_index_t col_idx, uint32_t row_count, bulk_access_cxt_t* acxt); +bool read_column_data_and_advance(bulk_access_cxt_t* acxt, uint32_t* data); +bool next_row(bulk_access_cxt_t* acxt); // Internal functions used to read/write columns with minimal validation. -int32_t get_column_value_as_heap_offset(mdcursor_t c, col_index_t col_idx, uint32_t out_length, uint32_t* offset); -int32_t set_column_value_as_heap_offset(mdcursor_t c, col_index_t col_idx, uint32_t in_length, uint32_t* offset); +bool get_column_value_as_heap_offset(mdcursor_t c, col_index_t col_idx, uint32_t* offset); +bool set_column_value_as_heap_offset(mdcursor_t c, col_index_t col_idx, uint32_t offset); // // Manipulation of bits diff --git a/src/native/dnmd/src/dnmd/pdb_blobs.c b/src/native/dnmd/src/dnmd/pdb_blobs.c index 2f210849952a2..a604dd8835cf6 100644 --- a/src/native/dnmd/src/dnmd/pdb_blobs.c +++ b/src/native/dnmd/src/dnmd/pdb_blobs.c @@ -93,7 +93,7 @@ static uint32_t get_num_sequence_points(mdcursor_t method_debug_information, uin return UINT32_MAX; mdcursor_t document; - if (1 != md_get_column_value_as_cursor(method_debug_information, mdtMethodDebugInformation_Document, 1, &document)) + if (!md_get_column_value_as_cursor(method_debug_information, mdtMethodDebugInformation_Document, &document)) return UINT32_MAX; if (CursorNull(&document) && !decompress_u32(&blob, &blob_len, &ignored)) // header InitialDocument @@ -175,7 +175,7 @@ md_blob_parse_result_t md_parse_sequence_points( return mdbpr_InvalidBlob; mdcursor_t document; - if (1 != md_get_column_value_as_cursor(method_debug_information, mdtMethodDebugInformation_Document, 1, &document)) + if (!md_get_column_value_as_cursor(method_debug_information, mdtMethodDebugInformation_Document, &document)) return mdbpr_InvalidBlob; // Create a "null" cursor to default-initialize the document field. @@ -702,4 +702,4 @@ md_blob_parse_result_t md_parse_imports(mdhandle_t handle, uint8_t const* blob, } } return mdbpr_Success; -} \ No newline at end of file +} diff --git a/src/native/dnmd/src/dnmd/query.c b/src/native/dnmd/src/dnmd/query.c index d6b6a61c7fb95..03d9f430e04a3 100644 --- a/src/native/dnmd/src/dnmd/query.c +++ b/src/native/dnmd/src/dnmd/query.c @@ -124,95 +124,87 @@ bool md_walk_user_string_heap(mdhandle_t handle, mduserstringcursor_t* cursor, m return true; } -static int32_t get_column_value_as_token_or_cursor(mdcursor_t* c, uint32_t col_idx, uint32_t out_length, mdToken* tk, mdcursor_t* cursor) +static bool get_column_value_as_token_or_cursor(mdcursor_t* c, uint32_t col_idx, mdToken* tk, mdcursor_t* cursor) { - assert(c != NULL && out_length != 0 && (tk != NULL || cursor != NULL)); + assert(c != NULL && (tk != NULL || cursor != NULL)); access_cxt_t acxt; - if (!create_access_context(c, col_idx, out_length, false, &acxt)) - return -1; + if (!create_access_context(c, col_idx, false, &acxt)) + return false; // If this isn't an index column, then fail. if (!(acxt.col_details & (mdtc_idx_table | mdtc_idx_coded))) - return -1; + return false; uint32_t table_row; mdtable_id_t table_id; uint32_t raw; - int32_t read_in = 0; - do + + if (!read_column_data(&acxt, &raw)) + return false; + + if (acxt.col_details & mdtc_idx_table) { - if (!read_column_data(&acxt, &raw)) - return -1; + // The raw value is the row index into the table that + // is embedded in the column details. + table_row = RidFromToken(raw); + table_id = ExtractTable(acxt.col_details); + } + else + { + assert(acxt.col_details & mdtc_idx_coded); + if (!decompose_coded_index(raw, acxt.col_details, &table_id, &table_row)) + return false; + } - if (acxt.col_details & mdtc_idx_table) - { - // The raw value is the row index into the table that - // is embedded in the column details. - table_row = RidFromToken(raw); - table_id = ExtractTable(acxt.col_details); - } - else - { - assert(acxt.col_details & mdtc_idx_coded); - if (!decompose_coded_index(raw, acxt.col_details, &table_id, &table_row)) - return -1; - } + if (0 > table_id || table_id >= MDTABLE_MAX_COUNT) + return false; - if (0 > table_id || table_id >= MDTABLE_MAX_COUNT) - return -1; + mdtable_t* table; + if (tk != NULL) + { + *tk = CreateTokenType(table_id) | table_row; + } + else + { + // Returning a cursor means pointing directly into a table + // so we must validate the cursor is valid prior to creation. + table = type_to_table(acxt.table->cxt, table_id); + + // Indices into tables begin at 1 - see II.22. + // However, tables can contain a row ID of 0 to + // indicate "none" or point 1 past the end. + if (table_row > table->row_count + 1) + return false; - mdtable_t* table; - if (tk != NULL) + // Sometimes we can get an index into a table of 0 or 1 past the end + // of a table that does not exist. In that case, our table object here + // will be completely uninitialized. Set the table id so we can do operations + // that need a table id, like creating the table or getting a token. + if (table->table_id == 0 && table_id != 0) { - tk[read_in] = CreateTokenType(table_id) | table_row; + assert(table_row == 0 || table_row == 1); + table->table_id = table_id; } - else - { - // Returning a cursor means pointing directly into a table - // so we must validate the cursor is valid prior to creation. - table = type_to_table(acxt.table->cxt, table_id); - - // Indices into tables begin at 1 - see II.22. - // However, tables can contain a row ID of 0 to - // indicate "none" or point 1 past the end. - if (table_row > table->row_count + 1) - return -1; - - // Sometimes we can get an index into a table of 0 or 1 past the end - // of a table that does not exist. In that case, our table object here - // will be completely uninitialized. Set the table id so we can do operations - // that need a table id, like creating the table or getting a token. - if (table->table_id == 0 && table_id != 0) - { - assert(table_row == 0 || table_row == 1); - table->table_id = table_id; - } - assert(cursor != NULL); - cursor[read_in] = create_cursor(table, table_row); - } - read_in++; - } while (out_length > 1 && next_row(&acxt)); + assert(cursor != NULL); + *cursor = create_cursor(table, table_row); + } - return read_in; + return true; } -int32_t md_get_column_value_as_token(mdcursor_t c, col_index_t col_idx, uint32_t out_length, mdToken* tk) +bool md_get_column_value_as_token(mdcursor_t c, col_index_t col_idx, mdToken* tk) { - if (out_length == 0) - return 0; assert(tk != NULL); - return get_column_value_as_token_or_cursor(&c, col_idx, out_length, tk, NULL); + return get_column_value_as_token_or_cursor(&c, col_idx, tk, NULL); } -int32_t md_get_column_value_as_cursor(mdcursor_t c, col_index_t col_idx, uint32_t out_length, mdcursor_t* cursor) +bool md_get_column_value_as_cursor(mdcursor_t c, col_index_t col_idx, mdcursor_t* cursor) { - if (out_length == 0) - return 0; assert(cursor != NULL); - return get_column_value_as_token_or_cursor(&c, col_idx, out_length, NULL, cursor); + return get_column_value_as_token_or_cursor(&c, col_idx, NULL, cursor); } // Forward declaration @@ -224,7 +216,7 @@ static bool _validate_md_find_token_of_range_element(mdcursor_t expected, mdcurs bool md_get_column_value_as_range(mdcursor_t c, col_index_t col_idx, mdcursor_t* cursor, uint32_t* count) { assert(cursor != NULL); - if (1 != get_column_value_as_token_or_cursor(&c, col_idx, 1, NULL, cursor)) + if (!get_column_value_as_token_or_cursor(&c, col_idx, NULL, cursor)) return false; // Check if the cursor is null or the end of the table @@ -254,7 +246,7 @@ bool md_get_column_value_as_range(mdcursor_t c, col_index_t col_idx, mdcursor_t* // Examine the current table's next row value to find the // extrema of the target table range. mdcursor_t end; - if (1 != md_get_column_value_as_cursor(nextMaybe, col_idx, 1, &end)) + if (!md_get_column_value_as_cursor(nextMaybe, col_idx, &end)) return false; // The next row is a null cursor, which means we need to @@ -274,173 +266,174 @@ bool md_get_column_value_as_range(mdcursor_t c, col_index_t col_idx, mdcursor_t* return true; } -int32_t md_get_column_value_as_constant(mdcursor_t c, col_index_t col_idx, uint32_t out_length, uint32_t* constant) +bool md_get_column_value_as_constant(mdcursor_t c, col_index_t col_idx, uint32_t* constant) { - if (out_length == 0) - return 0; assert(constant != NULL); access_cxt_t acxt; - if (!create_access_context(&c, col_idx, out_length, false, &acxt)) - return -1; + if (!create_access_context(&c, col_idx, false, &acxt)) + return false; // If this isn't an constant column, then fail. if (!(acxt.col_details & mdtc_constant)) - return -1; + return false; - int32_t read_in = 0; - do - { - if (!read_column_data(&acxt, &constant[read_in])) - return -1; - read_in++; - } while (out_length > 1 && next_row(&acxt)); + if (!read_column_data(&acxt, constant)) + return false; - return read_in; + return true; } // Set a column value as an existing offset into a heap. -int32_t get_column_value_as_heap_offset(mdcursor_t c, col_index_t col_idx, uint32_t out_length, uint32_t* offset) +bool get_column_value_as_heap_offset(mdcursor_t c, col_index_t col_idx, uint32_t* offset) { - if (out_length == 0) - return 0; assert(offset != NULL); access_cxt_t acxt; - if (!create_access_context(&c, col_idx, out_length, false, &acxt)) - return -1; + if (!create_access_context(&c, col_idx, false, &acxt)) + return false; // If this isn't a heap index column, then fail. if (!(acxt.col_details & mdtc_idx_heap)) - return -1; + return false; mdstream_t const* heap = get_heap_by_id(acxt.table->cxt, ExtractHeapType(acxt.col_details)); if (heap == NULL) - return -1; - -#ifdef DEBUG_COLUMN_SORTING - validate_column_not_sorted(acxt.table, col_idx); -#endif - - int32_t read_in = 0; - do - { - if (!read_column_data(&acxt, &offset[read_in])) - return -1; + return false; - read_in++; - } while (out_length > 1 && next_row(&acxt)); + if (!read_column_data(&acxt, offset)) + return false; - return read_in; + return true; } -int32_t md_get_column_value_as_utf8(mdcursor_t c, col_index_t col_idx, uint32_t out_length, char const** str) +bool md_get_column_value_as_utf8(mdcursor_t c, col_index_t col_idx, char const** str) { - if (out_length == 0) - return 0; - assert(str != NULL); - access_cxt_t acxt; - if (!create_access_context(&c, col_idx, out_length, false, &acxt)) - return -1; + if (!create_access_context(&c, col_idx, false, &acxt)) + return false; - // If this isn't a #String column, then fail. + // If this isn't a heap index column, then fail. if (!(acxt.col_details & mdtc_hstring)) - return -1; + return false; uint32_t offset; - int32_t read_in = 0; - do - { - if (!read_column_data(&acxt, &offset)) - return -1; - if (!try_get_string(acxt.table->cxt, offset, &str[read_in])) - return -1; - read_in++; - } while (out_length > 1 && next_row(&acxt)); + if (!read_column_data(&acxt, &offset)) + return false; - return read_in; + if (!try_get_string(CursorTable(&c)->cxt, offset, str)) + return false; + + return true; } -int32_t md_get_column_value_as_userstring(mdcursor_t c, col_index_t col_idx, uint32_t out_length, mduserstring_t* strings) +bool md_get_column_value_as_userstring(mdcursor_t c, col_index_t col_idx, mduserstring_t* string) { - if (out_length == 0) - return 0; - assert(strings != NULL); + assert(string != NULL); access_cxt_t acxt; - if (!create_access_context(&c, col_idx, out_length, false, &acxt)) - return -1; + if (!create_access_context(&c, col_idx, false, &acxt)) + return false; - // If this isn't a #US column, then fail. + // If this isn't a heap index column, then fail. if (!(acxt.col_details & mdtc_hus)) - return -1; + return false; - size_t unused; uint32_t offset; - int32_t read_in = 0; - do - { - if (!read_column_data(&acxt, &offset)) - return -1; - if (!try_get_user_string(acxt.table->cxt, offset, &strings[read_in], &unused)) - return -1; - read_in++; - } while (out_length > 1 && next_row(&acxt)); + if (!read_column_data(&acxt, &offset)) + return false; - return read_in; + size_t next_offset; + if (!try_get_user_string(CursorTable(&c)->cxt, offset, string, &next_offset)) + return false; + + return true; } -int32_t md_get_column_value_as_blob(mdcursor_t c, col_index_t col_idx, uint32_t out_length, uint8_t const** blob, uint32_t* blob_len) +bool md_get_column_value_as_blob(mdcursor_t c, col_index_t col_idx, uint8_t const** blob, uint32_t* blob_len) { - if (out_length == 0) - return 0; assert(blob != NULL && blob_len != NULL); access_cxt_t acxt; - if (!create_access_context(&c, col_idx, out_length, false, &acxt)) - return -1; + if (!create_access_context(&c, col_idx, false, &acxt)) + return false; - // If this isn't a #Blob column, then fail. + // If this isn't a heap index column, then fail. if (!(acxt.col_details & mdtc_hblob)) - return -1; + return false; uint32_t offset; - int32_t read_in = 0; - do - { - if (!read_column_data(&acxt, &offset)) - return -1; - if (!try_get_blob(acxt.table->cxt, offset, &blob[read_in], &blob_len[read_in])) - return -1; - read_in++; - } while (out_length > 1 && next_row(&acxt)); + if (!read_column_data(&acxt, &offset)) + return false; - return read_in; + if (!try_get_blob(CursorTable(&c)->cxt, offset, blob, blob_len)) + return false; + + return true; } -int32_t md_get_column_value_as_guid(mdcursor_t c, col_index_t col_idx, uint32_t out_length, mdguid_t* guid) +bool md_get_column_value_as_guid(mdcursor_t c, col_index_t col_idx, mdguid_t* guid) { - if (out_length == 0) - return 0; assert(guid != NULL); access_cxt_t acxt; - if (!create_access_context(&c, col_idx, out_length, false, &acxt)) - return -1; + if (!create_access_context(&c, col_idx, false, &acxt)) + return false; - // If this isn't a #GUID column, then fail. + // If this isn't a heap index column, then fail. if (!(acxt.col_details & mdtc_hguid)) + return false; + + uint32_t offset; + if (!read_column_data(&acxt, &offset)) + return false; + + if (!try_get_guid(CursorTable(&c)->cxt, offset, guid)) + return false; + + return true; +} + +int32_t md_get_many_rows_column_value_as_token(mdcursor_t c, uint32_t col_idx, uint32_t out_length, mdToken* tk) +{ + assert(out_length != 0 && tk != NULL); + + bulk_access_cxt_t acxt; + if (!create_bulk_access_context(&c, col_idx, out_length, &acxt)) + return -1; + + // If this isn't an index column, then fail. + if (!(acxt.col_details & (mdtc_idx_table | mdtc_idx_coded))) return -1; - uint32_t idx; + uint32_t table_row; + mdtable_id_t table_id; + + uint32_t raw; int32_t read_in = 0; do { - if (!read_column_data(&acxt, &idx)) + if (!read_column_data_and_advance(&acxt, &raw)) return -1; - if (!try_get_guid(acxt.table->cxt, idx, &guid[read_in])) + + if (acxt.col_details & mdtc_idx_table) + { + // The raw value is the row index into the table that + // is embedded in the column details. + table_row = RidFromToken(raw); + table_id = ExtractTable(acxt.col_details); + } + else + { + assert(acxt.col_details & mdtc_idx_coded); + if (!decompose_coded_index(raw, acxt.col_details, &table_id, &table_row)) + return -1; + } + + if (0 > table_id || table_id >= MDTABLE_MAX_COUNT) return -1; + + tk[read_in] = CreateTokenType(table_id) | table_row; read_in++; } while (out_length > 1 && next_row(&acxt)); @@ -463,7 +456,7 @@ bool md_get_column_values_raw(mdcursor_t c, uint32_t values_length, bool* values continue; // Create access context for the next column value - if (!create_access_context(&c, i, 1, false, &acxt)) + if (!create_access_context(&c, i, false, &acxt)) return false; if (!read_column_data(&acxt, &values_raw[i])) @@ -506,14 +499,13 @@ static int32_t col_compare_2bytes(void const* key, void const* row, void* cxt) uint16_t const lhs = *(uint16_t*)key; uint16_t rhs = 0; size_t col_len = fcxt->data_len; - assert(col_len == 2); + ASSERT_ASSUME(col_len == 2); bool success = read_u16(&col_data, &col_len, &rhs); assert(success && col_len == 0); (void)success; - return (lhs == rhs) ? 0 - : (lhs < rhs) ? -1 - : 1; + // 0: equal, < 0: (lhs < rhs), > 0: (lhr > rhs) + return lhs - rhs; } static int32_t col_compare_4bytes(void const* key, void const* row, void* cxt) @@ -526,14 +518,13 @@ static int32_t col_compare_4bytes(void const* key, void const* row, void* cxt) uint32_t const lhs = *(uint32_t*)key; uint32_t rhs = 0; size_t col_len = fcxt->data_len; - assert(col_len == 4); + ASSERT_ASSUME(col_len == 4); bool success = read_u32(&col_data, &col_len, &rhs); assert(success && col_len == 0); (void)success; - return (lhs == rhs) ? 0 - : (lhs < rhs) ? -1 - : 1; + // 0: equal, < 0: (lhs < rhs), > 0: (lhr > rhs) + return lhs - rhs; } typedef int32_t(*md_bcompare_t)(void const* key, void const* row, void*); @@ -634,35 +625,65 @@ md_range_result_t md_find_range_from_cursor(mdcursor_t begin, col_index_t idx, u find_cxt_t fcxt; // This was already created and validated when the row was found. // We assume the data is still valid. - (void)create_find_context(table, idx, &fcxt); - md_bcompare_t cmp_func = fcxt.data_len == 2 ? col_compare_2bytes : col_compare_4bytes; + bool success = create_find_context(table, idx, &fcxt); + ASSERT_ASSUME(success); // A valid value was found, so we are at least within the range. // Now find the extrema. *start = found; - while (cursor_move_no_checks(start, -1)) + mdcursor_t end = found; + + // PERF: Split this into an if/else instead of using a function pointer + // to avoid CFG overhead in MSVC. + if (fcxt.data_len == 2) { - // Since we are moving backwards in a sorted column, - // the value should match or be greater. - res = cmp_func(&value, cursor_to_row_bytes(start), &fcxt); - assert(res >= 0); - if (res > 0) + while (cursor_move_no_checks(start, -1)) { - // Move forward to the start. - (void)cursor_move_no_checks(start, 1); - break; + // Since we are moving backwards in a sorted column, + // the value should match or be greater. + res = col_compare_2bytes(&value, cursor_to_row_bytes(start), &fcxt); + assert(res >= 0); + if (res > 0) + { + // Move forward to the start. + (void)cursor_move_no_checks(start, 1); + break; + } + } + while (cursor_move_no_checks(&end, 1) && !CursorEnd(&end)) + { + // Since we are moving forwards in a sorted column, + // the value should match or be less. + res = col_compare_2bytes(&value, cursor_to_row_bytes(&end), &fcxt); + assert(res <= 0); + if (res < 0) + break; } } - - mdcursor_t end = found; - while (cursor_move_no_checks(&end, 1) && !CursorEnd(&end)) + else { - // Since we are moving forwards in a sorted column, - // the value should match or be less. - res = cmp_func(&value, cursor_to_row_bytes(&end), &fcxt); - assert(res <= 0); - if (res < 0) - break; + while (cursor_move_no_checks(start, -1)) + { + // Since we are moving backwards in a sorted column, + // the value should match or be greater. + res = col_compare_4bytes(&value, cursor_to_row_bytes(start), &fcxt); + assert(res >= 0); + if (res > 0) + { + // Move forward to the start. + (void)cursor_move_no_checks(start, 1); + break; + } + } + while (cursor_move_no_checks(&end, 1) && !CursorEnd(&end)) + { + // Since we are moving forwards in a sorted column, + // the value should match or be less. + res = col_compare_4bytes(&value, cursor_to_row_bytes(&end), &fcxt); + assert(res <= 0); + if (res < 0) + break; + } } // Compute the row delta @@ -820,7 +841,7 @@ static bool find_range_element(mdcursor_t element, mdcursor_t* tgt_cursor) { pos = tmp; if (!cursor_move_no_checks(&tmp, 1) - || 1 != md_get_column_value_as_token(tmp, tgt_col, 1, &tmp_tk)) + || !md_get_column_value_as_token(tmp, tgt_col, &tmp_tk)) { break; } @@ -844,9 +865,9 @@ static bool find_range_element(mdcursor_t element, mdcursor_t* tgt_cursor) *tgt_cursor = pos; return true; case mdtid_Event: - return md_get_column_value_as_cursor(pos, mdtEventMap_Parent, 1, tgt_cursor); + return md_get_column_value_as_cursor(pos, mdtEventMap_Parent, tgt_cursor); case mdtid_Property: - return md_get_column_value_as_cursor(pos, mdtPropertyMap_Parent, 1, tgt_cursor); + return md_get_column_value_as_cursor(pos, mdtPropertyMap_Parent, tgt_cursor); default: assert(!"Invalid table ID"); return false; @@ -896,5 +917,5 @@ bool md_resolve_indirect_cursor(mdcursor_t c, mdcursor_t* target) return true; } - return 1 == md_get_column_value_as_cursor(c, col_idx, 1, target); + return md_get_column_value_as_cursor(c, col_idx, target); } diff --git a/src/native/dnmd/src/dnmd/write.c b/src/native/dnmd/src/dnmd/write.c index 2821d3da3f763..41cd4889eb243 100644 --- a/src/native/dnmd/src/dnmd/write.c +++ b/src/native/dnmd/src/dnmd/write.c @@ -8,7 +8,7 @@ static bool is_row_sorted_with_next_row(md_key_info_t const* keys, uint8_t count col_index_t key_col = index_to_col(keys[i].index, table_id); access_cxt_t row_acxt; - if (!create_access_context(&row, key_col, 1, false, &row_acxt)) + if (!create_access_context(&row, key_col, false, &row_acxt)) return false; // Key columns can only be constant, index into a table, or a coded token index. @@ -16,7 +16,7 @@ static bool is_row_sorted_with_next_row(md_key_info_t const* keys, uint8_t count assert(row_acxt.col_details & (mdtc_constant | mdtc_idx_table | mdtc_idx_coded)); access_cxt_t next_acxt; - if (!create_access_context(&next_row, key_col, 1, false, &next_acxt)) + if (!create_access_context(&next_row, key_col, false, &next_acxt)) return false; uint32_t row_value; @@ -34,21 +34,19 @@ static bool is_row_sorted_with_next_row(md_key_info_t const* keys, uint8_t count return true; } -static int32_t set_column_value_as_token_or_cursor(mdcursor_t c, uint32_t col_idx, mdToken const* tk, mdcursor_t const* cursor, uint32_t in_length) +static bool set_column_value_as_token_or_cursor(mdcursor_t c, uint32_t col_idx, mdToken const* tk, mdcursor_t const* cursor) { - assert(in_length != 0 && (tk != NULL || cursor != NULL)); - access_cxt_t acxt; - if (!create_access_context(&c, col_idx, in_length, true, &acxt)) - return -1; + if (!create_access_context(&c, col_idx, true, &acxt)) + return false; // If we can't write on the underlying table, then fail. if (acxt.writable_data == NULL) - return -1; + return false; // If this isn't an index column, then fail. if (!(acxt.col_details & (mdtc_idx_table | mdtc_idx_coded))) - return -1; + return false; uint8_t key_count = 0; uint8_t key_idx = UINT8_MAX; @@ -71,90 +69,84 @@ static int32_t set_column_value_as_token_or_cursor(mdcursor_t c, uint32_t col_id } } - int32_t written = 0; - do + mdToken token; + if (tk != NULL) { - mdToken token; - if (tk != NULL) - { - token = tk[written]; - } - else - { - if (!md_cursor_to_token(cursor[written], &token)) - return -1; - } + token = *tk; + } + else + { + if (!md_cursor_to_token(*cursor, &token)) + return false; + } #ifdef DNMD_PORTABLE_PDB + { + uint32_t table_row = RidFromToken(token); + mdtable_id_t table_id = ExtractTokenType(token); + if (table_id < mdtid_FirstPdb) { - uint32_t table_row = RidFromToken(token); - mdtable_id_t table_id = ExtractTokenType(token); - if (table_id < mdtid_FirstPdb) - { - if (!update_referenced_type_system_table_row_count(acxt.table->cxt, table_id, table_row)) - return -1; - } + if (!update_referenced_type_system_table_row_count(acxt.table->cxt, table_id, table_row)) + return false; } + } #endif - uint32_t raw; - if (acxt.col_details & mdtc_idx_table) - { - uint32_t table_row = RidFromToken(token); - mdtable_id_t table_id = ExtractTokenType(token); - // The raw value is the row index into the table that - // is embedded in the column details. - // Return an error if the provided token does not point to the right table. - if (ExtractTable(acxt.col_details) != table_id) - return -1; - raw = table_row; - } - else - { - assert(acxt.col_details & mdtc_idx_coded); - if (!compose_coded_index(token, acxt.col_details, &raw)) - return -1; - } + uint32_t raw; + if (acxt.col_details & mdtc_idx_table) + { + uint32_t table_row = RidFromToken(token); + mdtable_id_t table_id = ExtractTokenType(token); + // The raw value is the row index into the table that + // is embedded in the column details. + // Return an error if the provided token does not point to the right table. + if (ExtractTable(acxt.col_details) != table_id) + return false; + raw = table_row; + } + else + { + assert(acxt.col_details & mdtc_idx_coded); + if (!compose_coded_index(token, acxt.col_details, &raw)) + return false; + } - if (!write_column_data(&acxt, raw)) - return -1; + if (!write_column_data(&acxt, raw)) + return false; - // If the column we are writing to is a key of a sorted column, then we need to validate that it is sorted correctly. - // We'll validate against the previous row here and then validate against the next row after we've written all of the columns that we will write. - if (key_idx != UINT8_MAX) + // If the column we are writing to is a key of a sorted column, then we need to validate that it is sorted correctly. + // We'll validate against the previous row here and then validate against the next row after we've written all of the columns that we will write. + if (key_idx != UINT8_MAX) + { + assert(keys != NULL && key_idx < key_count); + mdcursor_t current_row = c; + bool success = md_cursor_next(¤t_row); + assert(success); + (void)success; + mdcursor_t prior_row = current_row; + if (md_cursor_move(&prior_row, -1) && !CursorNull(&prior_row)) { - assert(keys != NULL && key_idx < key_count); - mdcursor_t current_row = c; - bool success = md_cursor_move(¤t_row, written); - assert(success); - (void)success; - mdcursor_t prior_row = current_row; - if (md_cursor_move(&prior_row, -1) && !CursorNull(&prior_row)) + // If we have a prior row, then we need to check if we're sorted with respect to it. + if (!is_row_sorted_with_next_row(keys, key_count, acxt.table->table_id, prior_row, current_row)) { - // If we have a prior row, then we need to check if we're sorted with respect to it. - if (!is_row_sorted_with_next_row(keys, key_count, acxt.table->table_id, prior_row, current_row)) - { - // If we're not sorted, then invalidate key_idx to avoid checking if we're sorted for future row writes. - // We won't go from unsorted to sorted. - acxt.table->is_sorted = false; - key_idx = UINT8_MAX; - } + // If we're not sorted, then invalidate key_idx to avoid checking if we're sorted for future row writes. + // We won't go from unsorted to sorted. + acxt.table->is_sorted = false; + key_idx = UINT8_MAX; } } - - written++; - } while (in_length > 1 && next_row(&acxt)); + } // Validate that the last row we wrote is sorted with respect to any following rows. if (key_idx != UINT8_MAX) { assert(keys != NULL && key_idx < key_count); mdcursor_t current_row = c; - bool success = md_cursor_move(¤t_row, written); + bool success = md_cursor_next(¤t_row); assert(success); (void)success; mdcursor_t next_row = current_row; - if (md_cursor_move(&next_row, 1) && !CursorEnd(&next_row)) + if (md_cursor_next(&next_row) && !CursorEnd(&next_row)) { // If we have a prior row, then we need to check if we're sorted with respect to it. if (!is_row_sorted_with_next_row(keys, key_count, acxt.table->table_id, current_row, next_row)) @@ -167,36 +159,28 @@ static int32_t set_column_value_as_token_or_cursor(mdcursor_t c, uint32_t col_id } } - return written; + return true; } -int32_t md_set_column_value_as_token(mdcursor_t c, col_index_t col, uint32_t in_length, mdToken const* tk) +bool md_set_column_value_as_token(mdcursor_t c, col_index_t col, mdToken tk) { - if (tk == NULL || in_length == 0) - return -1; - return set_column_value_as_token_or_cursor(c, col_to_index(col, CursorTable(&c)), tk, NULL, in_length); + return set_column_value_as_token_or_cursor(c, col_to_index(col, CursorTable(&c)), &tk, NULL); } -int32_t md_set_column_value_as_cursor(mdcursor_t c, col_index_t col, uint32_t in_length, mdcursor_t const* cursor) +bool md_set_column_value_as_cursor(mdcursor_t c, col_index_t col, mdcursor_t cursor) { - if (cursor == NULL || in_length == 0) - return -1; - return set_column_value_as_token_or_cursor(c, col_to_index(col, CursorTable(&c)), NULL, cursor, in_length); + return set_column_value_as_token_or_cursor(c, col_to_index(col, CursorTable(&c)), NULL, &cursor); } -int32_t md_set_column_value_as_constant(mdcursor_t c, col_index_t col_idx, uint32_t in_length, uint32_t const* constant) +bool md_set_column_value_as_constant(mdcursor_t c, col_index_t col_idx, uint32_t constant) { - if (in_length == 0) - return 0; - assert(constant != NULL); - access_cxt_t acxt; - if (!create_access_context(&c, col_idx, in_length, true, &acxt)) - return -1; + if (!create_access_context(&c, col_idx, true, &acxt)) + return false; // If this isn't an constant column, then fail. if (!(acxt.col_details & mdtc_constant)) - return -1; + return false; uint8_t key_count = 0; uint8_t key_idx = UINT8_MAX; @@ -219,44 +203,38 @@ int32_t md_set_column_value_as_constant(mdcursor_t c, col_index_t col_idx, uint3 } } - int32_t written = 0; - do - { - if (!write_column_data(&acxt, constant[written])) - return -1; + if (!write_column_data(&acxt, constant)) + return false; - // If the column we are writing to is a key of a sorted column, then we need to validate that it is sorted correctly. - // We'll validate against the previous row here and then validate against the next row after we've written all of the columns that we will write. - if (key_idx != UINT8_MAX) + // If the column we are writing to is a key of a sorted column, then we need to validate that it is sorted correctly. + // We'll validate against the previous row here and then validate against the next row after we've written all of the columns that we will write. + if (key_idx != UINT8_MAX) + { + assert(keys != NULL && key_idx < key_count); + mdcursor_t current_row = c; + bool success = md_cursor_next(¤t_row); + assert(success); + (void)success; + mdcursor_t prior_row = current_row; + if (md_cursor_move(&prior_row, -1) && !CursorNull(&prior_row)) { - assert(keys != NULL && key_idx < key_count); - mdcursor_t current_row = c; - bool success = md_cursor_move(¤t_row, written); - assert(success); - (void)success; - mdcursor_t prior_row = current_row; - if (md_cursor_move(&prior_row, -1) && !CursorNull(&prior_row)) + // If we have a prior row, then we need to check if we're sorted with respect to it. + if (!is_row_sorted_with_next_row(keys, key_count, acxt.table->table_id, prior_row, current_row)) { - // If we have a prior row, then we need to check if we're sorted with respect to it. - if (!is_row_sorted_with_next_row(keys, key_count, acxt.table->table_id, prior_row, current_row)) - { - // If we're not sorted, then invalidate key_idx to avoid checking if we're sorted for future row writes. - // We won't go from unsorted to sorted. - acxt.table->is_sorted = false; - key_idx = UINT8_MAX; - } + // If we're not sorted, then invalidate key_idx to avoid checking if we're sorted for future row writes. + // We won't go from unsorted to sorted. + acxt.table->is_sorted = false; + key_idx = UINT8_MAX; } } - - written++; - } while (in_length > 1 && next_row(&acxt)); + } // Validate that the last row we wrote is sorted with respect to any following rows. if (key_idx != UINT8_MAX) { assert(keys != NULL && key_idx < key_count); mdcursor_t current_row = c; - bool success = md_cursor_move(¤t_row, written); + bool success = md_cursor_next(¤t_row); assert(success); (void)success; mdcursor_t next_row = current_row; @@ -273,7 +251,7 @@ int32_t md_set_column_value_as_constant(mdcursor_t c, col_index_t col_idx, uint3 } } - return written; + return true; } #ifdef DEBUG_COLUMN_SORTING @@ -290,169 +268,127 @@ static void validate_column_is_not_key(mdtable_t const* table, col_index_t col_i #endif // Set a column value as an existing offset into a heap. -int32_t set_column_value_as_heap_offset(mdcursor_t c, col_index_t col_idx, uint32_t in_length, uint32_t* offset) +bool set_column_value_as_heap_offset(mdcursor_t c, col_index_t col_idx, uint32_t offset) { - if (in_length == 0) - return 0; - access_cxt_t acxt; - if (!create_access_context(&c, col_idx, in_length, true, &acxt)) - return -1; + if (!create_access_context(&c, col_idx, true, &acxt)) + return false; // If this isn't a heap index column, then fail. if (!(acxt.col_details & mdtc_idx_heap)) - return -1; + return false; mdstream_t const* heap = get_heap_by_id(acxt.table->cxt, ExtractHeapType(acxt.col_details)); if (heap == NULL) - return -1; + return false; #ifdef DEBUG_COLUMN_SORTING validate_column_is_not_key(acxt.table, col_idx); #endif - int32_t written = 0; - do - { - if (!write_column_data(&acxt, offset[written])) - return -1; - written++; - } while (in_length > 1 && next_row(&acxt)); + if (!write_column_data(&acxt, offset)) + return false; - return written; + return true; } -int32_t md_set_column_value_as_utf8(mdcursor_t c, col_index_t col_idx, uint32_t in_length, char const* const* str) +bool md_set_column_value_as_utf8(mdcursor_t c, col_index_t col_idx, char const* str) { - if (in_length == 0) - return 0; - access_cxt_t acxt; - if (!create_access_context(&c, col_idx, in_length, true, &acxt)) - return -1; + if (!create_access_context(&c, col_idx, true, &acxt)) + return false; // If this isn't an constant column, then fail. if (!(acxt.col_details & mdtc_hstring)) - return -1; + return false; #ifdef DEBUG_COLUMN_SORTING validate_column_is_not_key(acxt.table, col_idx); #endif - int32_t written = 0; - do - { - uint32_t heap_offset; - heap_offset = add_to_string_heap(CursorTable(&c)->cxt, str[written]); + uint32_t heap_offset; + heap_offset = add_to_string_heap(acxt.table->cxt, str); - if (heap_offset == 0 && str[written][0] != '\0') - return -1; + if (heap_offset == 0 && str[0] != '\0') + return false; - if (!write_column_data(&acxt, heap_offset)) - return -1; - written++; - } while (in_length > 1 && next_row(&acxt)); + if (!write_column_data(&acxt, heap_offset)) + return false; - return written; + return true; } -int32_t md_set_column_value_as_blob(mdcursor_t c, col_index_t col_idx, uint32_t in_length, uint8_t const* const* blob, uint32_t const* blob_len) +// TODO: These functions should not call set_column_value_as_heap_offset. +bool md_set_column_value_as_blob(mdcursor_t c, col_index_t col_idx, uint8_t const* blob, uint32_t blob_len) { - if (in_length == 0) - return 0; - access_cxt_t acxt; - if (!create_access_context(&c, col_idx, in_length, true, &acxt)) - return -1; + if (!create_access_context(&c, col_idx, true, &acxt)) + return false; // If this isn't an constant column, then fail. if (!(acxt.col_details & mdtc_hblob)) - return -1; + return false; #ifdef DEBUG_COLUMN_SORTING validate_column_is_not_key(acxt.table, col_idx); #endif - int32_t written = 0; - do - { - uint32_t heap_offset = add_to_blob_heap(CursorTable(&c)->cxt, blob[written], blob_len[written]); + uint32_t heap_offset = add_to_blob_heap(acxt.table->cxt, blob, blob_len); - if (heap_offset == 0 && blob_len[written] != 0) - return -1; + if (heap_offset == 0 && blob_len > 0) + return false; - if (!write_column_data(&acxt, heap_offset)) - return -1; - written++; - } while (in_length > 1 && next_row(&acxt)); + if (!write_column_data(&acxt, heap_offset)) + return false; - return written; + return true; } -int32_t md_set_column_value_as_guid(mdcursor_t c, col_index_t col_idx, uint32_t in_length, mdguid_t const* guid) +bool md_set_column_value_as_guid(mdcursor_t c, col_index_t col_idx, mdguid_t guid) { - if (in_length == 0) - return 0; - access_cxt_t acxt; - if (!create_access_context(&c, col_idx, in_length, true, &acxt)) - return -1; + if (!create_access_context(&c, col_idx, true, &acxt)) + return false; // If this isn't an constant column, then fail. if (!(acxt.col_details & mdtc_hguid)) - return -1; + return false; #ifdef DEBUG_COLUMN_SORTING validate_column_is_not_key(acxt.table, col_idx); #endif - int32_t written = 0; - do - { - uint32_t index = add_to_guid_heap(CursorTable(&c)->cxt, guid[written]); - - if (index == 0 && memcmp(&guid[written], &empty_guid, sizeof(mdguid_t)) != 0) - return -1; + uint32_t index = add_to_guid_heap(acxt.table->cxt, guid); - if (!write_column_data(&acxt, index)) - return -1; - written++; - } while (in_length > 1 && next_row(&acxt)); + if (index == 0 && memcmp(&guid, &empty_guid, sizeof(mdguid_t)) != 0) + return false; - return written; + return set_column_value_as_heap_offset(c, col_idx, index); } -int32_t md_set_column_value_as_userstring(mdcursor_t c, col_index_t col_idx, uint32_t in_length, char16_t const* const* userstring) +bool md_set_column_value_as_userstring(mdcursor_t c, col_index_t col_idx, char16_t const* userstring) { - if (in_length == 0) - return 0; - access_cxt_t acxt; - if (!create_access_context(&c, col_idx, in_length, true, &acxt)) - return -1; + if (!create_access_context(&c, col_idx, true, &acxt)) + return false; // If this isn't an constant column, then fail. - if (!(acxt.col_details & mdtc_hblob)) - return -1; + if (!(acxt.col_details & mdtc_hus)) + return false; #ifdef DEBUG_COLUMN_SORTING validate_column_is_not_key(acxt.table, col_idx); #endif - int32_t written = 0; - do - { - uint32_t index = add_to_user_string_heap(CursorTable(&c)->cxt, userstring[written]); + uint32_t index = add_to_user_string_heap(CursorTable(&c)->cxt, userstring); - if (index == 0 && userstring[written][0] != 0) - return -1; + if (index == 0 && userstring[0] != 0) + return false; - if (!write_column_data(&acxt, index)) - return -1; - written++; - } while (in_length > 1 && next_row(&acxt)); + if (!write_column_data(&acxt, index)) + return false; - return written; + return true; } int32_t update_shifted_row_references(mdcursor_t* c, uint32_t count, uint8_t col_index, mdtable_id_t updated_table, uint32_t original_starting_table_index, uint32_t new_starting_table_index) @@ -469,7 +405,7 @@ int32_t update_shifted_row_references(mdcursor_t* c, uint32_t count, uint8_t col for (uint32_t i = 0; i < count; i++, md_cursor_next(c)) { mdToken tk; - if (1 != md_get_column_value_as_token(*c, col, 1, &tk)) + if (!md_get_column_value_as_token(*c, col, &tk)) return -1; if ((mdtable_id_t)ExtractTokenType(tk) == updated_table) @@ -479,7 +415,7 @@ int32_t update_shifted_row_references(mdcursor_t* c, uint32_t count, uint8_t col { rid += diff; tk = TokenFromRid(rid, CreateTokenType(updated_table)); - if (1 != md_set_column_value_as_token(*c, col, 1, &tk)) + if (!md_set_column_value_as_token(*c, col, tk)) return -1; } } @@ -518,16 +454,16 @@ static bool copy_cursor_column(mdcursor_t dest, mdcursor_t src, col_index_t idx) switch (table->column_details[idx] & mdtc_categorymask) { case mdtc_constant: - if (1 != md_get_column_value_as_constant(src, idx, 1, &column_value)) + if (!md_get_column_value_as_constant(src, idx, &column_value)) return false; break; case mdtc_idx_coded: case mdtc_idx_table: - if (1 != md_get_column_value_as_token(src, idx, 1, &column_value)) + if (!md_get_column_value_as_token(src, idx, &column_value)) return false; break; case mdtc_idx_heap: - if (1 != get_column_value_as_heap_offset(src, idx, 1, &column_value)) + if (!get_column_value_as_heap_offset(src, idx, &column_value)) return false; break; default: @@ -538,16 +474,16 @@ static bool copy_cursor_column(mdcursor_t dest, mdcursor_t src, col_index_t idx) switch (dest_table->column_details[idx] & mdtc_categorymask) { case mdtc_constant: - if (1 != md_set_column_value_as_constant(dest, idx, 1, &column_value)) + if (!md_set_column_value_as_constant(dest, idx, column_value)) return false; break; case mdtc_idx_coded: case mdtc_idx_table: - if (1 != md_set_column_value_as_token(dest, idx, 1, &column_value)) + if (!md_set_column_value_as_token(dest, idx, column_value)) return false; break; case mdtc_idx_heap: - if (1 != set_column_value_as_heap_offset(dest, idx, 1, &column_value)) + if (set_column_value_as_heap_offset(dest, idx, column_value)) return false; break; default: @@ -561,10 +497,24 @@ static bool set_column_as_end_of_table_cursor(mdcursor_t c, col_index_t col_idx) { mdtable_t* table = CursorTable(&c); assert((table->column_details[col_to_index(col_idx, table)] & mdtc_categorymask) == mdtc_idx_table); - mdtable_id_t target_table = ExtractTable(table->column_details[col_to_index(col_idx, table)]); - mdcursor_t end_of_table = create_cursor(&table->cxt->tables[target_table], table->cxt->tables[target_table].row_count + 1); + mdtable_id_t target_table_id = ExtractTable(table->column_details[col_to_index(col_idx, table)]); + mdtable_t* target_table = &table->cxt->tables[target_table_id]; + + mdcursor_t end_of_table; + if (target_table->cxt == NULL) + { + if (!initialize_new_table_details(table->cxt, target_table_id, target_table)) + { + return false; + } + end_of_table = create_cursor(target_table, 0); + } + else + { + end_of_table = create_cursor(target_table, target_table->row_count + 1); + } - return md_set_column_value_as_cursor(c, col_idx, 1, &end_of_table); + return md_set_column_value_as_cursor(c, col_idx, end_of_table); } static bool initialize_list_columns(mdcursor_t c) @@ -694,7 +644,7 @@ static bool add_new_row_to_list(mdcursor_t list_owner, col_index_t list_col, mdc uint32_t count; if (!md_get_column_value_as_range(list_owner, list_col, &range, &count)) return false; - + // Assert that the insertion location is in our range or points to the first row of the next range. // For a zero-length range, row_to_insert_before will be the first row of the next range, so we need to account for that. assert(CursorTable(&range) == CursorTable(&row_to_insert_before)); @@ -716,7 +666,7 @@ static bool add_new_row_to_list(mdcursor_t list_owner, col_index_t list_col, mdc if (!md_insert_row_before(row_to_insert_before, &new_indirection_row)) return false; - if (!md_set_column_value_as_cursor(new_indirection_row, index_to_col(0, CursorTable(&row_to_insert_before)->table_id), 1, new_row)) + if (!md_set_column_value_as_cursor(new_indirection_row, index_to_col(0, CursorTable(&row_to_insert_before)->table_id), *new_row)) return false; if (count == 0 || CursorRow(&range) == CursorRow(&row_to_insert_before)) @@ -725,7 +675,7 @@ static bool add_new_row_to_list(mdcursor_t list_owner, col_index_t list_col, mdc // If the start of our range is the same as the row we're inserting before, then we're inserting at the start of the list. // In both of these cases, we need to update the parent's row column to point to the newly inserted row. // Otherwise, this element would be associated with the entry before the parent row. - if (!md_set_column_value_as_cursor(list_owner, list_col, 1, &new_indirection_row)) + if (!md_set_column_value_as_cursor(list_owner, list_col, new_indirection_row)) return false; } @@ -748,13 +698,13 @@ static bool add_new_row_to_list(mdcursor_t list_owner, col_index_t list_col, mdc // otherwise the list will be inconsistent. mdcursor_t parent_row = list_owner; mdcursor_t current_cursor_value; - if (1 != md_get_column_value_as_cursor(list_owner, list_col, 1, ¤t_cursor_value)) + if (!md_get_column_value_as_cursor(list_owner, list_col, ¤t_cursor_value)) return false; while (md_cursor_move(&parent_row, -1)) { mdcursor_t prev_cursor_value; - if (1 != md_get_column_value_as_cursor(parent_row, list_col, 1, &prev_cursor_value)) + if (!md_get_column_value_as_cursor(parent_row, list_col, &prev_cursor_value)) return false; if (CursorRow(&prev_cursor_value) != CursorRow(¤t_cursor_value)) @@ -768,7 +718,7 @@ static bool add_new_row_to_list(mdcursor_t list_owner, col_index_t list_col, mdc for (; CursorRow(&parent_row) <= CursorRow(&list_owner); md_cursor_next(&parent_row)) { - if (1 != md_set_column_value_as_cursor(parent_row, list_col, 1, new_row)) + if (!md_set_column_value_as_cursor(parent_row, list_col, *new_row)) return false; } } @@ -825,7 +775,7 @@ bool md_add_new_row_to_list(mdcursor_t list_owner, col_index_t list_col, mdcurso // Move the cursor just past the end of the range. We'll insert a row at the end of the range. if (!md_cursor_move(&row_after_range, count)) return false; - + return add_new_row_to_list(list_owner, list_col, row_after_range, new_row); } @@ -874,11 +824,11 @@ bool md_add_new_row_to_sorted_list(mdcursor_t list_owner, col_index_t list_col, mdcursor_t target_row; if (!md_resolve_indirect_cursor(row_to_check, &target_row)) return false; - + uint32_t current_sort_col_value; - if (1 != md_get_column_value_as_constant(target_row, sort_order_col, 1, ¤t_sort_col_value)) + if (!md_get_column_value_as_constant(target_row, sort_order_col, ¤t_sort_col_value)) return false; - + if (current_sort_col_value <= sort_col_value) { // row_to_check is the first row with a sort order less than or equal to the new row. @@ -902,12 +852,12 @@ bool md_add_new_row_to_sorted_list(mdcursor_t list_owner, col_index_t list_col, if (!add_new_row_to_list(list_owner, list_col, row_to_insert_before, new_row)) return false; - + // Now that we've added the new column to the list, set the sort order column to the provided value to // ensure the sort is accurate. - if (1 != md_set_column_value_as_constant(*new_row, sort_order_col, 1, &sort_col_value)) + if (!md_set_column_value_as_constant(*new_row, sort_order_col, sort_col_value)) return false; - + return true; } @@ -1012,7 +962,7 @@ bool sort_list_by_column(mdcursor_t parent, col_index_t list_col, col_index_t co } uint32_t sequence_number; - if (1 != md_get_column_value_as_constant(target, col, 1, &sequence_number)) + if (!md_get_column_value_as_constant(target, col, &sequence_number)) { free(cursor_order_buffer); assert(!"Failed to read constant column from target cursor"); @@ -1077,12 +1027,18 @@ bool sort_list_by_column(mdcursor_t parent, col_index_t list_col, col_index_t co col_index_t indirect_col = index_to_col(0, CursorTable(&range)->table_id); - if (next_index != md_set_column_value_as_cursor(range, indirect_col, (uint32_t)next_index, correct_cursor_order)) + mdcursor_t to_update = range; + for (uint32_t i = 0; i < count; i++) { - free(cursor_order_buffer); - return false; + if (!md_set_column_value_as_cursor(to_update, indirect_col, correct_cursor_order[i])) + { + free(cursor_order_buffer); + return false; + } + + md_cursor_next(&to_update); } free(cursor_order_buffer); return true; -} \ No newline at end of file +} diff --git a/src/native/dnmd/src/inc/dnmd.h b/src/native/dnmd/src/inc/dnmd.h index 19e5a9ea0e2b1..bc156ab457caf 100644 --- a/src/native/dnmd/src/inc/dnmd.h +++ b/src/native/dnmd/src/inc/dnmd.h @@ -441,20 +441,23 @@ typedef enum } col_index_t; // Query row's column values -// The returned number represents the number of valid cursor(s) for indexing. -int32_t md_get_column_value_as_token(mdcursor_t c, col_index_t col_idx, uint32_t out_length, mdToken* tk); -int32_t md_get_column_value_as_cursor(mdcursor_t c, col_index_t col_idx, uint32_t out_length, mdcursor_t* cursor); +bool md_get_column_value_as_token(mdcursor_t c, col_index_t col_idx, mdToken* tk); +bool md_get_column_value_as_cursor(mdcursor_t c, col_index_t col_idx, mdcursor_t* cursor); // Resolve the column to a cursor and a range based on the run/list pattern in tables. // The run continues to the smaller of: // * the last row of the target table // * the next run in the target table, found by inspecting the column value of the next row in the current table. // See md_find_token_of_range_element() for mapping elements in the other direction. bool md_get_column_value_as_range(mdcursor_t c, col_index_t col_idx, mdcursor_t* cursor, uint32_t* count); -int32_t md_get_column_value_as_constant(mdcursor_t c, col_index_t col_idx, uint32_t out_length, uint32_t* constant); -int32_t md_get_column_value_as_utf8(mdcursor_t c, col_index_t col_idx, uint32_t out_length, char const** str); -int32_t md_get_column_value_as_userstring(mdcursor_t c, col_index_t col_idx, uint32_t out_length, mduserstring_t* strings); -int32_t md_get_column_value_as_blob(mdcursor_t c, col_index_t col_idx, uint32_t out_length, uint8_t const** blob, uint32_t* blob_len); -int32_t md_get_column_value_as_guid(mdcursor_t c, col_index_t col_idx, uint32_t out_length, mdguid_t* guid); +bool md_get_column_value_as_constant(mdcursor_t c, col_index_t col_idx, uint32_t* constant); +bool md_get_column_value_as_utf8(mdcursor_t c, col_index_t col_idx, char const** str); +bool md_get_column_value_as_userstring(mdcursor_t c, col_index_t col_idx, mduserstring_t* strings); +bool md_get_column_value_as_blob(mdcursor_t c, col_index_t col_idx, uint8_t const** blob, uint32_t* blob_len); +bool md_get_column_value_as_guid(mdcursor_t c, col_index_t col_idx, mdguid_t* guid); + +// Read a table or coded index column from multiple rows and return the values as an array of tokens. +// The number of rows read is returned by the function. A '-1' return value indicates an error. +int32_t md_get_many_rows_column_value_as_token(mdcursor_t c, col_index_t col_idx, uint32_t out_length, mdToken* tokens); // Return the raw column values for the row. Unlike the md_get_column_value_as_* APIs, the returned values // are in their raw form. @@ -497,13 +500,13 @@ bool md_resolve_indirect_cursor(mdcursor_t c, mdcursor_t* target); // Set row's column values // The returned number represents the number of rows updated. -int32_t md_set_column_value_as_token(mdcursor_t c, col_index_t col, uint32_t in_length, mdToken const* tk); -int32_t md_set_column_value_as_cursor(mdcursor_t c, col_index_t col, uint32_t in_length, mdcursor_t const* cursor); -int32_t md_set_column_value_as_constant(mdcursor_t c, col_index_t col_idx, uint32_t in_length, uint32_t const* constant); -int32_t md_set_column_value_as_utf8(mdcursor_t c, col_index_t col_idx, uint32_t in_length, char const* const* str); -int32_t md_set_column_value_as_blob(mdcursor_t c, col_index_t col_idx, uint32_t in_length, uint8_t const* const* blob, uint32_t const* blob_len); -int32_t md_set_column_value_as_guid(mdcursor_t c, col_index_t col_idx, uint32_t in_length, mdguid_t const* guid); -int32_t md_set_column_value_as_userstring(mdcursor_t c, col_index_t col_idx, uint32_t in_length, char16_t const* const* userstring); +bool md_set_column_value_as_token(mdcursor_t c, col_index_t col, mdToken tk); +bool md_set_column_value_as_cursor(mdcursor_t c, col_index_t col, mdcursor_t cursor); +bool md_set_column_value_as_constant(mdcursor_t c, col_index_t col_idx, uint32_t constant); +bool md_set_column_value_as_utf8(mdcursor_t c, col_index_t col_idx, char const* str); +bool md_set_column_value_as_blob(mdcursor_t c, col_index_t col_idx, uint8_t const* blob, uint32_t blob_len); +bool md_set_column_value_as_guid(mdcursor_t c, col_index_t col_idx, mdguid_t guid); +bool md_set_column_value_as_userstring(mdcursor_t c, col_index_t col_idx, char16_t const* userstring); // Create a new row logically before the row specified by the cursor. // If the given row is in a table that is a target of a list column, this function will return false. diff --git a/src/native/dnmd/src/interfaces/dispenser.cpp b/src/native/dnmd/src/interfaces/dispenser.cpp index 8ba8275dd06c7..a3a14b865cb63 100644 --- a/src/native/dnmd/src/interfaces/dispenser.cpp +++ b/src/native/dnmd/src/interfaces/dispenser.cpp @@ -85,7 +85,7 @@ namespace if (!minipal_guid_v4_create(reinterpret_cast(&mvid))) return E_FAIL; - if (1 != md_set_column_value_as_guid(moduleCursor, mdtModule_Mvid, 1, &mvid)) + if (!md_set_column_value_as_guid(moduleCursor, mdtModule_Mvid, mvid)) return E_OUTOFMEMORY; minipal::com_ptr obj; diff --git a/src/native/dnmd/src/interfaces/hcorenum.cpp b/src/native/dnmd/src/interfaces/hcorenum.cpp index abebfa7709d7d..79a799d610a28 100644 --- a/src/native/dnmd/src/interfaces/hcorenum.cpp +++ b/src/native/dnmd/src/interfaces/hcorenum.cpp @@ -226,8 +226,13 @@ HRESULT HCORENUMImpl::ReadOneToken(mdToken& rToken, uint32_t& count) noexcept if (_type == HCORENUMType::Table) { - if (!md_cursor_to_token(currData->Table.Current, &rToken)) + mdcursor_t current; + if (!md_resolve_indirect_cursor(currData->Table.Current, ¤t)) + return CLDB_E_FILE_CORRUPT; + + if (!md_cursor_to_token(current, &rToken)) return S_FALSE; + (void)md_cursor_next(&currData->Table.Current); } else diff --git a/src/native/dnmd/src/interfaces/importhelpers.cpp b/src/native/dnmd/src/interfaces/importhelpers.cpp index 95cd6d4ef7d16..98328d42336ee 100644 --- a/src/native/dnmd/src/interfaces/importhelpers.cpp +++ b/src/native/dnmd/src/interfaces/importhelpers.cpp @@ -41,7 +41,7 @@ namespace if (!md_create_cursor(image, mdtid_Module, &c, &count)) return CLDB_E_FILE_CORRUPT; - if (1 != md_get_column_value_as_guid(c, mdtModule_Mvid, 1, mvid)) + if (!md_get_column_value_as_guid(c, mdtModule_Mvid, mvid)) return CLDB_E_FILE_CORRUPT; return S_OK; @@ -287,13 +287,13 @@ namespace UNREFERENCED_PARAMETER(buildNumber); UNREFERENCED_PARAMETER(revisionNumber); uint32_t temp; - if (1 != md_get_column_value_as_constant(c, mdtAssemblyRef_MajorVersion, 1, &temp)) + if (!md_get_column_value_as_constant(c, mdtAssemblyRef_MajorVersion, &temp)) return CLDB_E_FILE_CORRUPT; if (temp != majorVersion) return S_FALSE; - if (1 != md_get_column_value_as_constant(c, mdtAssemblyRef_MinorVersion, 1, &temp)) + if (!md_get_column_value_as_constant(c, mdtAssemblyRef_MinorVersion, &temp)) return CLDB_E_FILE_CORRUPT; if (temp != minorVersion) @@ -312,24 +312,24 @@ namespace [](mdcursor_t c, uint32_t majorVersion, uint32_t minorVersion, uint32_t buildNumber, uint32_t revisionNumber) { uint32_t temp; - if (1 != md_get_column_value_as_constant(c, mdtAssemblyRef_MajorVersion, 1, &temp)) + if (!md_get_column_value_as_constant(c, mdtAssemblyRef_MajorVersion, &temp)) return CLDB_E_FILE_CORRUPT; if (temp != majorVersion) return S_FALSE; - if (1 != md_get_column_value_as_constant(c, mdtAssemblyRef_MinorVersion, 1, &temp)) + if (!md_get_column_value_as_constant(c, mdtAssemblyRef_MinorVersion, &temp)) return CLDB_E_FILE_CORRUPT; if (temp != minorVersion) return S_FALSE; - if (1 != md_get_column_value_as_constant(c, mdtAssemblyRef_BuildNumber, 1, &temp)) + if (!md_get_column_value_as_constant(c, mdtAssemblyRef_BuildNumber, &temp)) return CLDB_E_FILE_CORRUPT; if (temp != buildNumber) return S_FALSE; - if (1 != md_get_column_value_as_constant(c, mdtAssemblyRef_RevisionNumber, 1, &temp)) + if (!md_get_column_value_as_constant(c, mdtAssemblyRef_RevisionNumber, &temp)) return CLDB_E_FILE_CORRUPT; if (temp != revisionNumber) @@ -394,13 +394,13 @@ namespace continue; char const* tempString; - if (1 != md_get_column_value_as_utf8(c, mdtAssemblyRef_Name, 1, &tempString)) + if (!md_get_column_value_as_utf8(c, mdtAssemblyRef_Name, &tempString)) return CLDB_E_FILE_CORRUPT; if (std::strcmp(tempString, name) != 0) continue; - if (1 != md_get_column_value_as_utf8(c, mdtAssemblyRef_Culture, 1, &tempString)) + if (!md_get_column_value_as_utf8(c, mdtAssemblyRef_Culture, &tempString)) return CLDB_E_FILE_CORRUPT; if (std::strcmp(tempString, culture) != 0) @@ -408,7 +408,7 @@ namespace uint8_t const* tempBlob; uint32_t tempBlobLength; - if (1 != md_get_column_value_as_blob(c, mdtAssemblyRef_PublicKeyOrToken, 1, &tempBlob, &tempBlobLength)) + if (!md_get_column_value_as_blob(c, mdtAssemblyRef_PublicKeyOrToken, &tempBlob, &tempBlobLength)) return CLDB_E_FILE_CORRUPT; // If our source has a public key or token, we can only match against an AssemblyRef that has a public key or token. @@ -422,7 +422,7 @@ namespace StrongNameToken refPublicKeyToken; uint32_t assemblyRefFlags; - if (1 != md_get_column_value_as_constant(c, mdtAssemblyRef_Flags, 1, &assemblyRefFlags)) + if (!md_get_column_value_as_constant(c, mdtAssemblyRef_Flags, &assemblyRefFlags)) return CLDB_E_FILE_CORRUPT; if (IsAfPublicKey(flags) == IsAfPublicKey(assemblyRefFlags)) @@ -475,36 +475,36 @@ namespace { HRESULT hr; uint32_t flags; - if (1 != md_get_column_value_as_constant(sourceAssemblyRef, mdtAssemblyRef_Flags, 1, &flags)) + if (!md_get_column_value_as_constant(sourceAssemblyRef, mdtAssemblyRef_Flags, &flags)) return E_FAIL; uint8_t const* publicKey; uint32_t publicKeyLength; - if (1 != md_get_column_value_as_blob(sourceAssemblyRef, mdtAssemblyRef_PublicKeyOrToken, 1, &publicKey, &publicKeyLength)) + if (!md_get_column_value_as_blob(sourceAssemblyRef, mdtAssemblyRef_PublicKeyOrToken, &publicKey, &publicKeyLength)) return E_FAIL; uint32_t majorVersion; - if (1 != md_get_column_value_as_constant(sourceAssemblyRef, mdtAssemblyRef_MajorVersion, 1, &majorVersion)) + if (!md_get_column_value_as_constant(sourceAssemblyRef, mdtAssemblyRef_MajorVersion, &majorVersion)) return E_FAIL; uint32_t minorVersion; - if (1 != md_get_column_value_as_constant(sourceAssemblyRef, mdtAssemblyRef_MinorVersion, 1, &minorVersion)) + if (!md_get_column_value_as_constant(sourceAssemblyRef, mdtAssemblyRef_MinorVersion, &minorVersion)) return E_FAIL; uint32_t buildNumber; - if (1 != md_get_column_value_as_constant(sourceAssemblyRef, mdtAssemblyRef_BuildNumber, 1, &buildNumber)) + if (!md_get_column_value_as_constant(sourceAssemblyRef, mdtAssemblyRef_BuildNumber, &buildNumber)) return E_FAIL; uint32_t revisionNumber; - if (1 != md_get_column_value_as_constant(sourceAssemblyRef, mdtAssemblyRef_RevisionNumber, 1, &revisionNumber)) + if (!md_get_column_value_as_constant(sourceAssemblyRef, mdtAssemblyRef_RevisionNumber, &revisionNumber)) return E_FAIL; char const* assemblyName; - if (1 != md_get_column_value_as_utf8(sourceAssemblyRef, mdtAssemblyRef_Name, 1, &assemblyName)) + if (!md_get_column_value_as_utf8(sourceAssemblyRef, mdtAssemblyRef_Name, &assemblyName)) return E_FAIL; char const* assemblyCulture; - if (1 != md_get_column_value_as_utf8(sourceAssemblyRef, mdtAssemblyRef_Culture, 1, &assemblyCulture)) + if (!md_get_column_value_as_utf8(sourceAssemblyRef, mdtAssemblyRef_Culture, &assemblyCulture)) return E_FAIL; RETURN_IF_FAILED(FindAssemblyRef( @@ -530,28 +530,28 @@ namespace onRowAdded(assemblyRef); - if (1 != md_set_column_value_as_constant(assemblyRef, mdtAssemblyRef_MajorVersion, 1, &majorVersion)) + if (!md_set_column_value_as_constant(assemblyRef, mdtAssemblyRef_MajorVersion, majorVersion)) return E_FAIL; - if (1 != md_set_column_value_as_constant(assemblyRef, mdtAssemblyRef_MinorVersion, 1, &minorVersion)) + if (!md_set_column_value_as_constant(assemblyRef, mdtAssemblyRef_MinorVersion, minorVersion)) return E_FAIL; - if (1 != md_set_column_value_as_constant(assemblyRef, mdtAssemblyRef_BuildNumber, 1, &buildNumber)) + if (!md_set_column_value_as_constant(assemblyRef, mdtAssemblyRef_BuildNumber, buildNumber)) return E_FAIL; - if (md_set_column_value_as_constant(assemblyRef, mdtAssemblyRef_RevisionNumber, 1, &revisionNumber)) + if (md_set_column_value_as_constant(assemblyRef, mdtAssemblyRef_RevisionNumber, revisionNumber)) return E_FAIL; - if (1 != md_set_column_value_as_constant(assemblyRef, mdtAssemblyRef_Flags, 1, &flags)) + if (!md_set_column_value_as_constant(assemblyRef, mdtAssemblyRef_Flags, flags)) return E_FAIL; - if (1 != md_set_column_value_as_utf8(assemblyRef, mdtAssemblyRef_Name, 1, &assemblyName)) + if (!md_set_column_value_as_utf8(assemblyRef, mdtAssemblyRef_Name, assemblyName)) return E_FAIL; - if (1 != md_set_column_value_as_utf8(assemblyRef, mdtAssemblyRef_Culture, 1, &assemblyCulture)) + if (!md_set_column_value_as_utf8(assemblyRef, mdtAssemblyRef_Culture, assemblyCulture)) return E_FAIL; - if (1 != md_set_column_value_as_blob(assemblyRef, mdtAssemblyRef_PublicKeyOrToken, 1, &publicKey, &publicKeyLength)) + if (!md_set_column_value_as_blob(assemblyRef, mdtAssemblyRef_PublicKeyOrToken, publicKey, publicKeyLength)) return E_FAIL; *targetAssembly = assemblyRef; @@ -595,12 +595,12 @@ namespace { HRESULT hr; uint32_t flags; - if (1 != md_get_column_value_as_constant(sourceAssembly, mdtAssembly_Flags, 1, &flags)) + if (!md_get_column_value_as_constant(sourceAssembly, mdtAssembly_Flags, &flags)) return E_FAIL; uint8_t const* publicKey; uint32_t publicKeyLength; - if (1 != md_get_column_value_as_blob(sourceAssembly, mdtAssembly_PublicKey, 1, &publicKey, &publicKeyLength)) + if (!md_get_column_value_as_blob(sourceAssembly, mdtAssembly_PublicKey, &publicKey, &publicKeyLength)) return E_FAIL; span publicKeyTokenSpan; @@ -618,27 +618,27 @@ namespace } uint32_t majorVersion; - if (1 != md_get_column_value_as_constant(sourceAssembly, mdtAssembly_MajorVersion, 1, &majorVersion)) + if (!md_get_column_value_as_constant(sourceAssembly, mdtAssembly_MajorVersion, &majorVersion)) return E_FAIL; uint32_t minorVersion; - if (1 != md_get_column_value_as_constant(sourceAssembly, mdtAssembly_MinorVersion, 1, &minorVersion)) + if (!md_get_column_value_as_constant(sourceAssembly, mdtAssembly_MinorVersion, &minorVersion)) return E_FAIL; uint32_t buildNumber; - if (1 != md_get_column_value_as_constant(sourceAssembly, mdtAssembly_BuildNumber, 1, &buildNumber)) + if (!md_get_column_value_as_constant(sourceAssembly, mdtAssembly_BuildNumber, &buildNumber)) return E_FAIL; uint32_t revisionNumber; - if (1 != md_get_column_value_as_constant(sourceAssembly, mdtAssembly_RevisionNumber, 1, &revisionNumber)) + if (!md_get_column_value_as_constant(sourceAssembly, mdtAssembly_RevisionNumber, &revisionNumber)) return E_FAIL; char const* assemblyName; - if (1 != md_get_column_value_as_utf8(sourceAssembly, mdtAssembly_Name, 1, &assemblyName)) + if (!md_get_column_value_as_utf8(sourceAssembly, mdtAssembly_Name, &assemblyName)) return E_FAIL; char const* assemblyCulture; - if (1 != md_get_column_value_as_utf8(sourceAssembly, mdtAssembly_Culture, 1, &assemblyCulture)) + if (!md_get_column_value_as_utf8(sourceAssembly, mdtAssembly_Culture, &assemblyCulture)) return E_FAIL; RETURN_IF_FAILED(FindAssemblyRef( @@ -664,35 +664,35 @@ namespace onRowAdded(assemblyRef); - if (1 != md_set_column_value_as_constant(assemblyRef, mdtAssemblyRef_MajorVersion, 1, &majorVersion)) + if (!md_set_column_value_as_constant(assemblyRef, mdtAssemblyRef_MajorVersion, majorVersion)) return E_FAIL; - if (1 != md_set_column_value_as_constant(assemblyRef, mdtAssemblyRef_MinorVersion, 1, &minorVersion)) + if (!md_set_column_value_as_constant(assemblyRef, mdtAssemblyRef_MinorVersion, minorVersion)) return E_FAIL; - if (1 != md_set_column_value_as_constant(assemblyRef, mdtAssemblyRef_BuildNumber, 1, &buildNumber)) + if (!md_set_column_value_as_constant(assemblyRef, mdtAssemblyRef_BuildNumber, buildNumber)) return E_FAIL; - if (md_set_column_value_as_constant(assemblyRef, mdtAssemblyRef_RevisionNumber, 1, &revisionNumber)) + if (md_set_column_value_as_constant(assemblyRef, mdtAssemblyRef_RevisionNumber, revisionNumber)) return E_FAIL; - if (1 != md_set_column_value_as_constant(assemblyRef, mdtAssemblyRef_Flags, 1, &flags)) + if (!md_set_column_value_as_constant(assemblyRef, mdtAssemblyRef_Flags, flags)) return E_FAIL; - if (1 != md_set_column_value_as_utf8(assemblyRef, mdtAssemblyRef_Name, 1, &assemblyName)) + if (!md_set_column_value_as_utf8(assemblyRef, mdtAssemblyRef_Name, assemblyName)) return E_FAIL; - if (1 != md_set_column_value_as_utf8(assemblyRef, mdtAssemblyRef_Culture, 1, &assemblyCulture)) + if (!md_set_column_value_as_utf8(assemblyRef, mdtAssemblyRef_Culture, assemblyCulture)) return E_FAIL; uint8_t const* hash = sourceAssemblyHash; uint32_t hashLength = (uint32_t)sourceAssemblyHash.size(); - if (1 != md_set_column_value_as_blob(assemblyRef, mdtAssemblyRef_HashValue, 1, &hash, &hashLength)) + if (!md_set_column_value_as_blob(assemblyRef, mdtAssemblyRef_HashValue, hash, hashLength)) return E_FAIL; uint8_t const* publicKeyTokenBlob = publicKeyToken.data(); uint32_t publicKeyTokenLength = (uint32_t)publicKeyToken.size(); - if (1 != md_set_column_value_as_blob(assemblyRef, mdtAssemblyRef_PublicKeyOrToken, 1, &publicKeyTokenBlob, &publicKeyTokenLength)) + if (!md_set_column_value_as_blob(assemblyRef, mdtAssemblyRef_PublicKeyOrToken, publicKeyTokenBlob, publicKeyTokenLength)) return E_FAIL; *targetAssembly = assemblyRef; @@ -784,14 +784,14 @@ HRESULT ImportReferenceToTypeDef( mdcursor_t importModule; uint32_t count; if (!md_create_cursor(sourceModule, mdtid_Module, &importModule, &count) - || 1 != md_get_column_value_as_utf8(importModule, mdtModule_Name, 1, &importName)) + || !md_get_column_value_as_utf8(importModule, mdtModule_Name, &importName)) { return E_FAIL; } md_added_row_t moduleRef; if (!md_append_row(targetModule, mdtid_ModuleRef, &moduleRef) - || 1 != md_set_column_value_as_utf8(moduleRef, mdtModuleRef_Name, 1, &importName)) + || !md_set_column_value_as_utf8(moduleRef, mdtModuleRef_Name, importName)) { return E_FAIL; } @@ -832,7 +832,7 @@ HRESULT ImportReferenceToTypeDef( while (md_find_row_from_cursor(nestedClasses, mdtNestedClass_NestedClass, RidFromToken(nestedTypeToken), &nestedClass)) { mdcursor_t enclosingClass; - if (1 != md_get_column_value_as_cursor(nestedClass, mdtNestedClass_EnclosingClass, 1, &enclosingClass)) + if (!md_get_column_value_as_cursor(nestedClass, mdtNestedClass_EnclosingClass, &enclosingClass)) return E_FAIL; typesForTypeRefs.push(enclosingClass); @@ -847,19 +847,19 @@ HRESULT ImportReferenceToTypeDef( if (!md_append_row(targetModule, mdtid_TypeRef, &typeRef)) return E_FAIL; - if (1 != md_set_column_value_as_cursor(typeRef, mdtTypeRef_ResolutionScope, 1, &resolutionScope)) + if (!md_set_column_value_as_cursor(typeRef, mdtTypeRef_ResolutionScope, resolutionScope)) return E_FAIL; char const* typeName; - if (1 != md_get_column_value_as_utf8(typeDef, mdtTypeDef_TypeName, 1, &typeName) - || 1 != md_set_column_value_as_utf8(typeRef, mdtTypeRef_TypeName, 1, &typeName)) + if (!md_get_column_value_as_utf8(typeDef, mdtTypeDef_TypeName, &typeName) + || !md_set_column_value_as_utf8(typeRef, mdtTypeRef_TypeName, typeName)) { return E_FAIL; } char const* typeNamespace; - if (1 != md_get_column_value_as_utf8(typeDef, mdtTypeDef_TypeNamespace, 1, &typeNamespace) - || 1 != md_set_column_value_as_utf8(typeRef, mdtTypeRef_TypeNamespace, 1, &typeNamespace)) + if (!md_get_column_value_as_utf8(typeDef, mdtTypeDef_TypeNamespace, &typeNamespace) + || !md_set_column_value_as_utf8(typeRef, mdtTypeRef_TypeNamespace, typeNamespace)) { return E_FAIL; } @@ -890,7 +890,7 @@ namespace for (uint32_t i = 0; i < count; i++, md_cursor_next(&c)) { char const* name; - if (1 != md_get_column_value_as_utf8(c, mdtModuleRef_Name, 1, &name)) + if (!md_get_column_value_as_utf8(c, mdtModuleRef_Name, &name)) return false; if (std::strcmp(name, moduleName) == 0) @@ -925,11 +925,11 @@ namespace for (uint32_t i = 0; i < count; ++i, md_cursor_next(&exportedType)) { char const* exportedTypeName; - if (1 != md_get_column_value_as_utf8(exportedType, mdtExportedType_TypeName, 1, &exportedTypeName)) + if (!md_get_column_value_as_utf8(exportedType, mdtExportedType_TypeName, &exportedTypeName)) return E_FAIL; char const* exportedTypeNamespace; - if (1 != md_get_column_value_as_utf8(exportedType, mdtExportedType_TypeNamespace, 1, &exportedTypeNamespace)) + if (!md_get_column_value_as_utf8(exportedType, mdtExportedType_TypeNamespace, &exportedTypeNamespace)) return E_FAIL; if (std::strcmp(typeName, exportedTypeName) == 0 && std::strcmp(typeNamespace, exportedTypeNamespace) == 0) @@ -945,7 +945,7 @@ namespace // If we found an ExportedType, then the type is defined in another module or is forwarded to another assembly. // We need to find the imported scope for the type. mdcursor_t implementation; - if (1 != md_get_column_value_as_cursor(exportedType, mdtExportedType_Implementation, 1, &implementation)) + if (!md_get_column_value_as_cursor(exportedType, mdtExportedType_Implementation, &implementation)) return E_FAIL; switch (GetTokenTypeFromCursor(implementation)) @@ -956,7 +956,7 @@ namespace case mdtFile: { char const* fileName; - if (1 != md_get_column_value_as_utf8(implementation, mdtFile_Name, 1, &fileName)) + if (!md_get_column_value_as_utf8(implementation, mdtFile_Name, &fileName)) return E_FAIL; mdcursor_t moduleCursor; @@ -964,7 +964,7 @@ namespace return E_FAIL; char const* moduleName; - if (1 != md_get_column_value_as_utf8(moduleCursor, mdtModule_Name, 1, &moduleName)) + if (!md_get_column_value_as_utf8(moduleCursor, mdtModule_Name, &moduleName)) return E_FAIL; if (std::strcmp(fileName, moduleName) == 0) @@ -979,7 +979,7 @@ namespace if (!md_append_row(module, mdtid_ModuleRef, &moduleRef)) return E_FAIL; - if (1 != md_set_column_value_as_utf8(moduleRef, mdtModuleRef_Name, 1, &fileName)) + if (!md_set_column_value_as_utf8(moduleRef, mdtModuleRef_Name, fileName)) return E_FAIL; *importedScope = moduleRef; @@ -1011,11 +1011,11 @@ namespace for (uint32_t i = 0; i < count; ++i, md_cursor_next(&typeDef)) { char const* typeDefName; - if (1 != md_get_column_value_as_utf8(typeDef, mdtTypeDef_TypeName, 1, &typeDefName)) + if (!md_get_column_value_as_utf8(typeDef, mdtTypeDef_TypeName, &typeDefName)) return E_FAIL; char const* typeDefNamespace; - if (1 != md_get_column_value_as_utf8(typeDef, mdtTypeDef_TypeNamespace, 1, &typeDefNamespace)) + if (!md_get_column_value_as_utf8(typeDef, mdtTypeDef_TypeNamespace, &typeDefNamespace)) return E_FAIL; if (std::strcmp(typeName, typeDefName) == 0 && std::strcmp(typeNamespace, typeDefNamespace) == 0) @@ -1044,7 +1044,7 @@ namespace return CLDB_E_FILE_CORRUPT; char const* assemblyModuleName; - if (1 != md_get_column_value_as_utf8(assemblyModule, mdtModule_Name, 1, &assemblyModuleName)) + if (!md_get_column_value_as_utf8(assemblyModule, mdtModule_Name, &assemblyModuleName)) return E_FAIL; mdcursor_t moduleCursor; @@ -1052,7 +1052,7 @@ namespace return CLDB_E_FILE_CORRUPT; char const* moduleName; - if (1 != md_get_column_value_as_utf8(moduleCursor, mdtModule_Name, 1, &moduleName)) + if (!md_get_column_value_as_utf8(moduleCursor, mdtModule_Name, &moduleName)) return E_FAIL; if (std::strcmp(assemblyModuleName, moduleName) == 0) @@ -1067,7 +1067,7 @@ namespace if (!md_append_row(module, mdtid_ModuleRef, &moduleRef)) return E_FAIL; - if (1 != md_set_column_value_as_utf8(moduleRef, mdtModuleRef_Name, 1, &assemblyModuleName)) + if (!md_set_column_value_as_utf8(moduleRef, mdtModuleRef_Name, assemblyModuleName)) return E_FAIL; *importedScope = moduleRef; @@ -1086,66 +1086,66 @@ namespace HRESULT hr; // Compare version, Name, Locale, and PublicKeyOrToken (possibly creating token from the assembly's key if needed) uint32_t refMajorVersion; - if (1 != md_get_column_value_as_constant(assemblyRef, mdtAssemblyRef_MajorVersion, 1, &refMajorVersion)) + if (!md_get_column_value_as_constant(assemblyRef, mdtAssemblyRef_MajorVersion, &refMajorVersion)) return CLDB_E_FILE_CORRUPT; uint32_t majorVersion; - if (1 != md_get_column_value_as_constant(assembly, mdtAssembly_MajorVersion, 1, &majorVersion)) + if (!md_get_column_value_as_constant(assembly, mdtAssembly_MajorVersion, &majorVersion)) return CLDB_E_FILE_CORRUPT; if (refMajorVersion != majorVersion) return S_FALSE; uint32_t refMinorVersion; - if (1 != md_get_column_value_as_constant(assemblyRef, mdtAssemblyRef_MinorVersion, 1, &refMinorVersion)) + if (!md_get_column_value_as_constant(assemblyRef, mdtAssemblyRef_MinorVersion, &refMinorVersion)) return CLDB_E_FILE_CORRUPT; uint32_t minorVersion; - if (1 != md_get_column_value_as_constant(assembly, mdtAssembly_MinorVersion, 1, &minorVersion)) + if (!md_get_column_value_as_constant(assembly, mdtAssembly_MinorVersion, &minorVersion)) return CLDB_E_FILE_CORRUPT; if (refMinorVersion != minorVersion) return S_FALSE; uint32_t refBuildNumber; - if (1 != md_get_column_value_as_constant(assemblyRef, mdtAssemblyRef_BuildNumber, 1, &refBuildNumber)) + if (!md_get_column_value_as_constant(assemblyRef, mdtAssemblyRef_BuildNumber, &refBuildNumber)) return CLDB_E_FILE_CORRUPT; uint32_t buildNumber; - if (1 != md_get_column_value_as_constant(assembly, mdtAssembly_BuildNumber, 1, &buildNumber)) + if (!md_get_column_value_as_constant(assembly, mdtAssembly_BuildNumber, &buildNumber)) return CLDB_E_FILE_CORRUPT; if (refBuildNumber != buildNumber) return S_FALSE; uint32_t refRevisionNumber; - if (1 != md_get_column_value_as_constant(assemblyRef, mdtAssemblyRef_RevisionNumber, 1, &refRevisionNumber)) + if (!md_get_column_value_as_constant(assemblyRef, mdtAssemblyRef_RevisionNumber, &refRevisionNumber)) return CLDB_E_FILE_CORRUPT; uint32_t revisionNumber; - if (1 != md_get_column_value_as_constant(assembly, mdtAssembly_RevisionNumber, 1, &revisionNumber)) + if (!md_get_column_value_as_constant(assembly, mdtAssembly_RevisionNumber, &revisionNumber)) return CLDB_E_FILE_CORRUPT; if (refRevisionNumber != revisionNumber) return S_FALSE; char const* refName; - if (1 != md_get_column_value_as_utf8(assemblyRef, mdtAssemblyRef_Name, 1, &refName)) + if (!md_get_column_value_as_utf8(assemblyRef, mdtAssemblyRef_Name, &refName)) return CLDB_E_FILE_CORRUPT; char const* name; - if (1 != md_get_column_value_as_utf8(assembly, mdtAssembly_Name, 1, &name)) + if (!md_get_column_value_as_utf8(assembly, mdtAssembly_Name, &name)) return CLDB_E_FILE_CORRUPT; if (std::strcmp(refName, name) != 0) return S_FALSE; char const* refCulture; - if (1 != md_get_column_value_as_utf8(assemblyRef, mdtAssemblyRef_Culture, 1, &refCulture)) + if (!md_get_column_value_as_utf8(assemblyRef, mdtAssemblyRef_Culture, &refCulture)) return CLDB_E_FILE_CORRUPT; char const* culture; - if (1 != md_get_column_value_as_utf8(assembly, mdtAssembly_Culture, 1, &culture)) + if (!md_get_column_value_as_utf8(assembly, mdtAssembly_Culture, &culture)) return CLDB_E_FILE_CORRUPT; if (std::strcmp(refCulture, culture) != 0) @@ -1153,12 +1153,12 @@ namespace uint8_t const* refPublicKeyOrToken; uint32_t refPublicKeyOrTokenLength; - if (1 != md_get_column_value_as_blob(assemblyRef, mdtAssemblyRef_PublicKeyOrToken, 1, &refPublicKeyOrToken, &refPublicKeyOrTokenLength)) + if (!md_get_column_value_as_blob(assemblyRef, mdtAssemblyRef_PublicKeyOrToken, &refPublicKeyOrToken, &refPublicKeyOrTokenLength)) return CLDB_E_FILE_CORRUPT; uint8_t const* publicKey; uint32_t publicKeyLength; - if (1 != md_get_column_value_as_blob(assembly, mdtAssembly_PublicKey, 1, &publicKey, &publicKeyLength)) + if (!md_get_column_value_as_blob(assembly, mdtAssembly_PublicKey, &publicKey, &publicKeyLength)) return CLDB_E_FILE_CORRUPT; if ((refPublicKeyOrTokenLength == 0) != (publicKeyLength == 0)) @@ -1167,7 +1167,7 @@ namespace if (refPublicKeyOrTokenLength != 0) { uint32_t refFlags; - if (1 != md_get_column_value_as_constant(assemblyRef, mdtAssemblyRef_Flags, 1, &refFlags)) + if (!md_get_column_value_as_constant(assemblyRef, mdtAssemblyRef_Flags, &refFlags)) return CLDB_E_FILE_CORRUPT; if (IsAfPublicKey(refFlags)) @@ -1209,7 +1209,7 @@ namespace while (GetTokenTypeFromCursor(scope) == mdtTypeRef) { mdcursor_t resolutionScope; - if (1 != md_get_column_value_as_cursor(scope, mdtTypeRef_ResolutionScope, 1, &resolutionScope)) + if (!md_get_column_value_as_cursor(scope, mdtTypeRef_ResolutionScope, &resolutionScope)) return E_FAIL; typesForTypeRefs.push(resolutionScope); @@ -1266,7 +1266,7 @@ namespace { // Create a ModuleRef from the target module to the source module. char const* moduleName; - if (1 != md_get_column_value_as_utf8(scope, mdtModule_Name, 1, &moduleName)) + if (!md_get_column_value_as_utf8(scope, mdtModule_Name, &moduleName)) return CLDB_E_FILE_CORRUPT; if (!FindModuleRef(targetModule, moduleName, &targetOutermostScope)) @@ -1275,7 +1275,7 @@ namespace if (!md_append_row(targetModule, mdtid_ModuleRef, &moduleRef)) return E_FAIL; - if (1 != md_set_column_value_as_utf8(moduleRef, mdtModuleRef_Name, 1, &moduleName)) + if (!md_set_column_value_as_utf8(moduleRef, mdtModuleRef_Name, moduleName)) return E_FAIL; targetOutermostScope = moduleRef; @@ -1288,7 +1288,7 @@ namespace // then we can use the Module token as the outermost scope. // otherwise, create ModuleRef to the module that the source ModuleRef points to. char const* moduleName; - if (1 != md_get_column_value_as_utf8(scope, mdtModuleRef_Name, 1, &moduleName)) + if (!md_get_column_value_as_utf8(scope, mdtModuleRef_Name, &moduleName)) return CLDB_E_FILE_CORRUPT; mdcursor_t targetModuleCursor; @@ -1297,7 +1297,7 @@ namespace return E_FAIL; char const* targetModuleName; - if (1 != md_get_column_value_as_utf8(targetModuleCursor, mdtModule_Name, 1, &targetModuleName)) + if (!md_get_column_value_as_utf8(targetModuleCursor, mdtModule_Name, &targetModuleName)) return E_FAIL; if (std::strcmp(moduleName, targetModuleName) == 0) @@ -1310,7 +1310,7 @@ namespace if (!md_append_row(targetModule, mdtid_ModuleRef, &moduleRef)) return E_FAIL; - if (1 != md_set_column_value_as_utf8(moduleRef, mdtModuleRef_Name, 1, &moduleName)) + if (!md_set_column_value_as_utf8(moduleRef, mdtModuleRef_Name, moduleName)) return E_FAIL; targetOutermostScope = moduleRef; @@ -1346,27 +1346,27 @@ namespace { mdcursor_t outermostTypeRef = typesForTypeRefs.top(); char const* typeName; - if (1 != md_get_column_value_as_utf8(outermostTypeRef, mdtTypeRef_TypeName, 1, &typeName)) + if (!md_get_column_value_as_utf8(outermostTypeRef, mdtTypeRef_TypeName, &typeName)) return E_FAIL; char const* typeNamespace; - if (1 != md_get_column_value_as_utf8(outermostTypeRef, mdtTypeRef_TypeNamespace, 1, &typeNamespace)) + if (!md_get_column_value_as_utf8(outermostTypeRef, mdtTypeRef_TypeNamespace, &typeNamespace)) return E_FAIL; // If we can't find an ExportedType entry for this type, we'll just move over the TypeRef with a Nil ResolutionScope. for (uint32_t i = 0; i < count; ++i, md_cursor_next(&exportedType)) { char const* exportedTypeName; - if (1 != md_get_column_value_as_utf8(exportedType, mdtExportedType_TypeName, 1, &exportedTypeName)) + if (!md_get_column_value_as_utf8(exportedType, mdtExportedType_TypeName, &exportedTypeName)) return E_FAIL; char const* exportedTypeNamespace; - if (1 != md_get_column_value_as_utf8(exportedType, mdtExportedType_TypeNamespace, 1, &exportedTypeNamespace)) + if (!md_get_column_value_as_utf8(exportedType, mdtExportedType_TypeNamespace, &exportedTypeNamespace)) return E_FAIL; if (std::strcmp(typeName, exportedTypeName) == 0 && std::strcmp(typeNamespace, exportedTypeNamespace) == 0) { - if (1 != md_get_column_value_as_cursor(exportedType, mdtExportedType_Implementation, 1, &implementation)) + if (!md_get_column_value_as_cursor(exportedType, mdtExportedType_Implementation, &implementation)) return E_FAIL; foundExportedType = true; @@ -1426,22 +1426,22 @@ namespace mdcursor_t outermostTypeRef = typesForTypeRefs.top(); char const* typeName; - if (1 != md_get_column_value_as_utf8(outermostTypeRef, mdtTypeRef_TypeName, 1, &typeName)) + if (!md_get_column_value_as_utf8(outermostTypeRef, mdtTypeRef_TypeName, &typeName)) return E_FAIL; char const* typeNamespace; - if (1 != md_get_column_value_as_utf8(outermostTypeRef, mdtTypeRef_TypeNamespace, 1, &typeNamespace)) + if (!md_get_column_value_as_utf8(outermostTypeRef, mdtTypeRef_TypeNamespace, &typeNamespace)) return E_FAIL; bool found = false; for (uint32_t i = 0; i < sourceAssemblyTypeDefCount; ++i, md_cursor_next(&sourceAssemblyTypeDef)) { char const* sourceAssemblyTypeDefName; - if (1 != md_get_column_value_as_utf8(sourceAssemblyTypeDef, mdtTypeDef_TypeName, 1, &sourceAssemblyTypeDefName)) + if (!md_get_column_value_as_utf8(sourceAssemblyTypeDef, mdtTypeDef_TypeName, &sourceAssemblyTypeDefName)) return E_FAIL; char const* sourceAssemblyTypeDefNamespace; - if (1 != md_get_column_value_as_utf8(sourceAssemblyTypeDef, mdtTypeDef_TypeNamespace, 1, &sourceAssemblyTypeDefNamespace)) + if (!md_get_column_value_as_utf8(sourceAssemblyTypeDef, mdtTypeDef_TypeNamespace, &sourceAssemblyTypeDefNamespace)) return E_FAIL; if (std::strcmp(typeName, sourceAssemblyTypeDefName) != 0 && std::strcmp(typeNamespace, sourceAssemblyTypeDefNamespace) != 0) @@ -1493,11 +1493,11 @@ namespace // The type is defined in the target assembly, so we need to correctly define its scope. mdcursor_t outermostTypeRef = typesForTypeRefs.top(); char const* typeName; - if (1 != md_get_column_value_as_utf8(outermostTypeRef, mdtTypeRef_TypeName, 1, &typeName)) + if (!md_get_column_value_as_utf8(outermostTypeRef, mdtTypeRef_TypeName, &typeName)) return E_FAIL; char const* typeNamespace; - if (1 != md_get_column_value_as_utf8(outermostTypeRef, mdtTypeRef_TypeNamespace, 1, &typeNamespace)) + if (!md_get_column_value_as_utf8(outermostTypeRef, mdtTypeRef_TypeNamespace, &typeNamespace)) return E_FAIL; RETURN_IF_FAILED(ImportScopeForTypeByNameInAssembly( @@ -1551,11 +1551,11 @@ namespace mdcursor_t sourceEnclosingTypeRef = typesForTypeRefs.top(); char const* typeName; - if (1 != md_get_column_value_as_utf8(sourceEnclosingTypeRef, mdtTypeRef_TypeName, 1, &typeName)) + if (!md_get_column_value_as_utf8(sourceEnclosingTypeRef, mdtTypeRef_TypeName, &typeName)) return E_FAIL; char const* typeNamespace; - if (1 != md_get_column_value_as_utf8(sourceEnclosingTypeRef, mdtTypeRef_TypeNamespace, 1, &typeNamespace)) + if (!md_get_column_value_as_utf8(sourceEnclosingTypeRef, mdtTypeRef_TypeNamespace, &typeNamespace)) return E_FAIL; mdToken enclosingScopeToken; @@ -1570,11 +1570,11 @@ namespace do { char const* targetTypeName; - if (1 != md_get_column_value_as_utf8(targetTypeDef, mdtTypeDef_TypeName, 1, &targetTypeName)) + if (!md_get_column_value_as_utf8(targetTypeDef, mdtTypeDef_TypeName, &targetTypeName)) return E_FAIL; char const* targetTypeNamespace; - if (1 != md_get_column_value_as_utf8(targetTypeDef, mdtTypeDef_TypeNamespace, 1, &targetTypeNamespace)) + if (!md_get_column_value_as_utf8(targetTypeDef, mdtTypeDef_TypeNamespace, &targetTypeNamespace)) return E_FAIL; // Check the name of the type. @@ -1600,7 +1600,7 @@ namespace if (shouldHaveEnclosingType) { mdToken targetEnclosingType; - if (1 != md_get_column_value_as_token(targetNestedClass, mdtNestedClass_EnclosingClass, 1, &targetEnclosingType)) + if (!md_get_column_value_as_token(targetNestedClass, mdtNestedClass_EnclosingClass, &targetEnclosingType)) return E_FAIL; // If the enclosing type doesn't match, then we are in a failure state. @@ -1629,19 +1629,19 @@ namespace if (!md_append_row(targetModule, mdtid_TypeRef, &targetEnclosingTypeRef)) return E_FAIL; - if (1 != md_set_column_value_as_cursor(targetEnclosingTypeRef, mdtTypeRef_ResolutionScope, 1, &resolutionScope)) + if (!md_set_column_value_as_cursor(targetEnclosingTypeRef, mdtTypeRef_ResolutionScope, resolutionScope)) return E_FAIL; char const* typeName; - if (1 != md_get_column_value_as_utf8(sourceEnclosingTypeRef, mdtTypeRef_TypeName, 1, &typeName) - || 1 != md_set_column_value_as_utf8(targetEnclosingTypeRef, mdtTypeRef_TypeName, 1, &typeName)) + if (!md_get_column_value_as_utf8(sourceEnclosingTypeRef, mdtTypeRef_TypeName, &typeName) + || !md_set_column_value_as_utf8(targetEnclosingTypeRef, mdtTypeRef_TypeName, typeName)) { return E_FAIL; } char const* typeNamespace; - if (1 != md_get_column_value_as_utf8(sourceEnclosingTypeRef, mdtTypeRef_TypeNamespace, 1, &typeNamespace) - || 1 != md_set_column_value_as_utf8(targetEnclosingTypeRef, mdtTypeRef_TypeNamespace, 1, &typeNamespace)) + if (!md_get_column_value_as_utf8(sourceEnclosingTypeRef, mdtTypeRef_TypeNamespace, &typeNamespace) + || !md_set_column_value_as_utf8(targetEnclosingTypeRef, mdtTypeRef_TypeNamespace, typeNamespace)) { return E_FAIL; } @@ -1694,10 +1694,10 @@ HRESULT ImportReferenceToTypeDefOrRefOrSpec( { uint8_t const* signature; uint32_t signatureLength; - if (1 != md_get_column_value_as_blob(sourceCursor, mdtTypeSpec_Signature, 1, &signature, &signatureLength)) + if (!md_get_column_value_as_blob(sourceCursor, mdtTypeSpec_Signature, &signature, &signatureLength)) return E_FAIL; - malloc_span importedSignature; + inline_span importedSignature; RETURN_IF_FAILED(ImportTypeSpecBlob(sourceAssembly, sourceModule, sourceAssemblyHash, targetAssembly, targetModule, {signature, signatureLength}, onRowAdded, importedSignature)); md_added_row_t typeSpec; @@ -1706,7 +1706,7 @@ HRESULT ImportReferenceToTypeDefOrRefOrSpec( uint8_t const* importedSignatureData = importedSignature; uint32_t importedSignatureLength = (uint32_t)importedSignature.size(); - if (1 != md_set_column_value_as_blob(typeSpec, mdtTypeSpec_Signature, 1, &importedSignatureData, &importedSignatureLength)) + if (!md_set_column_value_as_blob(typeSpec, mdtTypeSpec_Signature, importedSignatureData, importedSignatureLength)) return E_FAIL; if (!md_cursor_to_token(typeSpec, importedToken)) diff --git a/src/native/dnmd/src/interfaces/metadataemit.cpp b/src/native/dnmd/src/interfaces/metadataemit.cpp index 3de91267ab84f..f75fcd67c5647 100644 --- a/src/native/dnmd/src/interfaces/metadataemit.cpp +++ b/src/native/dnmd/src/interfaces/metadataemit.cpp @@ -86,7 +86,7 @@ HRESULT MetadataEmit::SetModuleProps( } } - if (1 != md_set_column_value_as_utf8(c, mdtModule_Name, 1, &start)) + if (!md_set_column_value_as_utf8(c, mdtModule_Name, start)) return E_FAIL; // TODO: Record ENC Log. @@ -195,17 +195,17 @@ HRESULT MetadataEmit::DefineTypeDef( char const* ns; char const* name; SplitTypeName(cvt, &ns, &name); - if (1 != md_set_column_value_as_utf8(c, mdtTypeDef_TypeNamespace, 1, &ns)) + if (!md_set_column_value_as_utf8(c, mdtTypeDef_TypeNamespace, ns)) return E_FAIL; - if (1 != md_set_column_value_as_utf8(c, mdtTypeDef_TypeName, 1, &name)) + if (!md_set_column_value_as_utf8(c, mdtTypeDef_TypeName, name)) return E_FAIL; // TODO: Handle reserved flags uint32_t flags = (uint32_t)dwTypeDefFlags; - if (1 != md_set_column_value_as_constant(c, mdtTypeDef_Flags, 1, &flags)) + if (!md_set_column_value_as_constant(c, mdtTypeDef_Flags, flags)) return E_FAIL; - if (1 != md_set_column_value_as_token(c, mdtTypeDef_Extends, 1, &tkExtends)) + if (!md_set_column_value_as_token(c, mdtTypeDef_Extends, tkExtends)) return E_FAIL; mdcursor_t fieldCursor; @@ -213,13 +213,13 @@ HRESULT MetadataEmit::DefineTypeDef( if (!md_create_cursor(MetaData(), mdtid_Field, &fieldCursor, &numFields)) { mdToken nilField = mdFieldDefNil; - if (1 != md_set_column_value_as_token(c, mdtTypeDef_FieldList, 1, &nilField)) + if (!md_set_column_value_as_token(c, mdtTypeDef_FieldList, nilField)) return E_FAIL; } else { md_cursor_move(&fieldCursor, numFields); - if (1 != md_set_column_value_as_cursor(c, mdtTypeDef_FieldList, 1, &fieldCursor)) + if (!md_set_column_value_as_cursor(c, mdtTypeDef_FieldList, fieldCursor)) return E_FAIL; } @@ -228,13 +228,13 @@ HRESULT MetadataEmit::DefineTypeDef( if (!md_create_cursor(MetaData(), mdtid_MethodDef, &methodCursor, &numMethods)) { mdToken nilMethod = mdMethodDefNil; - if (1 != md_set_column_value_as_token(c, mdtTypeDef_MethodList, 1, &nilMethod)) + if (!md_set_column_value_as_token(c, mdtTypeDef_MethodList, nilMethod)) return E_FAIL; } else { md_cursor_move(&methodCursor, numMethods); - if (1 != md_set_column_value_as_cursor(c, mdtTypeDef_MethodList, 1, &methodCursor)) + if (!md_set_column_value_as_cursor(c, mdtTypeDef_MethodList, methodCursor)) return E_FAIL; } @@ -248,10 +248,10 @@ HRESULT MetadataEmit::DefineTypeDef( if (!md_append_row(MetaData(), mdtid_InterfaceImpl, &interfaceImpl)) return E_FAIL; - if (1 != md_set_column_value_as_cursor(interfaceImpl, mdtInterfaceImpl_Class, 1, &c)) + if (!md_set_column_value_as_cursor(interfaceImpl, mdtInterfaceImpl_Class, c)) return E_FAIL; - if (1 != md_set_column_value_as_token(interfaceImpl, mdtInterfaceImpl_Interface, 1, ¤tImplementation)) + if (!md_set_column_value_as_token(interfaceImpl, mdtInterfaceImpl_Interface, currentImplementation)) return E_FAIL; } } @@ -286,10 +286,10 @@ HRESULT MetadataEmit::DefineNestedType( if (!md_append_row(MetaData(), mdtid_NestedClass, &c)) return E_FAIL; - if (1 != md_set_column_value_as_token(c, mdtNestedClass_NestedClass, 1, ptd)) + if (!md_set_column_value_as_token(c, mdtNestedClass_NestedClass, *ptd)) return E_FAIL; - if (1 != md_set_column_value_as_token(c, mdtNestedClass_EnclosingClass, 1, &tdEncloser)) + if (!md_set_column_value_as_token(c, mdtNestedClass_EnclosingClass, tdEncloser)) return E_FAIL; // TODO: Update ENC log @@ -330,23 +330,23 @@ HRESULT MetadataEmit::DefineMethod( pal::StringConvert cvt(szName); char const* name = cvt; - if (1 != md_set_column_value_as_utf8(newMethod, mdtMethodDef_Name, 1, &name)) + if (!md_set_column_value_as_utf8(newMethod, mdtMethodDef_Name, name)) return E_FAIL; uint32_t flags = dwMethodFlags; - if (1 != md_set_column_value_as_constant(newMethod, mdtMethodDef_Flags, 1, &flags)) + if (!md_set_column_value_as_constant(newMethod, mdtMethodDef_Flags, flags)) return E_FAIL; uint32_t sigLength = cbSigBlob; - if (1 != md_set_column_value_as_blob(newMethod, mdtMethodDef_Signature, 1, &pvSigBlob, &sigLength)) + if (!md_set_column_value_as_blob(newMethod, mdtMethodDef_Signature, pvSigBlob, sigLength)) return E_FAIL; uint32_t implFlags = dwImplFlags; - if (1 != md_set_column_value_as_constant(newMethod, mdtMethodDef_ImplFlags, 1, &implFlags)) + if (!md_set_column_value_as_constant(newMethod, mdtMethodDef_ImplFlags, implFlags)) return E_FAIL; uint32_t rva = ulCodeRVA; - if (1 != md_set_column_value_as_constant(newMethod, mdtMethodDef_Rva, 1, &rva)) + if (!md_set_column_value_as_constant(newMethod, mdtMethodDef_Rva, rva)) return E_FAIL; if (!md_cursor_to_token(newMethod, pmd)) @@ -365,13 +365,13 @@ HRESULT MetadataEmit::DefineMethodImpl( if (!md_append_row(MetaData(), mdtid_MethodImpl, &c)) return E_FAIL; - if (1 != md_set_column_value_as_token(c, mdtMethodImpl_Class, 1, &td)) + if (!md_set_column_value_as_token(c, mdtMethodImpl_Class, td)) return E_FAIL; - if (1 != md_set_column_value_as_token(c, mdtMethodImpl_MethodBody, 1, &tkBody)) + if (!md_set_column_value_as_token(c, mdtMethodImpl_MethodBody, tkBody)) return E_FAIL; - if (1 != md_set_column_value_as_token(c, mdtMethodImpl_MethodDeclaration, 1, &tkDecl)) + if (!md_set_column_value_as_token(c, mdtMethodImpl_MethodDeclaration, tkDecl)) return E_FAIL; // TODO: Update ENC log @@ -387,7 +387,7 @@ HRESULT MetadataEmit::DefineTypeRefByName( if (!md_append_row(MetaData(), mdtid_TypeRef, &c)) return E_FAIL; - if (1 != md_set_column_value_as_token(c, mdtTypeRef_ResolutionScope, 1, &tkResolutionScope)) + if (!md_set_column_value_as_token(c, mdtTypeRef_ResolutionScope, tkResolutionScope)) return E_FAIL; pal::StringConvert cv(szName); @@ -399,9 +399,9 @@ HRESULT MetadataEmit::DefineTypeRefByName( char const* name; SplitTypeName(cv, &ns, &name); - if (1 != md_set_column_value_as_utf8(c, mdtTypeRef_TypeNamespace, 1, &ns)) + if (!md_set_column_value_as_utf8(c, mdtTypeRef_TypeNamespace, ns)) return E_FAIL; - if (1 != md_set_column_value_as_utf8(c, mdtTypeRef_TypeName, 1, &name)) + if (!md_set_column_value_as_utf8(c, mdtTypeRef_TypeName, name)) return E_FAIL; if (!md_cursor_to_token(c, ptr)) @@ -480,15 +480,15 @@ HRESULT MetadataEmit::DefineMemberRef( if (!md_append_row(MetaData(), mdtid_MemberRef, &c)) return E_FAIL; - if (1 != md_set_column_value_as_token(c, mdtMemberRef_Class, 1, &tkImport)) + if (!md_set_column_value_as_token(c, mdtMemberRef_Class, tkImport)) return E_FAIL; - if (1 != md_set_column_value_as_utf8(c, mdtMemberRef_Name, 1, &name)) + if (!md_set_column_value_as_utf8(c, mdtMemberRef_Name, name)) return E_FAIL; uint8_t const* sig = (uint8_t const*)pvSigBlob; uint32_t sigLength = cbSigBlob; - if (1 != md_set_column_value_as_blob(c, mdtMemberRef_Signature, 1, &sig, &sigLength)) + if (!md_set_column_value_as_blob(c, mdtMemberRef_Signature, sig, sigLength)) return E_FAIL; if (!md_cursor_to_token(c, pmr)) @@ -528,14 +528,14 @@ namespace if (!md_append_row(md, mdtid_MethodSemantics, &addMethodSemantic)) return E_FAIL; - if (1 != md_set_column_value_as_cursor(addMethodSemantic, mdtMethodSemantics_Association, 1, &parent)) + if (!md_set_column_value_as_cursor(addMethodSemantic, mdtMethodSemantics_Association, parent)) return E_FAIL; uint32_t semantics = semantic; - if (1 != md_set_column_value_as_constant(addMethodSemantic, mdtMethodSemantics_Semantics, 1, &semantics)) + if (!md_set_column_value_as_constant(addMethodSemantic, mdtMethodSemantics_Semantics, semantics)) return E_FAIL; - if (1 != md_set_column_value_as_token(addMethodSemantic, mdtMethodSemantics_Method, 1, &method)) + if (!md_set_column_value_as_token(addMethodSemantic, mdtMethodSemantics_Method, method)) return E_FAIL; // TODO: Update EncLog @@ -553,7 +553,7 @@ namespace return CLDB_E_RECORD_NOTFOUND; mdToken nilParent = mdFieldDefNil; - if (1 != md_set_column_value_as_token(c, mdtFieldMarshal_Parent, 1, &nilParent)) + if (!md_set_column_value_as_token(c, mdtFieldMarshal_Parent, nilParent)) return E_FAIL; mdcursor_t parentCursor; @@ -571,11 +571,11 @@ namespace return CLDB_E_FILE_CORRUPT; uint32_t flags; - if (1 != md_get_column_value_as_constant(c, flagsColumn, 1, &flags)) + if (!md_get_column_value_as_constant(c, flagsColumn, &flags)) return E_FAIL; flags &= ~flagToRemove; - if (1 != md_set_column_value_as_constant(c, flagsColumn, 1, &flags)) + if (!md_set_column_value_as_constant(c, flagsColumn, flags)) return E_FAIL; // TODO: Update EncLog @@ -590,11 +590,11 @@ namespace return CLDB_E_FILE_CORRUPT; uint32_t flags; - if (1 != md_get_column_value_as_constant(c, flagsColumn, 1, &flags)) + if (!md_get_column_value_as_constant(c, flagsColumn, &flags)) return E_FAIL; flags |= flagToAdd; - if (1 != md_set_column_value_as_constant(c, flagsColumn, 1, &flags)) + if (!md_set_column_value_as_constant(c, flagsColumn, flags)) return E_FAIL; // TODO: Update EncLog @@ -615,7 +615,7 @@ namespace if (!md_append_row(md, childTable, &addedRow)) return E_FAIL; - if (1 != md_set_column_value_as_token(addedRow, parentCol, 1, &parent)) + if (!md_set_column_value_as_token(addedRow, parentCol, parent)) return E_FAIL; c = addedRow; } @@ -658,14 +658,14 @@ HRESULT MetadataEmit::DefineEvent( if (!md_add_new_row_to_list(c, mdtEventMap_EventList, &addedEvent)) return E_FAIL; - if (1 != md_set_column_value_as_utf8(addedEvent, mdtEvent_Name, 1, &name)) + if (!md_set_column_value_as_utf8(addedEvent, mdtEvent_Name, name)) return E_FAIL; uint32_t flags = dwEventFlags; - if (1 != md_set_column_value_as_constant(addedEvent, mdtEvent_EventFlags, 1, &flags)) + if (!md_set_column_value_as_constant(addedEvent, mdtEvent_EventFlags, flags)) return E_FAIL; - if (1 != md_set_column_value_as_token(addedEvent, mdtEvent_EventType, 1, &tkEventType)) + if (!md_set_column_value_as_token(addedEvent, mdtEvent_EventType, tkEventType)) return E_FAIL; if (mdAddOn != mdMethodDefNil) @@ -718,7 +718,7 @@ HRESULT MetadataEmit::SetClassLayout( uint32_t offset = rFieldOffsets[i].ulOffset; RETURN_IF_FAILED(FindOrCreateParentedRow(MetaData(), field, mdtid_FieldLayout, mdtFieldLayout_Field, [=](mdcursor_t c) { - if (1 != md_set_column_value_as_constant(c, mdtFieldLayout_Offset, 1, &offset)) + if (!md_set_column_value_as_constant(c, mdtFieldLayout_Offset, offset)) return E_FAIL; return S_OK; @@ -730,11 +730,11 @@ HRESULT MetadataEmit::SetClassLayout( RETURN_IF_FAILED(FindOrCreateParentedRow(MetaData(), td, mdtid_ClassLayout, mdtClassLayout_Parent, [=](mdcursor_t c) { uint32_t packSize = (uint32_t)dwPackSize; - if (1 != md_set_column_value_as_constant(c, mdtClassLayout_PackingSize, 1, &packSize)) + if (!md_set_column_value_as_constant(c, mdtClassLayout_PackingSize, packSize)) return E_FAIL; uint32_t classSize = (uint32_t)ulClassSize; - if (1 != md_set_column_value_as_constant(c, mdtClassLayout_ClassSize, 1, &classSize)) + if (!md_set_column_value_as_constant(c, mdtClassLayout_ClassSize, classSize)) return E_FAIL; return S_OK; @@ -803,18 +803,18 @@ HRESULT MetadataEmit::SetFieldMarshal( col_index_t col = TypeFromToken(tk) == mdtFieldDef ? mdtField_Flags : mdtParam_Flags; uint32_t flagToAdd = TypeFromToken(tk) == mdtFieldDef ? (uint32_t)fdHasFieldMarshal : (uint32_t)pdHasFieldMarshal; uint32_t flags; - if (1 != md_get_column_value_as_constant(parent, col, 1, &flags)) + if (!md_get_column_value_as_constant(parent, col, &flags)) return E_FAIL; flags |= flagToAdd; - if (1 != md_set_column_value_as_constant(parent, col, 1, &flags)) + if (!md_set_column_value_as_constant(parent, col, flags)) return E_FAIL; FindOrCreateParentedRow(MetaData(), tk, mdtid_FieldMarshal, mdtFieldMarshal_Parent, [=](mdcursor_t c) { uint8_t const* sig = (uint8_t const*)pvNativeType; uint32_t sigLength = cbNativeType; - if (1 != md_set_column_value_as_blob(c, mdtFieldMarshal_NativeType, 1, &sig, &sigLength)) + if (!md_set_column_value_as_blob(c, mdtFieldMarshal_NativeType, sig, sigLength)) return E_FAIL; return S_OK; @@ -860,7 +860,7 @@ HRESULT MetadataEmit::DefinePermissionSet( if (!md_append_row(MetaData(), mdtid_DeclSecurity, &c)) return E_FAIL; - if (1 != md_set_column_value_as_token(c, mdtDeclSecurity_Parent, 1, &tk)) + if (!md_set_column_value_as_token(c, mdtDeclSecurity_Parent, tk)) return E_FAIL; if (TypeFromToken(tk) == mdtTypeDef @@ -870,27 +870,27 @@ HRESULT MetadataEmit::DefinePermissionSet( col_index_t flagsCol = TypeFromToken(tk) == mdtTypeDef ? mdtTypeDef_Flags : mdtMethodDef_Flags; mdcursor_t parent; - if (1 != md_get_column_value_as_cursor(c, mdtDeclSecurity_Parent, 1, &parent)) + if (!md_get_column_value_as_cursor(c, mdtDeclSecurity_Parent, &parent)) return E_FAIL; uint32_t flags; - if (1 != md_get_column_value_as_constant(parent, flagsCol, 1, &flags)) + if (!md_get_column_value_as_constant(parent, flagsCol, &flags)) return E_FAIL; flags |= flagToAdd; - if (1 != md_set_column_value_as_constant(parent, flagsCol, 1, &flags)) + if (!md_set_column_value_as_constant(parent, flagsCol, flags)) return E_FAIL; // TODO: Update EncLog } uint32_t action = dwAction; - if (1 != md_set_column_value_as_constant(c, mdtDeclSecurity_Action, 1, &action)) + if (!md_set_column_value_as_constant(c, mdtDeclSecurity_Action, action)) return E_FAIL; uint8_t const* permission = (uint8_t const*)pvPermission; uint32_t permissionLength = cbPermission; - if (1 != md_set_column_value_as_blob(c, mdtDeclSecurity_PermissionSet, 1, &permission, &permissionLength)) + if (!md_set_column_value_as_blob(c, mdtDeclSecurity_PermissionSet, permission, permissionLength)) return E_FAIL; if (!md_cursor_to_token(c, ppm)) @@ -909,7 +909,7 @@ HRESULT MetadataEmit::SetRVA( return CLDB_E_FILE_CORRUPT; uint32_t rva = ulRVA; - if (1 != md_set_column_value_as_constant(method, mdtMethodDef_Rva, 1, &rva)) + if (!md_set_column_value_as_constant(method, mdtMethodDef_Rva, rva)) return E_FAIL; // TODO: Update EncLog @@ -926,7 +926,7 @@ HRESULT MetadataEmit::GetTokenFromSig( return E_FAIL; uint32_t sigLength = cbSig; - if (1 != md_set_column_value_as_blob(c, mdtStandAloneSig_Signature, 1, &pvSig, &sigLength)) + if (!md_set_column_value_as_blob(c, mdtStandAloneSig_Signature, pvSig, sigLength)) return E_FAIL; if (!md_cursor_to_token(c, pmsig)) @@ -947,7 +947,7 @@ HRESULT MetadataEmit::DefineModuleRef( pal::StringConvert cvt(szName); char const* name = cvt; - if (1 != md_set_column_value_as_utf8(c, mdtModuleRef_Name, 1, &name)) + if (!md_set_column_value_as_utf8(c, mdtModuleRef_Name, name)) return E_FAIL; if (!md_cursor_to_token(c, pmur)) @@ -966,7 +966,7 @@ HRESULT MetadataEmit::SetParent( if (!md_token_to_cursor(MetaData(), mr, &c)) return CLDB_E_FILE_CORRUPT; - if (1 != md_set_column_value_as_token(c, mdtMemberRef_Class, 1, &tk)) + if (!md_set_column_value_as_token(c, mdtMemberRef_Class, tk)) return E_FAIL; // TODO: Update EncLog @@ -983,7 +983,7 @@ HRESULT MetadataEmit::GetTokenFromTypeSpec( return E_FAIL; uint32_t sigLength = cbSig; - if (1 != md_set_column_value_as_blob(c, mdtTypeSpec_Signature, 1, &pvSig, &sigLength)) + if (!md_set_column_value_as_blob(c, mdtTypeSpec_Signature, pvSig, sigLength)) return E_FAIL; if (!md_cursor_to_token(c, ptypespec)) @@ -1034,50 +1034,50 @@ HRESULT MetadataEmit::DeleteToken( { case mdtTypeDef: { - if (1 != md_set_column_value_as_utf8(c, mdtTypeDef_TypeName, 1, &deletedName)) + if (!md_set_column_value_as_utf8(c, mdtTypeDef_TypeName, deletedName)) return E_FAIL; return AddFlag(MetaData(), tkObj, mdtTypeDef_Flags, tdSpecialName | tdRTSpecialName); } case mdtMethodDef: { - if (1 != md_set_column_value_as_utf8(c, mdtMethodDef_Name, 1, &deletedName)) + if (!md_set_column_value_as_utf8(c, mdtMethodDef_Name, deletedName)) return E_FAIL; return AddFlag(MetaData(), tkObj, mdtMethodDef_Flags, mdSpecialName | mdRTSpecialName); } case mdtFieldDef: { - if (1 != md_set_column_value_as_utf8(c, mdtField_Name, 1, &deletedName)) + if (!md_set_column_value_as_utf8(c, mdtField_Name, deletedName)) return E_FAIL; return AddFlag(MetaData(), tkObj, mdtField_Flags, fdSpecialName | fdRTSpecialName); } case mdtEvent: { - if (1 != md_set_column_value_as_utf8(c, mdtEvent_Name, 1, &deletedName)) + if (!md_set_column_value_as_utf8(c, mdtEvent_Name, deletedName)) return E_FAIL; return AddFlag(MetaData(), tkObj, mdtEvent_EventFlags, evSpecialName | evRTSpecialName); } case mdtProperty: { - if (1 != md_set_column_value_as_utf8(c, mdtProperty_Name, 1, &deletedName)) + if (!md_set_column_value_as_utf8(c, mdtProperty_Name, deletedName)) return E_FAIL; return AddFlag(MetaData(), tkObj, mdtProperty_Flags, prSpecialName | prRTSpecialName); } case mdtExportedType: { - if (1 != md_set_column_value_as_utf8(c, mdtExportedType_TypeName, 1, &deletedName)) + if (!md_set_column_value_as_utf8(c, mdtExportedType_TypeName, deletedName)) return E_FAIL; return S_OK; } case mdtCustomAttribute: { mdToken parent; - if (1 != md_get_column_value_as_token(c, mdtCustomAttribute_Parent, 1, &parent)) + if (!md_get_column_value_as_token(c, mdtCustomAttribute_Parent, &parent)) return E_FAIL; // Change the parent to the nil token. parent = TokenFromRid(mdTokenNil, TypeFromToken(parent)); - if (1 != md_set_column_value_as_token(c, mdtCustomAttribute_Parent, 1, &parent)) + if (!md_set_column_value_as_token(c, mdtCustomAttribute_Parent, parent)) return E_FAIL; return S_OK; @@ -1085,13 +1085,13 @@ HRESULT MetadataEmit::DeleteToken( case mdtGenericParam: { mdToken parent; - if (1 != md_get_column_value_as_token(c, mdtGenericParam_Owner, 1, &parent)) + if (!md_get_column_value_as_token(c, mdtGenericParam_Owner, &parent)) return E_FAIL; // Change the parent to the nil token. parent = TokenFromRid(mdTokenNil, TypeFromToken(parent)); - if (1 != md_set_column_value_as_token(c, mdtGenericParam_Owner, 1, &parent)) + if (!md_set_column_value_as_token(c, mdtGenericParam_Owner, parent)) return E_FAIL; return S_OK; @@ -1099,7 +1099,7 @@ HRESULT MetadataEmit::DeleteToken( case mdtGenericParamConstraint: { mdToken parent = mdGenericParamNil; - if (1 != md_set_column_value_as_token(c, mdtGenericParamConstraint_Owner, 1, &parent)) + if (!md_set_column_value_as_token(c, mdtGenericParamConstraint_Owner, parent)) return E_FAIL; return S_OK; @@ -1107,14 +1107,14 @@ HRESULT MetadataEmit::DeleteToken( case mdtPermission: { mdToken parent; - if (1 != md_get_column_value_as_token(c, mdtDeclSecurity_Parent, 1, &parent)) + if (!md_get_column_value_as_token(c, mdtDeclSecurity_Parent, &parent)) return E_FAIL; // Change the parent to the nil token. mdToken originalParent = parent; parent = TokenFromRid(mdTokenNil, TypeFromToken(parent)); - if (1 != md_set_column_value_as_token(c, mdtDeclSecurity_Parent, 1, &parent)) + if (!md_set_column_value_as_token(c, mdtDeclSecurity_Parent, parent)) return E_FAIL; if (TypeFromToken(originalParent) == mdtAssembly) @@ -1162,21 +1162,21 @@ HRESULT MetadataEmit::SetMethodProps( { // TODO: Strip the reserved flags from user input and preserve the existing reserved flags. uint32_t flags = dwMethodFlags; - if (1 != md_set_column_value_as_constant(c, mdtMethodDef_Flags, 1, &flags)) + if (!md_set_column_value_as_constant(c, mdtMethodDef_Flags, flags)) return E_FAIL; } if (ulCodeRVA != std::numeric_limits::max()) { uint32_t rva = ulCodeRVA; - if (1 != md_set_column_value_as_constant(c, mdtMethodDef_Rva, 1, &rva)) + if (!md_set_column_value_as_constant(c, mdtMethodDef_Rva, rva)) return E_FAIL; } if (dwImplFlags != std::numeric_limits::max()) { uint32_t implFlags = dwImplFlags; - if (1 != md_set_column_value_as_constant(c, mdtMethodDef_ImplFlags, 1, &implFlags)) + if (!md_set_column_value_as_constant(c, mdtMethodDef_ImplFlags, implFlags)) return E_FAIL; } @@ -1198,7 +1198,7 @@ HRESULT MetadataEmit::SetTypeDefProps( { // TODO: Strip the reserved flags from user input and preserve the existing reserved flags. uint32_t flags = dwTypeDefFlags; - if (1 != md_set_column_value_as_constant(c, mdtTypeDef_Flags, 1, &flags)) + if (!md_set_column_value_as_constant(c, mdtTypeDef_Flags, flags)) return E_FAIL; } @@ -1207,7 +1207,7 @@ HRESULT MetadataEmit::SetTypeDefProps( if (IsNilToken(tkExtends)) tkExtends = mdTypeDefNil; - if (1 != md_set_column_value_as_token(c, mdtTypeDef_Extends, 1, &tkExtends)) + if (!md_set_column_value_as_token(c, mdtTypeDef_Extends, tkExtends)) return E_FAIL; } @@ -1225,7 +1225,7 @@ HRESULT MetadataEmit::SetTypeDefProps( for (uint32_t i = 0; i < numInterfaceImpls; ++i) { mdToken parent; - if (1 != md_get_column_value_as_token(interfaceImplCursor, mdtInterfaceImpl_Class, 1, &parent)) + if (!md_get_column_value_as_token(interfaceImplCursor, mdtInterfaceImpl_Class, &parent)) return E_FAIL; // If getting a range was unsupported, then we're doing a whole table scan here. @@ -1234,7 +1234,7 @@ HRESULT MetadataEmit::SetTypeDefProps( if (parent == td) { mdToken newParent = mdTypeDefNil; - if (1 != md_set_column_value_as_token(interfaceImplCursor, mdtInterfaceImpl_Class, 1, &newParent)) + if (!md_set_column_value_as_token(interfaceImplCursor, mdtInterfaceImpl_Class, newParent)) return E_FAIL; } } @@ -1248,10 +1248,10 @@ HRESULT MetadataEmit::SetTypeDefProps( if (!md_append_row(MetaData(), mdtid_InterfaceImpl, &interfaceImpl)) return E_FAIL; - if (1 != md_set_column_value_as_cursor(interfaceImpl, mdtInterfaceImpl_Class, 1, &c)) + if (!md_set_column_value_as_cursor(interfaceImpl, mdtInterfaceImpl_Class, c)) return E_FAIL; - if (1 != md_set_column_value_as_token(interfaceImpl, mdtInterfaceImpl_Interface, 1, ¤tImplementation)) + if (!md_set_column_value_as_token(interfaceImpl, mdtInterfaceImpl_Interface, currentImplementation)) return E_FAIL; } while ((currentImplementation = rtkImplements[++implIndex]) != mdTokenNil); } @@ -1277,17 +1277,17 @@ namespace for (uint32_t i = 0; i < count; ++i, md_cursor_next(&c)) { mdToken association; - if (1 != md_get_column_value_as_token(c, mdtMethodSemantics_Association, 1, &association)) + if (!md_get_column_value_as_token(c, mdtMethodSemantics_Association, &association)) return E_FAIL; uint32_t recordSemantic; - if (1 != md_get_column_value_as_constant(c, mdtMethodSemantics_Semantics, 1, &recordSemantic)) + if (!md_get_column_value_as_constant(c, mdtMethodSemantics_Semantics, &recordSemantic)) return E_FAIL; if (association == parent && recordSemantic == (uint32_t)semantic) { association = TokenFromRid(mdTokenNil, TypeFromToken(association)); - if (1 != md_set_column_value_as_token(c, mdtMethodSemantics_Association, 1, &association)) + if (!md_set_column_value_as_token(c, mdtMethodSemantics_Association, association)) return E_FAIL; } } @@ -1313,13 +1313,13 @@ HRESULT MetadataEmit::SetEventProps( if (dwEventFlags != std::numeric_limits::max()) { uint32_t eventFlags = dwEventFlags; - if (1 != md_set_column_value_as_constant(c, mdtEvent_EventFlags, 1, &eventFlags)) + if (!md_set_column_value_as_constant(c, mdtEvent_EventFlags, eventFlags)) return E_FAIL; } if (!IsNilToken(tkEventType)) { - if (1 != md_set_column_value_as_token(c, mdtEvent_EventType, 1, &tkEventType)) + if (!md_set_column_value_as_token(c, mdtEvent_EventType, tkEventType)) return E_FAIL; } @@ -1377,12 +1377,12 @@ HRESULT MetadataEmit::SetPermissionSetProps( return CLDB_E_RECORD_NOTFOUND; uint32_t action = dwAction; - if (1 != md_set_column_value_as_constant(c, mdtDeclSecurity_Action, 1, &action)) + if (!md_set_column_value_as_constant(c, mdtDeclSecurity_Action, action)) return E_FAIL; uint8_t const* permission = (uint8_t const*)pvPermission; uint32_t permissionLength = cbPermission; - if (1 != md_set_column_value_as_blob(c, mdtDeclSecurity_PermissionSet, 1, &permission, &permissionLength)) + if (!md_set_column_value_as_blob(c, mdtDeclSecurity_PermissionSet, permission, permissionLength)) return E_FAIL; if (!md_cursor_to_token(c, ppm)) @@ -1424,7 +1424,7 @@ HRESULT MetadataEmit::DefinePinvokeMap( return E_FAIL; added_row_wrapper = md_added_row_t(row_to_edit); - if (1 != md_set_column_value_as_token(row_to_edit, mdtImplMap_MemberForwarded, 1, &tk)) + if (!md_set_column_value_as_token(row_to_edit, mdtImplMap_MemberForwarded, tk)) return E_FAIL; if (dwMappingFlags == std::numeric_limits::max()) @@ -1434,12 +1434,12 @@ HRESULT MetadataEmit::DefinePinvokeMap( } uint32_t mappingFlags = dwMappingFlags; - if (1 != md_set_column_value_as_constant(row_to_edit, mdtImplMap_MappingFlags, 1, &mappingFlags)) + if (!md_set_column_value_as_constant(row_to_edit, mdtImplMap_MappingFlags, mappingFlags)) return E_FAIL; pal::StringConvert cvt(szImportName); char const* name = cvt; - if (1 != md_set_column_value_as_utf8(row_to_edit, mdtImplMap_ImportName, 1, &name)) + if (!md_set_column_value_as_utf8(row_to_edit, mdtImplMap_ImportName, name)) return E_FAIL; if (IsNilToken(mrImportDLL)) @@ -1447,7 +1447,7 @@ HRESULT MetadataEmit::DefinePinvokeMap( // TODO: If the token is nil, create a module ref to "" (if it doesn't exist) and use that. } - if (1 != md_set_column_value_as_token(row_to_edit, mdtImplMap_ImportScope, 1, &mrImportDLL)) + if (!md_set_column_value_as_token(row_to_edit, mdtImplMap_ImportScope, mrImportDLL)) return E_FAIL; // TODO: Update EncLog @@ -1476,7 +1476,7 @@ HRESULT MetadataEmit::SetPinvokeMap( if (dwMappingFlags != std::numeric_limits::max()) { uint32_t mappingFlags = dwMappingFlags; - if (1 != md_set_column_value_as_constant(row_to_edit, mdtImplMap_MappingFlags, 1, &mappingFlags)) + if (!md_set_column_value_as_constant(row_to_edit, mdtImplMap_MappingFlags, mappingFlags)) return E_FAIL; } @@ -1484,11 +1484,11 @@ HRESULT MetadataEmit::SetPinvokeMap( { pal::StringConvert cvt(szImportName); char const* name = cvt; - if (1 != md_set_column_value_as_utf8(row_to_edit, mdtImplMap_ImportName, 1, &name)) + if (!md_set_column_value_as_utf8(row_to_edit, mdtImplMap_ImportName, name)) return E_FAIL; } - if (1 != md_set_column_value_as_token(row_to_edit, mdtImplMap_ImportScope, 1, &mrImportDLL)) + if (!md_set_column_value_as_token(row_to_edit, mdtImplMap_ImportScope, mrImportDLL)) return E_FAIL; // TODO: Update EncLog @@ -1543,15 +1543,15 @@ HRESULT MetadataEmit::DefineCustomAttribute( if (!md_append_row(MetaData(), mdtid_CustomAttribute, &new_row)) return E_FAIL; - if (1 != md_set_column_value_as_token(new_row, mdtCustomAttribute_Parent, 1, &tkOwner)) + if (!md_set_column_value_as_token(new_row, mdtCustomAttribute_Parent, tkOwner)) return E_FAIL; - if (1 != md_set_column_value_as_token(new_row, mdtCustomAttribute_Type, 1, &tkCtor)) + if (!md_set_column_value_as_token(new_row, mdtCustomAttribute_Type, tkCtor)) return E_FAIL; uint8_t const* pCustomAttributeBlob = (uint8_t const*)pCustomAttribute; uint32_t customAttributeBlobLen = cbCustomAttribute; - if (1 != md_set_column_value_as_blob(new_row, mdtCustomAttribute_Value, 1, &pCustomAttributeBlob, &customAttributeBlobLen)) + if (!md_set_column_value_as_blob(new_row, mdtCustomAttribute_Value, pCustomAttributeBlob, customAttributeBlobLen)) return E_FAIL; if (!md_cursor_to_token(new_row, pcv)) @@ -1575,7 +1575,7 @@ HRESULT MetadataEmit::SetCustomAttributeValue( uint8_t const* pCustomAttributeBlob = (uint8_t const*)pCustomAttribute; uint32_t customAttributeBlobLen = cbCustomAttribute; - if (1 != md_set_column_value_as_blob(c, mdtCustomAttribute_Value, 1, &pCustomAttributeBlob, &customAttributeBlobLen)) + if (!md_set_column_value_as_blob(c, mdtCustomAttribute_Value, pCustomAttributeBlob, customAttributeBlobLen)) return E_FAIL; // TODO: Update EncLog @@ -1669,7 +1669,7 @@ HRESULT MetadataEmit::DefineField( if (!md_add_new_row_to_list(typeDef, mdtTypeDef_FieldList, &c)) return E_FAIL; - if (1 != md_set_column_value_as_utf8(c, mdtField_Name, 1, &name)) + if (!md_set_column_value_as_utf8(c, mdtField_Name, name)) return E_FAIL; bool hasConstant = false; @@ -1694,7 +1694,7 @@ HRESULT MetadataEmit::DefineField( { fieldFlags |= fdRTSpecialName | fdSpecialName; } - if (1 != md_set_column_value_as_constant(c, mdtField_Flags, 1, &fieldFlags)) + if (!md_set_column_value_as_constant(c, mdtField_Flags, fieldFlags)) return E_FAIL; } else @@ -1708,7 +1708,7 @@ HRESULT MetadataEmit::DefineField( { fieldFlags |= fdRTSpecialName | fdSpecialName; } - if (1 != md_set_column_value_as_constant(c, mdtField_Flags, 1, &fieldFlags)) + if (!md_set_column_value_as_constant(c, mdtField_Flags, fieldFlags)) return E_FAIL; } @@ -1716,7 +1716,7 @@ HRESULT MetadataEmit::DefineField( uint32_t sigLength = cbSigBlob; if (sigLength != 0) { - if (1 != md_set_column_value_as_blob(c, mdtField_Signature, 1, &sig, &sigLength)) + if (!md_set_column_value_as_blob(c, mdtField_Signature, sig, sigLength)) return E_FAIL; } @@ -1726,11 +1726,11 @@ HRESULT MetadataEmit::DefineField( if (!md_append_row(MetaData(), mdtid_Constant, &constant)) return E_FAIL; - if (1 != md_set_column_value_as_cursor(constant, mdtConstant_Parent, 1, &c)) + if (!md_set_column_value_as_cursor(constant, mdtConstant_Parent, c)) return E_FAIL; uint32_t type = dwCPlusTypeFlag; - if (1 != md_set_column_value_as_constant(constant, mdtConstant_Type, 1, &type)) + if (!md_set_column_value_as_constant(constant, mdtConstant_Type, type)) return E_FAIL; uint64_t defaultConstantValue = 0; @@ -1739,7 +1739,7 @@ HRESULT MetadataEmit::DefineField( pConstantValue = (uint8_t const*)&defaultConstantValue; uint32_t constantSize = GetSizeOfConstantBlob(dwCPlusTypeFlag, pConstantValue, cchValue); - if (1 != md_set_column_value_as_blob(constant, mdtConstant_Value, 1, &pConstantValue, &constantSize)) + if (!md_set_column_value_as_blob(constant, mdtConstant_Value, pConstantValue, constantSize)) return E_FAIL; } @@ -1782,7 +1782,7 @@ HRESULT MetadataEmit::DefineProperty( return E_INVALIDARG; char const* name = cvt; - if (1 != md_set_column_value_as_utf8(c, mdtProperty_Name, 1, &name)) + if (!md_set_column_value_as_utf8(c, mdtProperty_Name, name)) return E_FAIL; @@ -1790,7 +1790,7 @@ HRESULT MetadataEmit::DefineProperty( { uint8_t const* sig = (uint8_t const*)pvSig; uint32_t sigLength = cbSig; - if (1 != md_set_column_value_as_blob(c, mdtProperty_Type, 1, &sig, &sigLength)) + if (!md_set_column_value_as_blob(c, mdtProperty_Type, sig, sigLength)) return E_FAIL; } @@ -1817,7 +1817,7 @@ HRESULT MetadataEmit::DefineProperty( hasConstant = true; } - if (1 != md_set_column_value_as_constant(c, mdtProperty_Flags, 1, &propFlags)) + if (!md_set_column_value_as_constant(c, mdtProperty_Flags, propFlags)) return E_FAIL; if (mdGetter != mdMethodDefNil) @@ -1844,11 +1844,11 @@ HRESULT MetadataEmit::DefineProperty( if (!md_append_row(MetaData(), mdtid_Constant, &constant)) return E_FAIL; - if (1 != md_set_column_value_as_cursor(constant, mdtConstant_Parent, 1, &c)) + if (!md_set_column_value_as_cursor(constant, mdtConstant_Parent, c)) return E_FAIL; uint32_t type = dwCPlusTypeFlag; - if (1 != md_set_column_value_as_constant(constant, mdtConstant_Type, 1, &type)) + if (!md_set_column_value_as_constant(constant, mdtConstant_Type, type)) return E_FAIL; uint64_t defaultConstantValue = 0; @@ -1857,7 +1857,7 @@ HRESULT MetadataEmit::DefineProperty( pConstantValue = (uint8_t const*)&defaultConstantValue; uint32_t constantSize = GetSizeOfConstantBlob(dwCPlusTypeFlag, pConstantValue, cchValue); - if (1 != md_set_column_value_as_blob(constant, mdtConstant_Value, 1, &pConstantValue, &constantSize)) + if (!md_set_column_value_as_blob(constant, mdtConstant_Value, pConstantValue, constantSize)) return E_FAIL; } @@ -1895,7 +1895,7 @@ HRESULT MetadataEmit::DefineParam( if (!md_add_new_row_to_sorted_list(method, mdtMethodDef_ParamList, mdtParam_Sequence, (uint32_t)ulParamSeq, &c)) return E_FAIL; - if (1 != md_set_column_value_as_utf8(c, mdtParam_Name, 1, &name)) + if (!md_set_column_value_as_utf8(c, mdtParam_Name, name)) return E_FAIL; bool hasConstant = false; @@ -1913,13 +1913,13 @@ HRESULT MetadataEmit::DefineParam( // TODO: Handle reserved flags uint32_t flags = dwParamFlags; - if (1 != md_set_column_value_as_constant(c, mdtParam_Flags, 1, &flags)) + if (!md_set_column_value_as_constant(c, mdtParam_Flags, flags)) return E_FAIL; } else { uint32_t flags = 0; - if (1 != md_set_column_value_as_constant(c, mdtParam_Flags, 1, &flags)) + if (!md_set_column_value_as_constant(c, mdtParam_Flags, flags)) return E_FAIL; } @@ -1929,11 +1929,11 @@ HRESULT MetadataEmit::DefineParam( if (!md_append_row(MetaData(), mdtid_Constant, &constant)) return E_FAIL; - if (1 != md_set_column_value_as_cursor(constant, mdtConstant_Parent, 1, &c)) + if (!md_set_column_value_as_cursor(constant, mdtConstant_Parent, c)) return E_FAIL; uint32_t type = dwCPlusTypeFlag; - if (1 != md_set_column_value_as_constant(constant, mdtConstant_Type, 1, &type)) + if (!md_set_column_value_as_constant(constant, mdtConstant_Type, type)) return E_FAIL; uint64_t defaultConstantValue = 0; @@ -1942,7 +1942,7 @@ HRESULT MetadataEmit::DefineParam( pConstantValue = (uint8_t const*)&defaultConstantValue; uint32_t constantSize = GetSizeOfConstantBlob(dwCPlusTypeFlag, pConstantValue, cchValue); - if (1 != md_set_column_value_as_blob(constant, mdtConstant_Value, 1, &pConstantValue, &constantSize)) + if (!md_set_column_value_as_blob(constant, mdtConstant_Value, pConstantValue, constantSize)) return E_FAIL; } @@ -1979,7 +1979,7 @@ HRESULT MetadataEmit::SetFieldProps( { // TODO: Handle reserved flags uint32_t fieldFlags = dwFieldFlags; - if (1 != md_set_column_value_as_constant(c, mdtField_Flags, 1, &fieldFlags)) + if (!md_set_column_value_as_constant(c, mdtField_Flags, fieldFlags)) return E_FAIL; } @@ -1989,7 +1989,7 @@ HRESULT MetadataEmit::SetFieldProps( return FindOrCreateParentedRow(MetaData(), fd, mdtid_Constant, mdtConstant_Parent, [=](mdcursor_t constant) { uint32_t type = dwCPlusTypeFlag; - if (1 != md_set_column_value_as_constant(constant, mdtConstant_Type, 1, &type)) + if (!md_set_column_value_as_constant(constant, mdtConstant_Type, type)) return E_FAIL; uint64_t defaultConstantValue = 0; @@ -1998,7 +1998,7 @@ HRESULT MetadataEmit::SetFieldProps( pConstantValue = (uint8_t const*)&defaultConstantValue; uint32_t constantSize = GetSizeOfConstantBlob(dwCPlusTypeFlag, pConstantValue, cchValue); - if (1 != md_set_column_value_as_blob(constant, mdtConstant_Value, 1, &pConstantValue, &constantSize)) + if (!md_set_column_value_as_blob(constant, mdtConstant_Value, pConstantValue, constantSize)) return E_FAIL; return S_OK; @@ -2044,7 +2044,7 @@ HRESULT MetadataEmit::SetPropertyProps( { // TODO: Preserve reserved flags uint32_t flags = dwPropFlags; - if (1 != md_set_column_value_as_constant(c, mdtProperty_Flags, 1, &flags)) + if (!md_set_column_value_as_constant(c, mdtProperty_Flags, flags)) return E_FAIL; } @@ -2075,7 +2075,7 @@ HRESULT MetadataEmit::SetPropertyProps( return FindOrCreateParentedRow(MetaData(), pr, mdtid_Constant, mdtConstant_Parent, [=](mdcursor_t constant) { uint32_t type = dwCPlusTypeFlag; - if (1 != md_set_column_value_as_constant(constant, mdtConstant_Type, 1, &type)) + if (!md_set_column_value_as_constant(constant, mdtConstant_Type, type)) return E_FAIL; uint64_t defaultConstantValue = 0; @@ -2084,7 +2084,7 @@ HRESULT MetadataEmit::SetPropertyProps( pConstantValue = (uint8_t const*)&defaultConstantValue; uint32_t constantSize = GetSizeOfConstantBlob(dwCPlusTypeFlag, pConstantValue, cchValue); - if (1 != md_set_column_value_as_blob(constant, mdtConstant_Value, 1, &pConstantValue, &constantSize)) + if (!md_set_column_value_as_blob(constant, mdtConstant_Value, pConstantValue, constantSize)) return E_FAIL; return S_OK; @@ -2113,7 +2113,7 @@ HRESULT MetadataEmit::SetParamProps( return E_INVALIDARG; char const* name = cvt; - if (1 != md_set_column_value_as_utf8(c, mdtParam_Name, 1, &name)) + if (!md_set_column_value_as_utf8(c, mdtParam_Name, name)) return E_FAIL; bool hasConstant = false; @@ -2130,7 +2130,7 @@ HRESULT MetadataEmit::SetParamProps( { // TODO: Handle reserved flags uint32_t flags = dwParamFlags; - if (1 != md_set_column_value_as_constant(c, mdtParam_Flags, 1, &flags)) + if (!md_set_column_value_as_constant(c, mdtParam_Flags, flags)) return E_FAIL; } @@ -2140,7 +2140,7 @@ HRESULT MetadataEmit::SetParamProps( return FindOrCreateParentedRow(MetaData(), pd, mdtid_Constant, mdtConstant_Parent, [=](mdcursor_t constant) { uint32_t type = dwCPlusTypeFlag; - if (1 != md_set_column_value_as_constant(constant, mdtConstant_Type, 1, &type)) + if (!md_set_column_value_as_constant(constant, mdtConstant_Type, type)) return E_FAIL; uint64_t defaultConstantValue = 0; @@ -2149,7 +2149,7 @@ HRESULT MetadataEmit::SetParamProps( pConstantValue = (uint8_t const*)&defaultConstantValue; uint32_t constantSize = GetSizeOfConstantBlob(dwCPlusTypeFlag, pConstantValue, cchValue); - if (1 != md_set_column_value_as_blob(constant, mdtConstant_Value, 1, &pConstantValue, &constantSize)) + if (!md_set_column_value_as_blob(constant, mdtConstant_Value, pConstantValue, constantSize)) return E_FAIL; return S_OK; @@ -2220,7 +2220,7 @@ HRESULT MetadataEmit::TranslateSigWithScope( minipal::com_ptr moduleEmit{}; RETURN_IF_FAILED(emit->QueryInterface(IID_IDNMDOwner, (void**)&moduleEmit)); - malloc_span translatedSig; + inline_span translatedSig; RETURN_IF_FAILED(ImportSignatureIntoModule( assemImport->MetaData(), moduleImport->MetaData(), @@ -2246,7 +2246,7 @@ HRESULT MetadataEmit::SetMethodImplFlags( return E_INVALIDARG; uint32_t flags = (uint32_t)dwImplFlags; - if (1 != md_set_column_value_as_constant(c, mdtMethodDef_ImplFlags, 1, &flags)) + if (!md_set_column_value_as_constant(c, mdtMethodDef_ImplFlags, flags)) return E_FAIL; // TODO: Update ENC log @@ -2261,7 +2261,7 @@ HRESULT MetadataEmit::SetFieldRVA( HRESULT hr = FindOrCreateParentedRow(MetaData(), fd, mdtid_FieldRva, mdtFieldRva_Field, [=](mdcursor_t c) { - if (1 != md_set_column_value_as_constant(c, mdtFieldRva_Rva, 1, &rva)) + if (!md_set_column_value_as_constant(c, mdtFieldRva_Rva, rva)) return E_FAIL; return S_OK; @@ -2274,11 +2274,11 @@ HRESULT MetadataEmit::SetFieldRVA( return E_INVALIDARG; uint32_t flags; - if (1 != md_get_column_value_as_constant(field, mdtField_Flags, 1, &flags)) + if (!md_get_column_value_as_constant(field, mdtField_Flags, &flags)) return CLDB_E_FILE_CORRUPT; flags |= fdHasFieldRVA; - if (1 != md_set_column_value_as_constant(field, mdtField_Flags, 1, &flags)) + if (!md_set_column_value_as_constant(field, mdtField_Flags, flags)) return E_FAIL; // TODO: Update ENC log @@ -2320,11 +2320,11 @@ HRESULT MetadataEmit::DefineMethodSpec( if (!md_append_row(MetaData(), mdtid_MethodSpec, &c)) return E_FAIL; - if (1 != md_set_column_value_as_token(c, mdtMethodSpec_Method, 1, &tkParent)) + if (!md_set_column_value_as_token(c, mdtMethodSpec_Method, tkParent)) return E_FAIL; uint32_t sigLength = cbSigBlob; - if (1 != md_set_column_value_as_blob(c, mdtMethodSpec_Instantiation, 1, &pvSigBlob, &sigLength)) + if (!md_set_column_value_as_blob(c, mdtMethodSpec_Instantiation, pvSigBlob, sigLength)) return E_FAIL; if (!md_cursor_to_token(c, pmi)) @@ -2394,15 +2394,15 @@ HRESULT MetadataEmit::DefineGenericParam( if (!md_append_row(MetaData(), mdtid_GenericParam, &c)) return E_FAIL; - if (1 != md_set_column_value_as_token(c, mdtGenericParam_Owner, 1, &tk)) + if (!md_set_column_value_as_token(c, mdtGenericParam_Owner, tk)) return E_FAIL; uint32_t paramSeq = ulParamSeq; - if (1 != md_set_column_value_as_constant(c, mdtGenericParam_Number, 1, ¶mSeq)) + if (!md_set_column_value_as_constant(c, mdtGenericParam_Number, paramSeq)) return E_FAIL; uint32_t flags = dwParamFlags; - if (1 != md_set_column_value_as_constant(c, mdtGenericParam_Flags, 1, &flags)) + if (!md_set_column_value_as_constant(c, mdtGenericParam_Flags, flags)) return E_FAIL; if (szname != nullptr) @@ -2412,13 +2412,13 @@ HRESULT MetadataEmit::DefineGenericParam( return E_INVALIDARG; char const* name = cvt; - if (1 != md_set_column_value_as_utf8(c, mdtGenericParam_Name, 1, &name)) + if (!md_set_column_value_as_utf8(c, mdtGenericParam_Name, name)) return E_FAIL; } else { char const* name = nullptr; - if (1 != md_set_column_value_as_utf8(c, mdtGenericParam_Name, 1, &name)) + if (!md_set_column_value_as_utf8(c, mdtGenericParam_Name, name)) return E_FAIL; } @@ -2430,10 +2430,10 @@ HRESULT MetadataEmit::DefineGenericParam( if (!md_append_row(MetaData(), mdtid_GenericParamConstraint, &added_row)) return E_FAIL; - if (1 != md_set_column_value_as_cursor(added_row, mdtGenericParamConstraint_Owner, 1, &c)) + if (!md_set_column_value_as_cursor(added_row, mdtGenericParamConstraint_Owner, c)) return E_FAIL; - if (1 != md_set_column_value_as_token(added_row, mdtGenericParamConstraint_Constraint, 1, &rtkConstraints[i])) + if (md_set_column_value_as_token(added_row, mdtGenericParamConstraint_Constraint, rtkConstraints[i])) return E_FAIL; // TODO: Update EncLog @@ -2462,7 +2462,7 @@ HRESULT MetadataEmit::SetGenericParamProps( return E_INVALIDARG; uint32_t flags = dwParamFlags; - if (1 != md_set_column_value_as_constant(c, mdtGenericParam_Flags, 1, &flags)) + if (!md_set_column_value_as_constant(c, mdtGenericParam_Flags, flags)) return E_FAIL; if (szName != nullptr) @@ -2472,7 +2472,7 @@ HRESULT MetadataEmit::SetGenericParamProps( return E_INVALIDARG; char const* name = cvt; - if (1 != md_set_column_value_as_utf8(c, mdtGenericParam_Name, 1, &name)) + if (!md_set_column_value_as_utf8(c, mdtGenericParam_Name, name)) return E_FAIL; } @@ -2490,13 +2490,13 @@ HRESULT MetadataEmit::SetGenericParamProps( for (uint32_t i = 0; i < count; ++i, md_cursor_next(&constraint)) { mdToken parent; - if (1 != md_get_column_value_as_token(constraint, mdtGenericParamConstraint_Owner, 1, &parent)) + if (!md_get_column_value_as_token(constraint, mdtGenericParamConstraint_Owner, &parent)) return E_FAIL; if (parent == gp) { parent = mdGenericParamNil; - if (1 != md_set_column_value_as_token(constraint, mdtGenericParamConstraint_Owner, 1, &parent)) + if (!md_set_column_value_as_token(constraint, mdtGenericParamConstraint_Owner, parent)) return E_FAIL; } } @@ -2508,10 +2508,10 @@ HRESULT MetadataEmit::SetGenericParamProps( if (!md_append_row(MetaData(), mdtid_GenericParamConstraint, &added_row)) return E_FAIL; - if (1 != md_set_column_value_as_cursor(added_row, mdtGenericParamConstraint_Owner, 1, &c)) + if (!md_set_column_value_as_cursor(added_row, mdtGenericParamConstraint_Owner, c)) return E_FAIL; - if (1 != md_set_column_value_as_token(added_row, mdtGenericParamConstraint_Constraint, 1, &rtkConstraints[i])) + if (md_set_column_value_as_token(added_row, mdtGenericParamConstraint_Constraint, rtkConstraints[i])) return E_FAIL; // TODO: Update EncLog @@ -2568,41 +2568,41 @@ HRESULT MetadataEmit::DefineAssembly( if (publicKey != nullptr) { uint32_t publicKeyLength = cbPublicKey; - if (1 != md_set_column_value_as_blob(c, mdtAssembly_PublicKey, 1, &publicKey, &publicKeyLength)) + if (!md_set_column_value_as_blob(c, mdtAssembly_PublicKey, publicKey, publicKeyLength)) return E_FAIL; } else { uint32_t publicKeyLength = 0; - if (1 != md_set_column_value_as_blob(c, mdtAssembly_PublicKey, 1, &publicKey, &publicKeyLength)) + if (!md_set_column_value_as_blob(c, mdtAssembly_PublicKey, publicKey, publicKeyLength)) return E_FAIL; } - if (1 != md_set_column_value_as_constant(c, mdtAssembly_Flags, 1, &assemblyFlags)) + if (!md_set_column_value_as_constant(c, mdtAssembly_Flags, assemblyFlags)) return E_FAIL; char const* name = cvt; - if (1 != md_set_column_value_as_utf8(c, mdtAssembly_Name, 1, &name)) + if (!md_set_column_value_as_utf8(c, mdtAssembly_Name, name)) return E_FAIL; uint32_t hashAlgId = ulHashAlgId; - if (1 != md_set_column_value_as_constant(c, mdtAssembly_HashAlgId, 1, &hashAlgId)) + if (!md_set_column_value_as_constant(c, mdtAssembly_HashAlgId, hashAlgId)) return E_FAIL; uint32_t majorVersion = pMetaData->usMajorVersion != std::numeric_limits::max() ? pMetaData->usMajorVersion : 0; - if (1 != md_set_column_value_as_constant(c, mdtAssembly_MajorVersion, 1, &majorVersion)) + if (!md_set_column_value_as_constant(c, mdtAssembly_MajorVersion, majorVersion)) return E_FAIL; uint32_t minorVersion = pMetaData->usMinorVersion != std::numeric_limits::max() ? pMetaData->usMinorVersion : 0; - if (1 != md_set_column_value_as_constant(c, mdtAssembly_MinorVersion, 1, &minorVersion)) + if (!md_set_column_value_as_constant(c, mdtAssembly_MinorVersion, minorVersion)) return E_FAIL; uint32_t buildNumber = pMetaData->usBuildNumber != std::numeric_limits::max() ? pMetaData->usBuildNumber : 0; - if (1 != md_set_column_value_as_constant(c, mdtAssembly_BuildNumber, 1, &buildNumber)) + if (!md_set_column_value_as_constant(c, mdtAssembly_BuildNumber, buildNumber)) return E_FAIL; uint32_t revisionNumber = pMetaData->usRevisionNumber != std::numeric_limits::max() ? pMetaData->usRevisionNumber : 0; - if (1 != md_set_column_value_as_constant(c, mdtAssembly_RevisionNumber, 1, &revisionNumber)) + if (!md_set_column_value_as_constant(c, mdtAssembly_RevisionNumber, revisionNumber)) return E_FAIL; if (pMetaData->szLocale != nullptr) @@ -2612,13 +2612,13 @@ HRESULT MetadataEmit::DefineAssembly( return E_INVALIDARG; char const* locale = cvtLocale; - if (1 != md_set_column_value_as_utf8(c, mdtAssembly_Culture, 1, &locale)) + if (!md_set_column_value_as_utf8(c, mdtAssembly_Culture, locale)) return E_FAIL; } else { char const* locale = nullptr; - if (1 != md_set_column_value_as_utf8(c, mdtAssembly_Culture, 1, &locale)) + if (!md_set_column_value_as_utf8(c, mdtAssembly_Culture, locale)) return E_FAIL; } @@ -2655,13 +2655,13 @@ HRESULT MetadataEmit::DefineAssemblyRef( if (publicKey != nullptr) { uint32_t publicKeyLength = cbPublicKeyOrToken; - if (1 != md_set_column_value_as_blob(c, mdtAssemblyRef_PublicKeyOrToken, 1, &publicKey, &publicKeyLength)) + if (!md_set_column_value_as_blob(c, mdtAssemblyRef_PublicKeyOrToken, publicKey, publicKeyLength)) return E_FAIL; } else { uint32_t publicKeyLength = 0; - if (1 != md_set_column_value_as_blob(c, mdtAssemblyRef_PublicKeyOrToken, 1, &publicKey, &publicKeyLength)) + if (!md_set_column_value_as_blob(c, mdtAssemblyRef_PublicKeyOrToken, publicKey, publicKeyLength)) return E_FAIL; } @@ -2669,39 +2669,39 @@ HRESULT MetadataEmit::DefineAssemblyRef( { uint8_t const* hashValue = (uint8_t const*)pbHashValue; uint32_t hashValueLength = cbHashValue; - if (1 != md_set_column_value_as_blob(c, mdtAssemblyRef_HashValue, 1, &hashValue, &hashValueLength)) + if (!md_set_column_value_as_blob(c, mdtAssemblyRef_HashValue, hashValue, hashValueLength)) return E_FAIL; } else { uint8_t const* hashValue = nullptr; uint32_t hashValueLength = 0; - if (1 != md_set_column_value_as_blob(c, mdtAssemblyRef_HashValue, 1, &hashValue, &hashValueLength)) + if (!md_set_column_value_as_blob(c, mdtAssemblyRef_HashValue, hashValue, hashValueLength)) return E_FAIL; } uint32_t assemblyFlags = PrepareForSaving(dwAssemblyRefFlags); - if (1 != md_set_column_value_as_constant(c, mdtAssemblyRef_Flags, 1, &assemblyFlags)) + if (!md_set_column_value_as_constant(c, mdtAssemblyRef_Flags, assemblyFlags)) return E_FAIL; char const* name = cvt; - if (1 != md_set_column_value_as_utf8(c, mdtAssemblyRef_Name, 1, &name)) + if (!md_set_column_value_as_utf8(c, mdtAssemblyRef_Name, name)) return E_FAIL; uint32_t majorVersion = pMetaData->usMajorVersion != std::numeric_limits::max() ? pMetaData->usMajorVersion : 0; - if (1 != md_set_column_value_as_constant(c, mdtAssemblyRef_MajorVersion, 1, &majorVersion)) + if (!md_set_column_value_as_constant(c, mdtAssemblyRef_MajorVersion, majorVersion)) return E_FAIL; uint32_t minorVersion = pMetaData->usMinorVersion != std::numeric_limits::max() ? pMetaData->usMinorVersion : 0; - if (1 != md_set_column_value_as_constant(c, mdtAssemblyRef_MinorVersion, 1, &minorVersion)) + if (!md_set_column_value_as_constant(c, mdtAssemblyRef_MinorVersion, minorVersion)) return E_FAIL; uint32_t buildNumber = pMetaData->usBuildNumber != std::numeric_limits::max() ? pMetaData->usBuildNumber : 0; - if (1 != md_set_column_value_as_constant(c, mdtAssemblyRef_BuildNumber, 1, &buildNumber)) + if (!md_set_column_value_as_constant(c, mdtAssemblyRef_BuildNumber, buildNumber)) return E_FAIL; uint32_t revisionNumber = pMetaData->usRevisionNumber != std::numeric_limits::max() ? pMetaData->usRevisionNumber : 0; - if (1 != md_set_column_value_as_constant(c, mdtAssemblyRef_RevisionNumber, 1, &revisionNumber)) + if (!md_set_column_value_as_constant(c, mdtAssemblyRef_RevisionNumber, revisionNumber)) return E_FAIL; if (pMetaData->szLocale != nullptr) @@ -2711,13 +2711,13 @@ HRESULT MetadataEmit::DefineAssemblyRef( return E_INVALIDARG; char const* locale = cvtLocale; - if (1 != md_set_column_value_as_utf8(c, mdtAssemblyRef_Culture, 1, &locale)) + if (!md_set_column_value_as_utf8(c, mdtAssemblyRef_Culture, locale)) return E_FAIL; } else { char const* locale = nullptr; - if (1 != md_set_column_value_as_utf8(c, mdtAssemblyRef_Culture, 1, &locale)) + if (!md_set_column_value_as_utf8(c, mdtAssemblyRef_Culture, locale)) return E_FAIL; } @@ -2748,26 +2748,26 @@ HRESULT MetadataEmit::DefineFile( char const* name = cvt; - if (1 != md_set_column_value_as_utf8(c, mdtFile_Name, 1, &name)) + if (!md_set_column_value_as_utf8(c, mdtFile_Name, name)) return E_FAIL; if (pbHashValue != nullptr) { uint8_t const* hashValue = (uint8_t const*)pbHashValue; uint32_t hashValueLength = cbHashValue; - if (1 != md_set_column_value_as_blob(c, mdtFile_HashValue, 1, &hashValue, &hashValueLength)) + if (!md_set_column_value_as_blob(c, mdtFile_HashValue, hashValue, hashValueLength)) return E_FAIL; } else { uint8_t const* hashValue = nullptr; uint32_t hashValueLength = 0; - if (1 != md_set_column_value_as_blob(c, mdtFile_HashValue, 1, &hashValue, &hashValueLength)) + if (!md_set_column_value_as_blob(c, mdtFile_HashValue, hashValue, hashValueLength)) return E_FAIL; } uint32_t fileFlags = dwFileFlags != std::numeric_limits::max() ? dwFileFlags : 0; - if (1 != md_set_column_value_as_constant(c, mdtFile_Flags, 1, &fileFlags)) + if (!md_set_column_value_as_constant(c, mdtFile_Flags, fileFlags)) return E_FAIL; if (!md_cursor_to_token(c, pmdf)) @@ -2796,14 +2796,14 @@ HRESULT MetadataEmit::DefineExportedType( char const* ns; char const* name; SplitTypeName(cvt, &ns, &name); - if (1 != md_set_column_value_as_utf8(c, mdtExportedType_TypeNamespace, 1, &ns)) + if (!md_set_column_value_as_utf8(c, mdtExportedType_TypeNamespace, ns)) return E_FAIL; - if (1 != md_set_column_value_as_utf8(c, mdtExportedType_TypeName, 1, &name)) + if (!md_set_column_value_as_utf8(c, mdtExportedType_TypeName, name)) return E_FAIL; if (!IsNilToken(tkImplementation)) { - if (1 != md_set_column_value_as_token(c, mdtExportedType_Implementation, 1, &tkImplementation)) + if (!md_set_column_value_as_token(c, mdtExportedType_Implementation, tkImplementation)) return E_FAIL; } else @@ -2811,24 +2811,24 @@ HRESULT MetadataEmit::DefineExportedType( // COMPAT: When the implementation column isn't defined, it is defaulted to the 0 value. // For the Implementation coded index, the nil File token is the 0 value; mdToken nilToken = mdFileNil; - if (1 != md_set_column_value_as_token(c, mdtExportedType_Implementation, 1, &nilToken)) + if (!md_set_column_value_as_token(c, mdtExportedType_Implementation, nilToken)) return E_FAIL; } if (!IsNilToken(tkTypeDef)) { - if (1 != md_set_column_value_as_constant(c, mdtExportedType_TypeDefId, 1, &tkTypeDef)) + if (!md_set_column_value_as_constant(c, mdtExportedType_TypeDefId, tkTypeDef)) return E_FAIL; } else { mdToken nilToken = 0; - if (1 != md_set_column_value_as_constant(c, mdtExportedType_TypeDefId, 1, &nilToken)) + if (!md_set_column_value_as_constant(c, mdtExportedType_TypeDefId, nilToken)) return E_FAIL; } uint32_t exportedTypeFlags = dwExportedTypeFlags != std::numeric_limits::max() ? dwExportedTypeFlags : 0; - if (1 != md_set_column_value_as_constant(c, mdtExportedType_Flags, 1, &exportedTypeFlags)) + if (!md_set_column_value_as_constant(c, mdtExportedType_Flags, exportedTypeFlags)) return E_FAIL; if (!md_cursor_to_token(c, pmdct)) @@ -2855,12 +2855,12 @@ HRESULT MetadataEmit::DefineManifestResource( return E_INVALIDARG; char const* name = cvt; - if (1 != md_set_column_value_as_utf8(c, mdtManifestResource_Name, 1, &name)) + if (!md_set_column_value_as_utf8(c, mdtManifestResource_Name, name)) return E_FAIL; if (!IsNilToken(tkImplementation)) { - if (1 != md_set_column_value_as_token(c, mdtManifestResource_Implementation, 1, &tkImplementation)) + if (!md_set_column_value_as_token(c, mdtManifestResource_Implementation, tkImplementation)) return E_FAIL; } else @@ -2868,16 +2868,16 @@ HRESULT MetadataEmit::DefineManifestResource( // COMPAT: When the implementation column isn't defined, it is defaulted to the 0 value. // For the Implementation coded index, the nil File token is the 0 value; mdToken nilToken = mdFileNil; - if (1 != md_set_column_value_as_token(c, mdtManifestResource_Implementation, 1, &nilToken)) + if (!md_set_column_value_as_token(c, mdtManifestResource_Implementation, nilToken)) return E_FAIL; } uint32_t offset = dwOffset != std::numeric_limits::max() ? dwOffset : 0; - if (1 != md_set_column_value_as_constant(c, mdtManifestResource_Offset, 1, &offset)) + if (!md_set_column_value_as_constant(c, mdtManifestResource_Offset, offset)) return E_FAIL; uint32_t resourceFlags = dwResourceFlags != std::numeric_limits::max() ? dwResourceFlags : 0; - if (1 != md_set_column_value_as_constant(c, mdtManifestResource_Flags, 1, &resourceFlags)) + if (!md_set_column_value_as_constant(c, mdtManifestResource_Flags, resourceFlags)) return E_FAIL; if (!md_cursor_to_token(c, pmdmr)) @@ -2910,11 +2910,11 @@ HRESULT MetadataEmit::SetAssemblyProps( if (publicKey != nullptr) { uint32_t publicKeyLength = cbPublicKey; - if (1 != md_set_column_value_as_blob(c, mdtAssembly_PublicKey, 1, &publicKey, &publicKeyLength)) + if (!md_set_column_value_as_blob(c, mdtAssembly_PublicKey, publicKey, publicKeyLength)) return E_FAIL; } - if (1 != md_set_column_value_as_constant(c, mdtAssembly_Flags, 1, &assemblyFlags)) + if (!md_set_column_value_as_constant(c, mdtAssembly_Flags, assemblyFlags)) return E_FAIL; if (szName != nullptr) @@ -2924,42 +2924,42 @@ HRESULT MetadataEmit::SetAssemblyProps( return E_INVALIDARG; char const* name = cvt; - if (1 != md_set_column_value_as_utf8(c, mdtAssembly_Name, 1, &name)) + if (!md_set_column_value_as_utf8(c, mdtAssembly_Name, name)) return E_FAIL; } if (ulHashAlgId != std::numeric_limits::max()) { uint32_t hashAlgId = ulHashAlgId; - if (1 != md_set_column_value_as_constant(c, mdtAssembly_HashAlgId, 1, &hashAlgId)) + if (!md_set_column_value_as_constant(c, mdtAssembly_HashAlgId, hashAlgId)) return E_FAIL; } if (pMetaData->usMajorVersion != std::numeric_limits::max()) { uint32_t majorVersion = pMetaData->usMajorVersion; - if (1 != md_set_column_value_as_constant(c, mdtAssembly_MajorVersion, 1, &majorVersion)) + if (!md_set_column_value_as_constant(c, mdtAssembly_MajorVersion, majorVersion)) return E_FAIL; } if (pMetaData->usMinorVersion != std::numeric_limits::max()) { uint32_t minorVersion = pMetaData->usMinorVersion; - if (1 != md_set_column_value_as_constant(c, mdtAssembly_MinorVersion, 1, &minorVersion)) + if (!md_set_column_value_as_constant(c, mdtAssembly_MinorVersion, minorVersion)) return E_FAIL; } if (pMetaData->usBuildNumber != std::numeric_limits::max()) { uint32_t buildNumber = pMetaData->usBuildNumber; - if (1 != md_set_column_value_as_constant(c, mdtAssembly_BuildNumber, 1, &buildNumber)) + if (!md_set_column_value_as_constant(c, mdtAssembly_BuildNumber, buildNumber)) return E_FAIL; } if (pMetaData->usRevisionNumber != std::numeric_limits::max()) { uint32_t revisionNumber = pMetaData->usRevisionNumber; - if (1 != md_set_column_value_as_constant(c, mdtAssembly_RevisionNumber, 1, &revisionNumber)) + if (!md_set_column_value_as_constant(c, mdtAssembly_RevisionNumber, revisionNumber)) return E_FAIL; } @@ -2970,7 +2970,7 @@ HRESULT MetadataEmit::SetAssemblyProps( return E_INVALIDARG; char const* locale = cvtLocale; - if (1 != md_set_column_value_as_utf8(c, mdtAssembly_Culture, 1, &locale)) + if (!md_set_column_value_as_utf8(c, mdtAssembly_Culture, locale)) return E_FAIL; } @@ -3003,7 +3003,7 @@ HRESULT MetadataEmit::SetAssemblyRefProps( if (publicKey != nullptr) { uint32_t publicKeyLength = cbPublicKeyOrToken; - if (1 != md_set_column_value_as_blob(c, mdtAssemblyRef_PublicKeyOrToken, 1, &publicKey, &publicKeyLength)) + if (!md_set_column_value_as_blob(c, mdtAssemblyRef_PublicKeyOrToken, publicKey, publicKeyLength)) return E_FAIL; } @@ -3011,11 +3011,11 @@ HRESULT MetadataEmit::SetAssemblyRefProps( { uint8_t const* hashValue = (uint8_t const*)pbHashValue; uint32_t hashValueLength = cbHashValue; - if (1 != md_set_column_value_as_blob(c, mdtAssemblyRef_HashValue, 1, &hashValue, &hashValueLength)) + if (!md_set_column_value_as_blob(c, mdtAssemblyRef_HashValue, hashValue, hashValueLength)) return E_FAIL; } - if (1 != md_set_column_value_as_constant(c, mdtAssemblyRef_Flags, 1, &assemblyFlags)) + if (!md_set_column_value_as_constant(c, mdtAssemblyRef_Flags, assemblyFlags)) return E_FAIL; if (szName != nullptr) @@ -3025,35 +3025,35 @@ HRESULT MetadataEmit::SetAssemblyRefProps( return E_INVALIDARG; char const* name = cvt; - if (1 != md_set_column_value_as_utf8(c, mdtAssemblyRef_Name, 1, &name)) + if (!md_set_column_value_as_utf8(c, mdtAssemblyRef_Name, name)) return E_FAIL; } if (pMetaData->usMajorVersion != std::numeric_limits::max()) { uint32_t majorVersion = pMetaData->usMajorVersion; - if (1 != md_set_column_value_as_constant(c, mdtAssemblyRef_MajorVersion, 1, &majorVersion)) + if (!md_set_column_value_as_constant(c, mdtAssemblyRef_MajorVersion, majorVersion)) return E_FAIL; } if (pMetaData->usMinorVersion != std::numeric_limits::max()) { uint32_t minorVersion = pMetaData->usMinorVersion; - if (1 != md_set_column_value_as_constant(c, mdtAssemblyRef_MinorVersion, 1, &minorVersion)) + if (!md_set_column_value_as_constant(c, mdtAssemblyRef_MinorVersion, minorVersion)) return E_FAIL; } if (pMetaData->usBuildNumber != std::numeric_limits::max()) { uint32_t buildNumber = pMetaData->usBuildNumber; - if (1 != md_set_column_value_as_constant(c, mdtAssemblyRef_BuildNumber, 1, &buildNumber)) + if (!md_set_column_value_as_constant(c, mdtAssemblyRef_BuildNumber, buildNumber)) return E_FAIL; } if (pMetaData->usRevisionNumber != std::numeric_limits::max()) { uint32_t revisionNumber = pMetaData->usRevisionNumber; - if (1 != md_set_column_value_as_constant(c, mdtAssemblyRef_RevisionNumber, 1, &revisionNumber)) + if (!md_set_column_value_as_constant(c, mdtAssemblyRef_RevisionNumber, revisionNumber)) return E_FAIL; } @@ -3064,7 +3064,7 @@ HRESULT MetadataEmit::SetAssemblyRefProps( return E_INVALIDARG; char const* locale = cvtLocale; - if (1 != md_set_column_value_as_utf8(c, mdtAssemblyRef_Culture, 1, &locale)) + if (!md_set_column_value_as_utf8(c, mdtAssemblyRef_Culture, locale)) return E_FAIL; } @@ -3087,14 +3087,14 @@ HRESULT MetadataEmit::SetFileProps( { uint8_t const* hashValue = (uint8_t const*)pbHashValue; uint32_t hashValueLength = cbHashValue; - if (1 != md_set_column_value_as_blob(c, mdtFile_HashValue, 1, &hashValue, &hashValueLength)) + if (!md_set_column_value_as_blob(c, mdtFile_HashValue, hashValue, hashValueLength)) return E_FAIL; } if (dwFileFlags != std::numeric_limits::max()) { uint32_t fileFlags = dwFileFlags; - if (1 != md_set_column_value_as_constant(c, mdtFile_Flags, 1, &fileFlags)) + if (!md_set_column_value_as_constant(c, mdtFile_Flags, fileFlags)) return E_FAIL; } @@ -3115,20 +3115,20 @@ HRESULT MetadataEmit::SetExportedTypeProps( if (!IsNilToken(tkImplementation)) { - if (1 != md_set_column_value_as_token(c, mdtExportedType_Implementation, 1, &tkImplementation)) + if (!md_set_column_value_as_token(c, mdtExportedType_Implementation, tkImplementation)) return E_FAIL; } if (!IsNilToken(tkTypeDef)) { - if (1 != md_set_column_value_as_token(c, mdtExportedType_TypeDefId, 1, &tkTypeDef)) + if (!md_set_column_value_as_token(c, mdtExportedType_TypeDefId, tkTypeDef)) return E_FAIL; } if (dwExportedTypeFlags != std::numeric_limits::max()) { uint32_t exportedTypeFlags = dwExportedTypeFlags; - if (1 != md_set_column_value_as_constant(c, mdtExportedType_Flags, 1, &exportedTypeFlags)) + if (!md_set_column_value_as_constant(c, mdtExportedType_Flags, exportedTypeFlags)) return E_FAIL; } @@ -3149,21 +3149,21 @@ HRESULT MetadataEmit::SetManifestResourceProps( if (!IsNilToken(tkImplementation)) { - if (1 != md_set_column_value_as_token(c, mdtManifestResource_Implementation, 1, &tkImplementation)) + if (!md_set_column_value_as_token(c, mdtManifestResource_Implementation, tkImplementation)) return E_FAIL; } if (dwOffset != std::numeric_limits::max()) { uint32_t offset = dwOffset; - if (1 != md_set_column_value_as_constant(c, mdtManifestResource_Offset, 1, &offset)) + if (!md_set_column_value_as_constant(c, mdtManifestResource_Offset, offset)) return E_FAIL; } if (dwResourceFlags != std::numeric_limits::max()) { uint32_t resourceFlags = dwResourceFlags; - if (1 != md_set_column_value_as_constant(c, mdtManifestResource_Flags, 1, &resourceFlags)) + if (!md_set_column_value_as_constant(c, mdtManifestResource_Flags, resourceFlags)) return E_FAIL; } diff --git a/src/native/dnmd/src/interfaces/metadataimport.cpp b/src/native/dnmd/src/interfaces/metadataimport.cpp index dcb008ea25b22..30c80aef49ca9 100644 --- a/src/native/dnmd/src/interfaces/metadataimport.cpp +++ b/src/native/dnmd/src/interfaces/metadataimport.cpp @@ -120,7 +120,7 @@ namespace mdcursor_t target; if (!md_resolve_indirect_cursor(curr, &target)) return CLDB_E_FILE_CORRUPT; - if (1 != md_get_column_value_as_utf8(target, filter->FilterColumn, 1, &toMatch)) + if (!md_get_column_value_as_utf8(target, filter->FilterColumn, &toMatch)) return CLDB_E_FILE_CORRUPT; if (0 == ::strcmp(toMatch, cvt)) @@ -181,7 +181,7 @@ namespace uint32_t i = 0; while (i < currCount) { - int32_t read = md_get_column_value_as_token(curr, keyColumn, ARRAY_SIZE(matchedGroup), matchedGroup); + int32_t read = md_get_many_rows_column_value_as_token(curr, keyColumn, ARRAY_SIZE(matchedGroup), matchedGroup); if (read == 0) break; @@ -332,7 +332,7 @@ namespace uint32_t i = 0; while (i < currCount) { - int32_t read = md_get_column_value_as_token(curr, lookupRange, ARRAY_SIZE(matchedGroup), matchedGroup); + int32_t read = md_get_many_rows_column_value_as_token(curr, lookupRange, ARRAY_SIZE(matchedGroup), matchedGroup); if (read == 0) break; @@ -444,9 +444,9 @@ namespace uint32_t typeRefScope; char const* typeRefNspace; char const* typeRefName; - if (1 != md_get_column_value_as_token(typeRefCursor, mdtTypeRef_ResolutionScope, 1, &typeRefScope) - || 1 != md_get_column_value_as_utf8(typeRefCursor, mdtTypeRef_TypeNamespace, 1, &typeRefNspace) - || 1 != md_get_column_value_as_utf8(typeRefCursor, mdtTypeRef_TypeName, 1, &typeRefName)) + if (!md_get_column_value_as_token(typeRefCursor, mdtTypeRef_ResolutionScope, &typeRefScope) + || !md_get_column_value_as_utf8(typeRefCursor, mdtTypeRef_TypeNamespace, &typeRefNspace) + || !md_get_column_value_as_utf8(typeRefCursor, mdtTypeRef_TypeName, &typeRefName)) { return CLDB_E_FILE_CORRUPT; } @@ -482,7 +482,7 @@ namespace mdToken tmpTk; for (uint32_t i = 0; i < count; (void)md_cursor_next(&cursor), ++i) { - if (1 != md_get_column_value_as_constant(cursor, mdtTypeDef_Flags, 1, &flags)) + if (!md_get_column_value_as_constant(cursor, mdtTypeDef_Flags, &flags)) return CLDB_E_FILE_CORRUPT; // Use XOR to handle the following in a single expression: @@ -505,13 +505,13 @@ namespace continue; } - if (1 != md_get_column_value_as_utf8(cursor, mdtTypeDef_TypeNamespace, 1, &str)) + if (!md_get_column_value_as_utf8(cursor, mdtTypeDef_TypeNamespace, &str)) return CLDB_E_FILE_CORRUPT; if (0 != ::strcmp(nspace, str)) continue; - if (1 != md_get_column_value_as_utf8(cursor, mdtTypeDef_TypeName, 1, &str)) + if (!md_get_column_value_as_utf8(cursor, mdtTypeDef_TypeName, &str)) return CLDB_E_FILE_CORRUPT; if (0 == ::strcmp(name, str)) @@ -568,12 +568,12 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetScopeProps( return CLDB_E_INDEX_NOTFOUND; GUID mvid; - if (1 != md_get_column_value_as_guid(cursor, mdtModule_Mvid, 1, reinterpret_cast(&mvid))) + if (!md_get_column_value_as_guid(cursor, mdtModule_Mvid, reinterpret_cast(&mvid))) return CLDB_E_FILE_CORRUPT; *pmvid = mvid; char const* name; - if (1 != md_get_column_value_as_utf8(cursor, mdtModule_Name, 1, &name)) + if (!md_get_column_value_as_utf8(cursor, mdtModule_Name, &name)) return CLDB_E_FILE_CORRUPT; return ConvertAndReturnStringOutput(name, szName, cchName, pchName); } @@ -605,12 +605,12 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetTypeDefProps( return CLDB_E_RECORD_NOTFOUND; uint32_t flags; - if (1 != md_get_column_value_as_constant(cursor, mdtTypeDef_Flags, 1, &flags)) + if (!md_get_column_value_as_constant(cursor, mdtTypeDef_Flags, &flags)) return CLDB_E_FILE_CORRUPT; *pdwTypeDefFlags = flags; mdToken extends; - if (1 != md_get_column_value_as_token(cursor, mdtTypeDef_Extends, 1, &extends)) + if (!md_get_column_value_as_token(cursor, mdtTypeDef_Extends, &extends)) return CLDB_E_FILE_CORRUPT; *ptkExtends = extends == mdTypeDefNil ? mdTypeRefNil @@ -618,8 +618,8 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetTypeDefProps( char const* name; char const* nspace; - if (1 != md_get_column_value_as_utf8(cursor, mdtTypeDef_TypeName, 1, &name) - || 1 != md_get_column_value_as_utf8(cursor, mdtTypeDef_TypeNamespace, 1, &nspace)) + if (!md_get_column_value_as_utf8(cursor, mdtTypeDef_TypeName, &name) + || !md_get_column_value_as_utf8(cursor, mdtTypeDef_TypeNamespace, &nspace)) { return CLDB_E_FILE_CORRUPT; } @@ -643,12 +643,12 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetInterfaceImplProps( return CLDB_E_INDEX_NOTFOUND; mdTypeDef type; - if (1 != md_get_column_value_as_token(cursor, mdtInterfaceImpl_Class, 1, &type)) + if (!md_get_column_value_as_token(cursor, mdtInterfaceImpl_Class, &type)) return CLDB_E_FILE_CORRUPT; *pClass = type; mdToken iface; - if (1 != md_get_column_value_as_token(cursor, mdtInterfaceImpl_Interface, 1, &iface)) + if (!md_get_column_value_as_token(cursor, mdtInterfaceImpl_Interface, &iface)) return CLDB_E_FILE_CORRUPT; *ptkIface = iface; @@ -671,14 +671,14 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetTypeRefProps( return CLDB_E_RECORD_NOTFOUND; mdToken resScope; - if (1 != md_get_column_value_as_token(cursor, mdtTypeRef_ResolutionScope, 1, &resScope)) + if (!md_get_column_value_as_token(cursor, mdtTypeRef_ResolutionScope, &resScope)) return CLDB_E_FILE_CORRUPT; *ptkResolutionScope = resScope; char const* name; char const* nspace; - if (1 != md_get_column_value_as_utf8(cursor, mdtTypeRef_TypeName, 1, &name) - || 1 != md_get_column_value_as_utf8(cursor, mdtTypeRef_TypeNamespace, 1, &nspace)) + if (!md_get_column_value_as_utf8(cursor, mdtTypeRef_TypeName, &name) + || !md_get_column_value_as_utf8(cursor, mdtTypeRef_TypeNamespace, &nspace)) { return CLDB_E_FILE_CORRUPT; } @@ -786,7 +786,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::EnumMembersWithName( mdcursor_t methodCursor; if (!md_resolve_indirect_cursor(methodList, &methodCursor)) return CLDB_E_FILE_CORRUPT; - if (1 != md_get_column_value_as_utf8(methodCursor, mdtMethodDef_Name, 1, &toMatch)) + if (!md_get_column_value_as_utf8(methodCursor, mdtMethodDef_Name, &toMatch)) return CLDB_E_FILE_CORRUPT; if (0 == ::strcmp(toMatch, cvt)) @@ -803,7 +803,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::EnumMembersWithName( mdcursor_t fieldCursor; if (!md_resolve_indirect_cursor(fieldList, &fieldCursor)) return CLDB_E_FILE_CORRUPT; - if (1 != md_get_column_value_as_utf8(fieldCursor, mdtField_Name, 1, &toMatch)) + if (!md_get_column_value_as_utf8(fieldCursor, mdtField_Name, &toMatch)) return CLDB_E_FILE_CORRUPT; if (0 == ::strcmp(toMatch, cvt)) @@ -929,7 +929,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::EnumMemberRefs( uint32_t i = 0; while (i < count) { - int32_t read = md_get_column_value_as_token(cursor, mdtMemberRef_Class, ARRAY_SIZE(toMatch), toMatch); + int32_t read = md_get_many_rows_column_value_as_token(cursor, mdtMemberRef_Class, ARRAY_SIZE(toMatch), toMatch); if (read == 0) break; @@ -983,8 +983,8 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::EnumMethodImpls( bool operator()(mdcursor_t c) { - if (1 != md_get_column_value_as_token(c, mdtMethodImpl_MethodBody, 1, &Body) - || 1 != md_get_column_value_as_token(c, mdtMethodImpl_MethodDeclaration, 1, &Decl)) + if (!md_get_column_value_as_token(c, mdtMethodImpl_MethodBody, &Body) + || !md_get_column_value_as_token(c, mdtMethodImpl_MethodDeclaration, &Decl)) { Result = CLDB_E_FILE_CORRUPT; return true; @@ -1057,10 +1057,10 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::EnumPermissionSets( for (uint32_t i = 0; i < count; ++i) { if ((IsDclActionNil(dwActions) - || (1 == md_get_column_value_as_constant(cursor, mdtDeclSecurity_Action, 1, &action) + || (md_get_column_value_as_constant(cursor, mdtDeclSecurity_Action, &action) && action == dwActions)) && (IsNilToken(tk) - || (1 == md_get_column_value_as_token(cursor, mdtDeclSecurity_Parent, 1, &parent) + || (md_get_column_value_as_token(cursor, mdtDeclSecurity_Parent, &parent) && parent == tk))) { (void)md_cursor_to_token(cursor, &toAdd); @@ -1112,10 +1112,10 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::FindMethod( if (!md_get_column_value_as_range(typedefCursor, mdtTypeDef_MethodList, &methodCursor, &count)) return CLDB_E_FILE_CORRUPT; - malloc_span methodDefSig; + inline_span methodDefSig; try { - methodDefSig = GetMethodDefSigFromMethodRefSig({ (uint8_t*)pvSigBlob, (size_t)cbSigBlob }); + GetMethodDefSigFromMethodRefSig({ (uint8_t*)pvSigBlob, (size_t)cbSigBlob }, methodDefSig); } catch (std::exception const&) { @@ -1132,7 +1132,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::FindMethod( if (!md_resolve_indirect_cursor(methodCursor, &target)) return CLDB_E_FILE_CORRUPT; uint32_t flags; - if (1 != md_get_column_value_as_constant(target, mdtMethodDef_Flags, 1, &flags)) + if (!md_get_column_value_as_constant(target, mdtMethodDef_Flags, &flags)) return CLDB_E_FILE_CORRUPT; // Ignore PrivateScope methods. By the spec, they can only be referred to by a MethodDef token @@ -1141,7 +1141,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::FindMethod( continue; char const* methodName; - if (1 != md_get_column_value_as_utf8(target, mdtMethodDef_Name, 1, &methodName)) + if (!md_get_column_value_as_utf8(target, mdtMethodDef_Name, &methodName)) return CLDB_E_FILE_CORRUPT; if (::strncmp(methodName, cvt, cvt.Length()) != 0) continue; @@ -1150,7 +1150,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::FindMethod( { uint8_t const* sig; uint32_t sigLen; - if (1 != md_get_column_value_as_blob(target, mdtMethodDef_Signature, 1, &sig, &sigLen)) + if (!md_get_column_value_as_blob(target, mdtMethodDef_Signature, &sig, &sigLen)) return CLDB_E_FILE_CORRUPT; if (sigLen != methodDefSig.size() || ::memcmp(methodDefSig, sig, sigLen) != 0) @@ -1197,7 +1197,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::FindField( if (!md_resolve_indirect_cursor(fieldCursor, &target)) return CLDB_E_FILE_CORRUPT; uint32_t flags; - if (1 != md_get_column_value_as_constant(target, mdtField_Flags, 1, &flags)) + if (!md_get_column_value_as_constant(target, mdtField_Flags, &flags)) return CLDB_E_FILE_CORRUPT; // Ignore PrivateScope fields. By the spec, they can only be referred to by a FieldDef token @@ -1206,7 +1206,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::FindField( continue; char const* name; - if (1 != md_get_column_value_as_utf8(target, mdtField_Name, 1, &name)) + if (!md_get_column_value_as_utf8(target, mdtField_Name, &name)) return CLDB_E_FILE_CORRUPT; if (::strncmp(name, cvt, cvt.Length()) != 0) continue; @@ -1215,7 +1215,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::FindField( { uint8_t const* sig; uint32_t sigLen; - if (1 != md_get_column_value_as_blob(target, mdtField_Signature, 1, &sig, &sigLen)) + if (!md_get_column_value_as_blob(target, mdtField_Signature, &sig, &sigLen)) return CLDB_E_FILE_CORRUPT; if (cbSigBlob != sigLen || ::memcmp(pvSigBlob, sig, sigLen) != 0) @@ -1260,7 +1260,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::FindMemberRef( for (uint32_t i = 0; i < count; (void)md_cursor_next(&cursor), ++i) { mdToken refParent; - if (1 != md_get_column_value_as_token(cursor, mdtMemberRef_Class, 1, &refParent)) + if (!md_get_column_value_as_token(cursor, mdtMemberRef_Class, &refParent)) return CLDB_E_FILE_CORRUPT; if (refParent != td) @@ -1269,7 +1269,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::FindMemberRef( if (szName != nullptr) { char const* name; - if (1 != md_get_column_value_as_utf8(cursor, mdtMemberRef_Name, 1, &name)) + if (!md_get_column_value_as_utf8(cursor, mdtMemberRef_Name, &name)) return CLDB_E_FILE_CORRUPT; pal::StringConvert cvt{ szName }; if (!cvt.Success()) @@ -1282,7 +1282,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::FindMemberRef( { uint8_t const* sig; uint32_t sigLen; - if (1 != md_get_column_value_as_blob(cursor, mdtMemberRef_Signature, 1, &sig, &sigLen)) + if (!md_get_column_value_as_blob(cursor, mdtMemberRef_Signature, &sig, &sigLen)) return CLDB_E_FILE_CORRUPT; if (cbSigBlob != sigLen || ::memcmp(pvSigBlob, sig, sigLen) != 0) @@ -1323,29 +1323,29 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetMethodProps( *pClass = classDef; uint32_t attrs; - if (1 != md_get_column_value_as_constant(cursor, mdtMethodDef_Flags, 1, &attrs)) + if (!md_get_column_value_as_constant(cursor, mdtMethodDef_Flags, &attrs)) return CLDB_E_FILE_CORRUPT; *pdwAttr = attrs; uint32_t rva; - if (1 != md_get_column_value_as_constant(cursor, mdtMethodDef_Rva, 1, &rva)) + if (!md_get_column_value_as_constant(cursor, mdtMethodDef_Rva, &rva)) return CLDB_E_FILE_CORRUPT; *pulCodeRVA = rva; uint32_t implFlags; - if (1 != md_get_column_value_as_constant(cursor, mdtMethodDef_ImplFlags, 1, &implFlags)) + if (!md_get_column_value_as_constant(cursor, mdtMethodDef_ImplFlags, &implFlags)) return CLDB_E_FILE_CORRUPT; *pdwImplFlags = implFlags; uint8_t const* sig; uint32_t sigLen; - if (1 != md_get_column_value_as_blob(cursor, mdtMethodDef_Signature, 1, &sig, &sigLen)) + if (!md_get_column_value_as_blob(cursor, mdtMethodDef_Signature, &sig, &sigLen)) return CLDB_E_FILE_CORRUPT; *ppvSigBlob = sig; *pcbSigBlob = sigLen; char const* name; - if (1 != md_get_column_value_as_utf8(cursor, mdtMethodDef_Name, 1, &name)) + if (!md_get_column_value_as_utf8(cursor, mdtMethodDef_Name, &name)) return CLDB_E_FILE_CORRUPT; return ConvertAndReturnStringOutput(name, szMethod, cchMethod, pchMethod); } @@ -1368,21 +1368,21 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetMemberRefProps( return CLDB_E_INDEX_NOTFOUND; mdToken type; - if (1 != md_get_column_value_as_token(cursor, mdtMemberRef_Class, 1, &type)) + if (!md_get_column_value_as_token(cursor, mdtMemberRef_Class, &type)) return CLDB_E_FILE_CORRUPT; *ptk = type; uint8_t const* sig; uint32_t sigLen; - if (1 != md_get_column_value_as_blob(cursor, mdtMemberRef_Signature, 1, &sig, &sigLen)) + if (!md_get_column_value_as_blob(cursor, mdtMemberRef_Signature, &sig, &sigLen)) return CLDB_E_FILE_CORRUPT; *ppvSigBlob = sig; *pbSig = sigLen; char const* name; - if (1 != md_get_column_value_as_utf8(cursor, mdtMemberRef_Name, 1, &name)) + if (!md_get_column_value_as_utf8(cursor, mdtMemberRef_Name, &name)) return CLDB_E_FILE_CORRUPT; return ConvertAndReturnStringOutput(name, szMember, cchMember, pchMember); } @@ -1492,12 +1492,12 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetEventProps( *pClass = classDef; uint32_t flags; - if (1 != md_get_column_value_as_constant(cursor, mdtEvent_EventFlags, 1, &flags)) + if (!md_get_column_value_as_constant(cursor, mdtEvent_EventFlags, &flags)) return CLDB_E_FILE_CORRUPT; *pdwEventFlags = flags; mdToken type; - if (1 != md_get_column_value_as_token(cursor, mdtEvent_EventType, 1, &type)) + if (!md_get_column_value_as_token(cursor, mdtEvent_EventType, &type)) return CLDB_E_FILE_CORRUPT; *ptkEventType = type; @@ -1520,8 +1520,8 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetEventProps( { mdMethodDef tk; uint32_t semantics; - if (1 != md_get_column_value_as_token(c, mdtMethodSemantics_Method, 1, &tk) - || 1 != md_get_column_value_as_constant(c, mdtMethodSemantics_Semantics, 1, &semantics)) + if (!md_get_column_value_as_token(c, mdtMethodSemantics_Method, &tk) + || !md_get_column_value_as_constant(c, mdtMethodSemantics_Semantics, &semantics)) { Result = CLDB_E_FILE_CORRUPT; return true; // Failure detected, so stop. @@ -1557,7 +1557,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetEventProps( *pcOtherMethod = finder.OtherCount; char const* name; - if (1 != md_get_column_value_as_utf8(cursor, mdtEvent_Name, 1, &name)) + if (!md_get_column_value_as_utf8(cursor, mdtEvent_Name, &name)) return CLDB_E_FILE_CORRUPT; // The const_cast<> is needed because the signature incorrectly expresses the // desired semantics. This has been wrong since .NET Framework 1.0. @@ -1593,7 +1593,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::EnumMethodSemantics( uint32_t i = 0; while (i < count) { - int32_t read = md_get_column_value_as_token(cursor, mdtMethodSemantics_Method, ARRAY_SIZE(toMatch), toMatch); + int32_t read = md_get_many_rows_column_value_as_token(cursor, mdtMethodSemantics_Method, ARRAY_SIZE(toMatch), toMatch); if (read == 0) break; @@ -1602,7 +1602,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::EnumMethodSemantics( { if (toMatch[j] == mb) { - if (1 != md_get_column_value_as_token(cursor, mdtMethodSemantics_Association, 1, &matchedTk)) + if (!md_get_column_value_as_token(cursor, mdtMethodSemantics_Association, &matchedTk)) return CLDB_E_FILE_CORRUPT; RETURN_IF_FAILED(HCORENUMImpl::AddToDynamicEnum(*enumImpl, matchedTk)); } @@ -1637,11 +1637,11 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetMethodSemantics( bool operator()(mdcursor_t c) { mdToken matchedTk; - if (1 == md_get_column_value_as_token(c, mdtMethodSemantics_Method, 1, &matchedTk) + if (md_get_column_value_as_token(c, mdtMethodSemantics_Method, &matchedTk) && MethodDef == matchedTk) { // Found result, stop iterating - Result = (1 == md_get_column_value_as_constant(c, mdtMethodSemantics_Semantics, 1, &Value)) + Result = (md_get_column_value_as_constant(c, mdtMethodSemantics_Semantics, &Value)) ? S_OK : CLDB_E_FILE_CORRUPT; return true; @@ -1687,8 +1687,8 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetClassLayout( uint32_t packSize; uint32_t classSize; // Acquire the packing and class sizes for the type and cursor to the typedef entry. - if (1 != md_get_column_value_as_constant(entry, mdtClassLayout_PackingSize, 1, &packSize) - || 1 != md_get_column_value_as_constant(entry, mdtClassLayout_ClassSize, 1, &classSize)) + if (!md_get_column_value_as_constant(entry, mdtClassLayout_PackingSize, &packSize) + || !md_get_column_value_as_constant(entry, mdtClassLayout_ClassSize, &classSize)) { return CLDB_E_FILE_CORRUPT; } @@ -1728,7 +1728,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetClassLayout( mdcursor_t fieldLayoutRow; if (md_find_row_from_cursor(fieldLayoutBegin, mdtFieldLayout_Field, RidFromToken(offset.ridOfField), &fieldLayoutRow)) { - (void)md_get_column_value_as_constant(fieldLayoutRow, mdtFieldLayout_Offset, 1, (uint32_t*)&offset.ulOffset); + (void)md_get_column_value_as_constant(fieldLayoutRow, mdtFieldLayout_Offset, (uint32_t*)&offset.ulOffset); foundLayout = true; } @@ -1766,7 +1766,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetFieldMarshal( uint8_t const* sig; uint32_t sigLen; - if (1 != md_get_column_value_as_blob(fieldMarshalRow, mdtFieldMarshal_NativeType, 1, &sig, &sigLen)) + if (!md_get_column_value_as_blob(fieldMarshalRow, mdtFieldMarshal_NativeType, &sig, &sigLen)) return CLDB_E_FILE_CORRUPT; *ppvNativeType = (PCCOR_SIGNATURE)sig; @@ -1788,8 +1788,8 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetRVA( if (!md_token_to_cursor(_md_ptr.get(), tk, &cursor)) return CLDB_E_RECORD_NOTFOUND; - if (1 != md_get_column_value_as_constant(cursor, mdtMethodDef_Rva, 1, &codeRVA) - || 1 != md_get_column_value_as_constant(cursor, mdtMethodDef_ImplFlags, 1, &implFlags)) + if (!md_get_column_value_as_constant(cursor, mdtMethodDef_Rva, &codeRVA) + || !md_get_column_value_as_constant(cursor, mdtMethodDef_ImplFlags, &implFlags)) { return CLDB_E_FILE_CORRUPT; } @@ -1807,7 +1807,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetRVA( return CLDB_E_RECORD_NOTFOUND; } - if (1 != md_get_column_value_as_constant(fieldRvaRow, mdtFieldRva_Rva, 1, &codeRVA)) + if (!md_get_column_value_as_constant(fieldRvaRow, mdtFieldRva_Rva, &codeRVA)) return CLDB_E_FILE_CORRUPT; } @@ -1834,13 +1834,13 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetPermissionSetProps( return CLDB_E_RECORD_NOTFOUND; if (pdwAction != nullptr - && 1 != md_get_column_value_as_constant(cursor, mdtDeclSecurity_Action, 1, (uint32_t*)pdwAction)) + && !md_get_column_value_as_constant(cursor, mdtDeclSecurity_Action, (uint32_t*)pdwAction)) { return CLDB_E_FILE_CORRUPT; } if (ppvPermission != nullptr - && 1 != md_get_column_value_as_blob(cursor, mdtDeclSecurity_PermissionSet, 1, (uint8_t const**)ppvPermission, (uint32_t*)pcbPermission)) + && !md_get_column_value_as_blob(cursor, mdtDeclSecurity_PermissionSet, (uint8_t const**)ppvPermission, (uint32_t*)pcbPermission)) { return CLDB_E_FILE_CORRUPT; } @@ -1862,7 +1862,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetSigFromToken( uint8_t const* sig; uint32_t sigLen; - if (1 != md_get_column_value_as_blob(cursor, mdtStandAloneSig_Signature, 1, &sig, &sigLen)) + if (!md_get_column_value_as_blob(cursor, mdtStandAloneSig_Signature, &sig, &sigLen)) return CLDB_E_FILE_CORRUPT; *ppvSig = (PCCOR_SIGNATURE)sig; *pcbSig = sigLen; @@ -1885,7 +1885,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetModuleRefProps( return CLDB_E_INDEX_NOTFOUND; char const* name; - if (1 != md_get_column_value_as_utf8(cursor, mdtModuleRef_Name, 1, &name)) + if (!md_get_column_value_as_utf8(cursor, mdtModuleRef_Name, &name)) return CLDB_E_FILE_CORRUPT; return ConvertAndReturnStringOutput(name, szName, cchName, pchName); } @@ -1916,7 +1916,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetTypeSpecFromToken( mdcursor_t cursor; if (!md_token_to_cursor(_md_ptr.get(), typespec, &cursor) - || 1 != md_get_column_value_as_blob(cursor, mdtTypeSpec_Signature, 1, ppvSig, (uint32_t*)pcbSig)) + || !md_get_column_value_as_blob(cursor, mdtTypeSpec_Signature, ppvSig, (uint32_t*)pcbSig)) { return CLDB_E_RECORD_NOTFOUND; } @@ -1972,7 +1972,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetNameFromToken( // Not if (!md_token_to_cursor(_md_ptr.get(), tk, &cursor)) return CLDB_E_RECORD_NOTFOUND; - if (1 != md_get_column_value_as_utf8(cursor, col_idx, 1, pszUtf8NamePtr)) + if (!md_get_column_value_as_utf8(cursor, col_idx, pszUtf8NamePtr)) return CLDB_E_FILE_CORRUPT; return S_OK; @@ -2052,17 +2052,17 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetPinvokeMap( } uint32_t flags; - if (1 != md_get_column_value_as_constant(implRow, mdtImplMap_MappingFlags, 1, &flags)) + if (!md_get_column_value_as_constant(implRow, mdtImplMap_MappingFlags, &flags)) return CLDB_E_FILE_CORRUPT; *pdwMappingFlags = flags; mdModuleRef token; - if (1 != md_get_column_value_as_token(implRow, mdtImplMap_ImportScope, 1, &token)) + if (!md_get_column_value_as_token(implRow, mdtImplMap_ImportScope, &token)) return CLDB_E_FILE_CORRUPT; *pmrImportDLL = token; char const* importName; - if (1 != md_get_column_value_as_utf8(implRow, mdtImplMap_ImportName, 1, &importName)) + if (!md_get_column_value_as_utf8(implRow, mdtImplMap_ImportName, &importName)) return CLDB_E_FILE_CORRUPT; return ConvertAndReturnStringOutput(importName, szImportName, cchImportName, pchImportName); } @@ -2156,7 +2156,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetParamForMethodIndex( mdcursor_t target; if (!md_resolve_indirect_cursor(curr, &target)) return CLDB_E_FILE_CORRUPT; - if (1 != md_get_column_value_as_constant(target, mdtParam_Sequence, 1, &seqMaybe)) + if (!md_get_column_value_as_constant(target, mdtParam_Sequence, &seqMaybe)) return CLDB_E_FILE_CORRUPT; if (ulParamSeq == seqMaybe) @@ -2235,7 +2235,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::EnumCustomAttributes( uint32_t i = 0; while (i < currCount) { - int32_t read = md_get_column_value_as_token(curr, mdtCustomAttribute_Parent, ARRAY_SIZE(toMatch), toMatch); + int32_t read = md_get_many_rows_column_value_as_token(curr, mdtCustomAttribute_Parent, ARRAY_SIZE(toMatch), toMatch); if (read == 0) break; @@ -2274,18 +2274,18 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetCustomAttributeProps( return CLDB_E_RECORD_NOTFOUND; mdToken obj; - if (1 != md_get_column_value_as_token(cursor, mdtCustomAttribute_Parent, 1, &obj)) + if (!md_get_column_value_as_token(cursor, mdtCustomAttribute_Parent, &obj)) return CLDB_E_FILE_CORRUPT; *ptkObj = obj; mdToken type; - if (1 != md_get_column_value_as_token(cursor, mdtCustomAttribute_Type, 1, &type)) + if (!md_get_column_value_as_token(cursor, mdtCustomAttribute_Type, &type)) return CLDB_E_FILE_CORRUPT; *ptkType = type; uint8_t const* blob; uint32_t blobLen; - if (1 != md_get_column_value_as_blob(cursor, mdtCustomAttribute_Value, 1, &blob, &blobLen)) + if (!md_get_column_value_as_blob(cursor, mdtCustomAttribute_Value, &blob, &blobLen)) return CLDB_E_FILE_CORRUPT; *ppBlob = blob; *pcbSize = blobLen; @@ -2316,7 +2316,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::FindTypeRef( char const* str; for (uint32_t i = 0; i < count; (void)md_cursor_next(&cursor), ++i) { - if (1 != md_get_column_value_as_token(cursor, mdtTypeRef_ResolutionScope, 1, &resMaybe)) + if (!md_get_column_value_as_token(cursor, mdtTypeRef_ResolutionScope, &resMaybe)) return CLDB_E_FILE_CORRUPT; // See if the Resolution scopes match. @@ -2326,13 +2326,13 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::FindTypeRef( continue; } - if (1 != md_get_column_value_as_utf8(cursor, mdtTypeRef_TypeNamespace, 1, &str)) + if (!md_get_column_value_as_utf8(cursor, mdtTypeRef_TypeNamespace, &str)) return CLDB_E_FILE_CORRUPT; if (0 != ::strcmp(nspace, str)) continue; - if (1 != md_get_column_value_as_utf8(cursor, mdtTypeRef_TypeName, 1, &str)) + if (!md_get_column_value_as_utf8(cursor, mdtTypeRef_TypeName, &str)) return CLDB_E_FILE_CORRUPT; if (0 == ::strcmp(name, str)) @@ -2422,9 +2422,9 @@ namespace } else { - if (1 != md_get_column_value_as_constant(constantPropCursor, mdtConstant_Type, 1, &corType)) + if (!md_get_column_value_as_constant(constantPropCursor, mdtConstant_Type, &corType)) return CLDB_E_FILE_CORRUPT; - if (1 != md_get_column_value_as_blob(constantPropCursor, mdtConstant_Value, 1, &defaultValue, &defaultValueLen)) + if (!md_get_column_value_as_blob(constantPropCursor, mdtConstant_Value, &defaultValue, &defaultValueLen)) return CLDB_E_FILE_CORRUPT; } @@ -2464,13 +2464,13 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetFieldProps( *pClass = classDef; uint32_t flags; - if (1 != md_get_column_value_as_constant(cursor, mdtField_Flags, 1, &flags)) + if (!md_get_column_value_as_constant(cursor, mdtField_Flags, &flags)) return CLDB_E_FILE_CORRUPT; *pdwAttr = flags; uint8_t const* sig; uint32_t sigLen; - if (1 != md_get_column_value_as_blob(cursor, mdtField_Signature, 1, &sig, &sigLen)) + if (!md_get_column_value_as_blob(cursor, mdtField_Signature, &sig, &sigLen)) return CLDB_E_FILE_CORRUPT; *ppvSigBlob = (PCCOR_SIGNATURE)sig; *pcbSigBlob = sigLen; @@ -2479,7 +2479,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetFieldProps( RETURN_IF_FAILED(FindConstant(_md_ptr, mb, *pdwCPlusTypeFlag, *ppValue, *pcchValue)); char const* name; - if (1 != md_get_column_value_as_utf8(cursor, mdtField_Name, 1, &name)) + if (!md_get_column_value_as_utf8(cursor, mdtField_Name, &name)) return CLDB_E_FILE_CORRUPT; return ConvertAndReturnStringOutput(name, szField, cchField, pchField); } @@ -2516,13 +2516,13 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetPropertyProps( *pClass = classDef; uint32_t flags; - if (1 != md_get_column_value_as_constant(cursor, mdtProperty_Flags, 1, &flags)) + if (!md_get_column_value_as_constant(cursor, mdtProperty_Flags, &flags)) return CLDB_E_FILE_CORRUPT; *pdwPropFlags = flags; uint8_t const* sig; uint32_t sigLen; - if (1 != md_get_column_value_as_blob(cursor, mdtProperty_Type, 1, &sig, &sigLen)) + if (!md_get_column_value_as_blob(cursor, mdtProperty_Type, &sig, &sigLen)) return CLDB_E_FILE_CORRUPT; *ppvSig = sig; *pbSig = sigLen; @@ -2548,8 +2548,8 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetPropertyProps( { mdMethodDef tk; uint32_t semantics; - if (1 != md_get_column_value_as_token(c, mdtMethodSemantics_Method, 1, &tk) - || 1 != md_get_column_value_as_constant(c, mdtMethodSemantics_Semantics, 1, &semantics)) + if (!md_get_column_value_as_token(c, mdtMethodSemantics_Method, &tk) + || !md_get_column_value_as_constant(c, mdtMethodSemantics_Semantics, &semantics)) { Result = CLDB_E_FILE_CORRUPT; return true; // Failure detected, so stop. @@ -2581,7 +2581,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetPropertyProps( *pcOtherMethod = finder.OtherCount; char const* name; - if (1 != md_get_column_value_as_utf8(cursor, mdtProperty_Name, 1, &name)) + if (!md_get_column_value_as_utf8(cursor, mdtProperty_Name, &name)) return CLDB_E_FILE_CORRUPT; // The const_cast<> is needed because the signature incorrectly expresses the @@ -2615,12 +2615,12 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetParamProps( *pmd = methodDef; uint32_t seq; - if (1 != md_get_column_value_as_constant(cursor, mdtParam_Sequence, 1, &seq)) + if (!md_get_column_value_as_constant(cursor, mdtParam_Sequence, &seq)) return CLDB_E_FILE_CORRUPT; *pulSequence = seq; uint32_t flags; - if (1 != md_get_column_value_as_constant(cursor, mdtParam_Flags, 1, &flags)) + if (!md_get_column_value_as_constant(cursor, mdtParam_Flags, &flags)) return CLDB_E_FILE_CORRUPT; *pdwAttr = flags; @@ -2628,7 +2628,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetParamProps( RETURN_IF_FAILED(FindConstant(_md_ptr, tk, *pdwCPlusTypeFlag, *ppValue, *pcchValue)); char const* name; - if (1 != md_get_column_value_as_utf8(cursor, mdtParam_Name, 1, &name)) + if (!md_get_column_value_as_utf8(cursor, mdtParam_Name, &name)) return CLDB_E_FILE_CORRUPT; return ConvertAndReturnStringOutput(name, szName, cchName, pchName); } @@ -2683,7 +2683,7 @@ namespace uint32_t tokenType = TypeFromToken(typeTk); while (tokenType == mdtTypeSpec) { - if (1 != md_get_column_value_as_blob(cursor, mdtTypeSpec_Signature, 1, &specBlob, &specBlobLen)) + if (!md_get_column_value_as_blob(cursor, mdtTypeSpec_Signature, &specBlob, &specBlobLen)) return CLDB_E_FILE_CORRUPT; RETURN_IF_FAILED(ExtractTypeDefRefFromSpec(specBlob, specBlobLen, typeTk)); @@ -2698,13 +2698,13 @@ namespace switch (tokenType) { case mdtTypeDef: - return (1 == md_get_column_value_as_utf8(cursor, mdtTypeDef_TypeNamespace, 1, nspace) - && 1 == md_get_column_value_as_utf8(cursor, mdtTypeDef_TypeName, 1, name)) + return (md_get_column_value_as_utf8(cursor, mdtTypeDef_TypeNamespace, nspace) + && md_get_column_value_as_utf8(cursor, mdtTypeDef_TypeName, name)) ? S_OK : CLDB_E_FILE_CORRUPT; case mdtTypeRef: - return (1 == md_get_column_value_as_utf8(cursor, mdtTypeRef_TypeNamespace, 1, nspace) - && 1 == md_get_column_value_as_utf8(cursor, mdtTypeRef_TypeName, 1, name)) + return (md_get_column_value_as_utf8(cursor, mdtTypeRef_TypeNamespace, nspace) + && md_get_column_value_as_utf8(cursor, mdtTypeRef_TypeName, name)) ? S_OK : CLDB_E_FILE_CORRUPT; default: @@ -2751,7 +2751,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetCustomAttributeByName( size_t len; char const* curr; - if (1 != md_get_column_value_as_cursor(custAttrCurr, mdtCustomAttribute_Type, 1, &type)) + if (!md_get_column_value_as_cursor(custAttrCurr, mdtCustomAttribute_Type, &type)) { hr = CLDB_E_FILE_CORRUPT; return true; @@ -2771,7 +2771,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetCustomAttributeByName( } break; case mdtMemberRef: - if (1 != md_get_column_value_as_cursor(type, mdtMemberRef_Class, 1, &tgtType)) + if (!md_get_column_value_as_cursor(type, mdtMemberRef_Class, &tgtType)) { hr = CLDB_E_FILE_CORRUPT; return true; @@ -2810,7 +2810,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetCustomAttributeByName( { uint8_t const* data; uint32_t dataLen; - if (1 != md_get_column_value_as_blob(custAttrCurr, mdtCustomAttribute_Value, 1, &data, &dataLen)) + if (!md_get_column_value_as_blob(custAttrCurr, mdtCustomAttribute_Value, &data, &dataLen)) { hr = CLDB_E_FILE_CORRUPT; return true; @@ -2862,7 +2862,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetNestedClassProps( } mdTypeDef enclosed; - if (1 != md_get_column_value_as_token(nestedClassRow, mdtNestedClass_EnclosingClass, 1, &enclosed)) + if (!md_get_column_value_as_token(nestedClassRow, mdtNestedClass_EnclosingClass, &enclosed)) return CLDB_E_FILE_CORRUPT; *ptdEnclosingClass = enclosed; @@ -2912,13 +2912,13 @@ namespace } char const* nspace; - if (1 != md_get_column_value_as_utf8(cursor, colNspace, 1, &nspace)) + if (!md_get_column_value_as_utf8(cursor, colNspace, &nspace)) return InvalidReadCount; if (0 == ::strcmp(nspace, CMOD_CALLCONV_NAMESPACE) || 0 == ::strcmp(nspace, CMOD_CALLCONV_NAMESPACE_OLD)) { char const* name; - if (1 != md_get_column_value_as_utf8(cursor, colName, 1, &name)) + if (!md_get_column_value_as_utf8(cursor, colName, &name)) return InvalidReadCount; if (0 == ::strcmp(name, CMOD_CALLCONV_NAME_CDECL)) @@ -3234,21 +3234,21 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetGenericParamProps( if (!md_token_to_cursor(_md_ptr.get(), gp, &cursor)) return CLDB_E_RECORD_NOTFOUND; - if (1 != md_get_column_value_as_token(cursor, mdtGenericParam_Owner, 1, ptOwner)) + if (!md_get_column_value_as_token(cursor, mdtGenericParam_Owner, ptOwner)) return CLDB_E_FILE_CORRUPT; uint32_t sequenceNumber; - if (1 != md_get_column_value_as_constant(cursor, mdtGenericParam_Number, 1, &sequenceNumber)) + if (!md_get_column_value_as_constant(cursor, mdtGenericParam_Number, &sequenceNumber)) return CLDB_E_FILE_CORRUPT; *pulParamSeq = sequenceNumber; uint32_t paramFlags; - if (1 != md_get_column_value_as_constant(cursor, mdtGenericParam_Flags, 1, ¶mFlags)) + if (!md_get_column_value_as_constant(cursor, mdtGenericParam_Flags, ¶mFlags)) return CLDB_E_FILE_CORRUPT; *pdwParamFlags = paramFlags; char const* name; - if (1 != md_get_column_value_as_utf8(cursor, mdtGenericParam_Name, 1, &name)) + if (!md_get_column_value_as_utf8(cursor, mdtGenericParam_Name, &name)) return CLDB_E_FILE_CORRUPT; return ConvertAndReturnStringOutput(name, wzname, cchName, pchName); @@ -3264,12 +3264,12 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetMethodSpecProps( if (!md_token_to_cursor(_md_ptr.get(), mi, &cursor)) return CLDB_E_RECORD_NOTFOUND; - if (1 != md_get_column_value_as_token(cursor, mdtMethodSpec_Method, 1, tkParent)) + if (!md_get_column_value_as_token(cursor, mdtMethodSpec_Method, tkParent)) return CLDB_E_FILE_CORRUPT; uint8_t const* sig; uint32_t sigLen; - if (1 != md_get_column_value_as_blob(cursor, mdtMethodSpec_Instantiation, 1, &sig, &sigLen)) + if (!md_get_column_value_as_blob(cursor, mdtMethodSpec_Instantiation, &sig, &sigLen)) return CLDB_E_FILE_CORRUPT; *ppvSigBlob = (PCCOR_SIGNATURE)sig; @@ -3333,10 +3333,10 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetGenericParamConstraintProps( if (!md_token_to_cursor(_md_ptr.get(), gpc, &cursor)) return CLDB_E_RECORD_NOTFOUND; - if (1 != md_get_column_value_as_token(cursor, mdtGenericParamConstraint_Owner, 1, ptGenericParam)) + if (!md_get_column_value_as_token(cursor, mdtGenericParamConstraint_Owner, ptGenericParam)) return CLDB_E_FILE_CORRUPT; - if (1 != md_get_column_value_as_token(cursor, mdtGenericParamConstraint_Constraint, 1, ptkConstraintType)) + if (!md_get_column_value_as_token(cursor, mdtGenericParamConstraint_Constraint, ptkConstraintType)) return CLDB_E_FILE_CORRUPT; return S_OK; @@ -3435,7 +3435,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetAssemblyProps( { uint8_t const* publicKey; uint32_t publicKeySize; - if (1 != md_get_column_value_as_blob(cursor, mdtAssembly_PublicKey, 1, &publicKey, &publicKeySize)) + if (!md_get_column_value_as_blob(cursor, mdtAssembly_PublicKey, &publicKey, &publicKeySize)) return CLDB_E_FILE_CORRUPT; *ppbPublicKey = publicKey; @@ -3445,7 +3445,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetAssemblyProps( if (pulHashAlgId != nullptr) { uint32_t hashAlgId; - if (1 != md_get_column_value_as_constant(cursor, mdtAssembly_HashAlgId, 1, &hashAlgId)) + if (!md_get_column_value_as_constant(cursor, mdtAssembly_HashAlgId, &hashAlgId)) return CLDB_E_FILE_CORRUPT; *pulHashAlgId = hashAlgId; } @@ -3456,16 +3456,16 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetAssemblyProps( uint32_t minorVersion; uint32_t buildNumber; uint32_t patchNumber; - if (1 != md_get_column_value_as_constant(cursor, mdtAssembly_MajorVersion, 1, &majorVersion)) + if (!md_get_column_value_as_constant(cursor, mdtAssembly_MajorVersion, &majorVersion)) return CLDB_E_FILE_CORRUPT; - if (1 != md_get_column_value_as_constant(cursor, mdtAssembly_MinorVersion, 1, &minorVersion)) + if (!md_get_column_value_as_constant(cursor, mdtAssembly_MinorVersion, &minorVersion)) return CLDB_E_FILE_CORRUPT; - if (1 != md_get_column_value_as_constant(cursor, mdtAssembly_BuildNumber, 1, &buildNumber)) + if (!md_get_column_value_as_constant(cursor, mdtAssembly_BuildNumber, &buildNumber)) return CLDB_E_FILE_CORRUPT; - if (1 != md_get_column_value_as_constant(cursor, mdtAssembly_RevisionNumber, 1, &patchNumber)) + if (!md_get_column_value_as_constant(cursor, mdtAssembly_RevisionNumber, &patchNumber)) return CLDB_E_FILE_CORRUPT; pMetaData->usMajorVersion = static_cast(majorVersion); @@ -3474,7 +3474,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetAssemblyProps( pMetaData->usRevisionNumber = static_cast(patchNumber); char const* culture; - if (1 != md_get_column_value_as_utf8(cursor, mdtAssembly_Culture, 1, &culture)) + if (!md_get_column_value_as_utf8(cursor, mdtAssembly_Culture, &culture)) return CLDB_E_FILE_CORRUPT; HRESULT hr; @@ -3488,12 +3488,12 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetAssemblyProps( if (pdwAssemblyFlags != nullptr) { uint32_t assemblyFlags; - if (1 != md_get_column_value_as_constant(cursor, mdtAssembly_Flags, 1, &assemblyFlags)) + if (!md_get_column_value_as_constant(cursor, mdtAssembly_Flags, &assemblyFlags)) return CLDB_E_FILE_CORRUPT; uint8_t const* publicKey; uint32_t publicKeySize; - if (1 != md_get_column_value_as_blob(cursor, mdtAssembly_PublicKey, 1, &publicKey, &publicKeySize)) + if (!md_get_column_value_as_blob(cursor, mdtAssembly_PublicKey, &publicKey, &publicKeySize)) return CLDB_E_FILE_CORRUPT; if (publicKeySize != 0) assemblyFlags |= afPublicKey; @@ -3504,7 +3504,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetAssemblyProps( if (szName != nullptr || pchName != nullptr) { char const* name; - if (1 != md_get_column_value_as_utf8(cursor, mdtAssembly_Name, 1, &name)) + if (!md_get_column_value_as_utf8(cursor, mdtAssembly_Name, &name)) return CLDB_E_FILE_CORRUPT; return ConvertAndReturnStringOutput(name, szName, cchName, pchName); @@ -3534,7 +3534,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetAssemblyRefProps( { uint8_t const* publicKeyOrToken; uint32_t publicKeyOrTokenSize; - if (1 != md_get_column_value_as_blob(cursor, mdtAssemblyRef_PublicKeyOrToken, 1, &publicKeyOrToken, &publicKeyOrTokenSize)) + if (!md_get_column_value_as_blob(cursor, mdtAssemblyRef_PublicKeyOrToken, &publicKeyOrToken, &publicKeyOrTokenSize)) return CLDB_E_FILE_CORRUPT; *ppbPublicKeyOrToken = publicKeyOrToken; @@ -3545,7 +3545,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetAssemblyRefProps( { uint8_t const* hashValue; uint32_t hashValueSize; - if (1 != md_get_column_value_as_blob(cursor, mdtAssemblyRef_HashValue, 1, &hashValue, &hashValueSize)) + if (!md_get_column_value_as_blob(cursor, mdtAssemblyRef_HashValue, &hashValue, &hashValueSize)) return CLDB_E_FILE_CORRUPT; *ppbHashValue = hashValue; *pcbHashValue = hashValueSize; @@ -3557,16 +3557,16 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetAssemblyRefProps( uint32_t minorVersion; uint32_t buildNumber; uint32_t patchNumber; - if (1 != md_get_column_value_as_constant(cursor, mdtAssemblyRef_MajorVersion, 1, &majorVersion)) + if (!md_get_column_value_as_constant(cursor, mdtAssemblyRef_MajorVersion, &majorVersion)) return CLDB_E_FILE_CORRUPT; - if (1 != md_get_column_value_as_constant(cursor, mdtAssemblyRef_MinorVersion, 1, &minorVersion)) + if (!md_get_column_value_as_constant(cursor, mdtAssemblyRef_MinorVersion, &minorVersion)) return CLDB_E_FILE_CORRUPT; - if (1 != md_get_column_value_as_constant(cursor, mdtAssemblyRef_BuildNumber, 1, &buildNumber)) + if (!md_get_column_value_as_constant(cursor, mdtAssemblyRef_BuildNumber, &buildNumber)) return CLDB_E_FILE_CORRUPT; - if (1 != md_get_column_value_as_constant(cursor, mdtAssemblyRef_RevisionNumber, 1, &patchNumber)) + if (!md_get_column_value_as_constant(cursor, mdtAssemblyRef_RevisionNumber, &patchNumber)) return CLDB_E_FILE_CORRUPT; pMetaData->usMajorVersion = static_cast(majorVersion); @@ -3575,7 +3575,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetAssemblyRefProps( pMetaData->usRevisionNumber = static_cast(patchNumber); char const* culture; - if (1 != md_get_column_value_as_utf8(cursor, mdtAssemblyRef_Culture, 1, &culture)) + if (!md_get_column_value_as_utf8(cursor, mdtAssemblyRef_Culture, &culture)) return CLDB_E_FILE_CORRUPT; HRESULT hr; @@ -3589,7 +3589,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetAssemblyRefProps( if (pdwAssemblyRefFlags != nullptr) { uint32_t assemblyRefFlags; - if (1 != md_get_column_value_as_constant(cursor, mdtAssemblyRef_Flags, 1, &assemblyRefFlags)) + if (!md_get_column_value_as_constant(cursor, mdtAssemblyRef_Flags, &assemblyRefFlags)) return CLDB_E_FILE_CORRUPT; *pdwAssemblyRefFlags = assemblyRefFlags; @@ -3598,7 +3598,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetAssemblyRefProps( if (szName != nullptr || pchName != nullptr) { char const* name; - if (1 != md_get_column_value_as_utf8(cursor, mdtAssemblyRef_Name, 1, &name)) + if (!md_get_column_value_as_utf8(cursor, mdtAssemblyRef_Name, &name)) return CLDB_E_FILE_CORRUPT; return ConvertAndReturnStringOutput(name, szName, cchName, pchName); @@ -3625,7 +3625,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetFileProps( { uint8_t const* hashValue; uint32_t hashValueSize; - if (1 != md_get_column_value_as_blob(cursor, mdtFile_HashValue, 1, &hashValue, &hashValueSize)) + if (!md_get_column_value_as_blob(cursor, mdtFile_HashValue, &hashValue, &hashValueSize)) return CLDB_E_FILE_CORRUPT; *ppbHashValue = hashValue; *pcbHashValue = hashValueSize; @@ -3634,7 +3634,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetFileProps( if (pdwFileFlags != nullptr) { uint32_t fileFlags; - if (1 != md_get_column_value_as_constant(cursor, mdtFile_Flags, 1, &fileFlags)) + if (!md_get_column_value_as_constant(cursor, mdtFile_Flags, &fileFlags)) return CLDB_E_FILE_CORRUPT; *pdwFileFlags = fileFlags; @@ -3643,7 +3643,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetFileProps( if (szName != nullptr || pchName != nullptr) { char const* name; - if (1 != md_get_column_value_as_utf8(cursor, mdtFile_Name, 1, &name)) + if (!md_get_column_value_as_utf8(cursor, mdtFile_Name, &name)) return CLDB_E_FILE_CORRUPT; return ConvertAndReturnStringOutput(name, szName, cchName, pchName); @@ -3668,7 +3668,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetExportedTypeProps( if (ptkImplementation != nullptr) { - if (1 != md_get_column_value_as_token(cursor, mdtExportedType_Implementation, 1, ptkImplementation)) + if (!md_get_column_value_as_token(cursor, mdtExportedType_Implementation, ptkImplementation)) return CLDB_E_FILE_CORRUPT; } @@ -3676,14 +3676,14 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetExportedTypeProps( { // This column points into the TypeDef table of another module, // so it isn't a true column reference here. - if (1 != md_get_column_value_as_constant(cursor, mdtExportedType_TypeDefId, 1, ptkTypeDef)) + if (!md_get_column_value_as_constant(cursor, mdtExportedType_TypeDefId, ptkTypeDef)) return CLDB_E_FILE_CORRUPT; } if (pdwExportedTypeFlags != nullptr) { uint32_t exportedTypeFlags; - if (1 != md_get_column_value_as_constant(cursor, mdtExportedType_Flags, 1, &exportedTypeFlags)) + if (!md_get_column_value_as_constant(cursor, mdtExportedType_Flags, &exportedTypeFlags)) return CLDB_E_FILE_CORRUPT; *pdwExportedTypeFlags = exportedTypeFlags; @@ -3692,11 +3692,11 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetExportedTypeProps( if (szName != nullptr || pchName != nullptr) { char const* name; - if (1 != md_get_column_value_as_utf8(cursor, mdtExportedType_TypeName, 1, &name)) + if (!md_get_column_value_as_utf8(cursor, mdtExportedType_TypeName, &name)) return CLDB_E_FILE_CORRUPT; char const* nspace; - if (1 != md_get_column_value_as_utf8(cursor, mdtExportedType_TypeNamespace, 1, &nspace)) + if (!md_get_column_value_as_utf8(cursor, mdtExportedType_TypeNamespace, &nspace)) return CLDB_E_FILE_CORRUPT; HRESULT hr; @@ -3725,14 +3725,14 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetManifestResourceProps( if (ptkImplementation != nullptr) { - if (1 != md_get_column_value_as_token(cursor, mdtManifestResource_Implementation, 1, ptkImplementation)) + if (!md_get_column_value_as_token(cursor, mdtManifestResource_Implementation, ptkImplementation)) return CLDB_E_FILE_CORRUPT; } if (pdwOffset != nullptr) { uint32_t offset; - if (1 != md_get_column_value_as_constant(cursor, mdtManifestResource_Offset, 1, &offset)) + if (!md_get_column_value_as_constant(cursor, mdtManifestResource_Offset, &offset)) return CLDB_E_FILE_CORRUPT; *pdwOffset = offset; @@ -3741,7 +3741,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetManifestResourceProps( if (pdwResourceFlags != nullptr) { uint32_t resourceFlags; - if (1 != md_get_column_value_as_constant(cursor, mdtManifestResource_Flags, 1, &resourceFlags)) + if (!md_get_column_value_as_constant(cursor, mdtManifestResource_Flags, &resourceFlags)) return CLDB_E_FILE_CORRUPT; *pdwResourceFlags = resourceFlags; @@ -3749,7 +3749,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::GetManifestResourceProps( if (szName != nullptr || pchName != nullptr) { char const* name; - if (1 != md_get_column_value_as_utf8(cursor, mdtManifestResource_Name, 1, &name)) + if (!md_get_column_value_as_utf8(cursor, mdtManifestResource_Name, &name)) return CLDB_E_FILE_CORRUPT; return ConvertAndReturnStringOutput(name, szName, cchName, pchName); @@ -3856,7 +3856,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::FindExportedTypeByName( for (uint32_t i = 0; i < count; md_cursor_next(&cursor), i++) { mdToken implementation; - if (1 != md_get_column_value_as_token(cursor, mdtExportedType_Implementation, 1, &implementation)) + if (!md_get_column_value_as_token(cursor, mdtExportedType_Implementation, &implementation)) return CLDB_E_FILE_CORRUPT; // Handle the case of nested vs. non-nested classes @@ -3875,14 +3875,14 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::FindExportedTypeByName( } char const* recordNspace; - if (1 != md_get_column_value_as_utf8(cursor, mdtExportedType_TypeNamespace, 1, &recordNspace)) + if (!md_get_column_value_as_utf8(cursor, mdtExportedType_TypeNamespace, &recordNspace)) return CLDB_E_FILE_CORRUPT; if (::strcmp(nspace, recordNspace) != 0) continue; char const* recordName; - if (1 != md_get_column_value_as_utf8(cursor, mdtExportedType_TypeName, 1, &recordName)) + if (!md_get_column_value_as_utf8(cursor, mdtExportedType_TypeName, &recordName)) return CLDB_E_FILE_CORRUPT; if (::strcmp(name, recordName) != 0) @@ -3918,7 +3918,7 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::FindManifestResourceByName( return CLDB_E_FILE_CORRUPT; char const* name; - if (1 != md_get_column_value_as_utf8(cursor, mdtManifestResource_Name, 1, &name)) + if (!md_get_column_value_as_utf8(cursor, mdtManifestResource_Name, &name)) return CLDB_E_FILE_CORRUPT; if (::strncmp(name, cvt, cvt.Length()) == 0) @@ -3946,4 +3946,4 @@ HRESULT STDMETHODCALLTYPE MetadataImportRO::FindAssembliesByName( UNREFERENCED_PARAMETER(pcAssemblies); // Requires VM knowledge and is only supported in .NET Framework. return E_NOTIMPL; -} \ No newline at end of file +} diff --git a/src/native/dnmd/src/interfaces/signatures.cpp b/src/native/dnmd/src/interfaces/signatures.cpp index 7c546357c1fbd..a0416d5a419f7 100644 --- a/src/native/dnmd/src/interfaces/signatures.cpp +++ b/src/native/dnmd/src/interfaces/signatures.cpp @@ -35,7 +35,7 @@ namespace struct signature_element_part_tag { }; - + struct raw_byte_tag final : signature_element_part_tag { }; @@ -120,7 +120,7 @@ namespace case ELEMENT_TYPE_PINNED: signature = WalkSignatureElement(signature, callback); break; - + case ELEMENT_TYPE_VAR: case ELEMENT_TYPE_MVAR: { @@ -203,11 +203,11 @@ namespace } } -malloc_span GetMethodDefSigFromMethodRefSig(span methodRefSig) +void GetMethodDefSigFromMethodRefSig(span methodRefSig, inline_span& methodDefSig) { assert(methodRefSig.size() > 0); // We don't need to do anything with the various elements of the signature, - // we just need to know how many parameters are before the sentinel. + // we just need to know how many parameters are before the sentinel. span signature = methodRefSig; uint8_t const callingConvention = signature[0]; signature = slice(signature, 1); @@ -217,9 +217,9 @@ malloc_span GetMethodDefSigFromMethodRefSig(span methodRe // parameter list. if ((callingConvention & IMAGE_CEE_CS_CALLCONV_MASK) != IMAGE_CEE_CS_CALLCONV_VARARG) { - malloc_span methodDefSig{ (uint8_t*)std::malloc(methodRefSig.size()), methodRefSig.size() }; - std::memcpy(methodDefSig, methodRefSig, methodRefSig.size()); - return methodDefSig; + methodDefSig.resize(methodRefSig.size()); + std::copy(methodRefSig.begin(), methodRefSig.end(), methodDefSig.begin()); + return; } uint32_t genericParameterCount = 0; @@ -249,7 +249,7 @@ malloc_span GetMethodDefSigFromMethodRefSig(span methodRe signature = WalkSignatureElement(signature, [](std::intmax_t, signature_element_part_tag) { }); } - + // Now that we know the number of parameters, we can copy the MethodDefSig portion of the signature // and update the parameter count. // We need to account for the fact that the parameter count may be encoded with less bytes @@ -259,29 +259,29 @@ malloc_span GetMethodDefSigFromMethodRefSig(span methodRe ULONG originalParamCountCompressedSize = CorSigCompressData(originalParameterCount, buffer); ULONG newParamCountCompressedSize = CorSigCompressData(i, buffer); span compressedNewParamCount = { buffer, newParamCountCompressedSize }; - + // The MethodDefSig length will be the length of the original signature up to the ELEMENT_TYPE_SENTINEL value, // minus the difference in the compressed size of the original parameter count and the new parameter count, if any. size_t methodDefSigBufferLength = methodRefSig.size() - signature.size() - originalParamCountCompressedSize + newParamCountCompressedSize; - malloc_span methodDefSigBuffer{ (uint8_t*)std::malloc(methodDefSigBufferLength), methodDefSigBufferLength }; - + methodDefSig.resize(methodDefSigBufferLength); + // Copy over the signature into the new buffer. // In case the parameter count was encoded with less bytes, we need to account for that // and copy the signature piece by piece. size_t offset = 0; - methodDefSigBuffer[offset++] = callingConvention; + methodDefSig[offset++] = callingConvention; if ((callingConvention & IMAGE_CEE_CS_CALLCONV_GENERIC) == IMAGE_CEE_CS_CALLCONV_GENERIC) { - offset += CorSigCompressData(genericParameterCount, methodDefSigBuffer + offset); + offset += CorSigCompressData(genericParameterCount, methodDefSig + offset); } - std::memcpy(methodDefSigBuffer + offset, compressedNewParamCount, newParamCountCompressedSize); + std::memcpy(methodDefSig + offset, compressedNewParamCount, newParamCountCompressedSize); offset += newParamCountCompressedSize; // Now that we've re-written the parameter count, we can copy the rest of the signature directly from the MethodRefSig assert(returnTypeAndParameters.size() >= methodDefSigBufferLength - offset); - std::memcpy(methodDefSigBuffer + offset, returnTypeAndParameters, methodDefSigBufferLength - offset); + std::memcpy(methodDefSig + offset, returnTypeAndParameters, methodDefSigBufferLength - offset); - return methodDefSigBuffer; + return; } // Define a function object that enables us to combine multiple lambdas into a single overload set. @@ -298,7 +298,7 @@ namespace // Define a perfectly-forwarding operator() that will call the function object with the given arguments. template - auto operator()(Args&&... args) const + auto operator()(Args&&... args) const -> decltype(std::declval()(std::forward(args)...)) { return _t(std::forward(args)...); @@ -312,7 +312,7 @@ namespace { using Overload::operator(); using Overload::operator(); - + Overload(T&& t, Ts&&... ts) :Overload(std::forward(t)), Overload(std::forward(ts)...) @@ -335,7 +335,7 @@ HRESULT ImportSignatureIntoModule( mdhandle_t destinationModule, span signature, std::function onRowAdded, - malloc_span& importedSignature) + inline_span& importedSignature) { HRESULT hr; // We are going to copy over the signature and replace the tokens from the source module in the signature @@ -371,7 +371,7 @@ HRESULT ImportSignatureIntoModule( destinationModule, onRowAdded, &token); - + // We can safely continue walking the signature even if we failed to import the token. // We'll return the failure code when we're done. if (FAILED(localHR)) @@ -434,14 +434,17 @@ HRESULT ImportSignatureIntoModule( return hr; } - uint8_t* buffer = (uint8_t*)std::malloc(importedSignatureBuffer.size()); - if (buffer == nullptr) + try + { + importedSignature.resize(importedSignature.size()); + } + catch (std::bad_alloc const&) { return E_OUTOFMEMORY; } - std::memcpy(buffer, importedSignatureBuffer.data(), importedSignatureBuffer.size()); - importedSignature = { buffer, importedSignatureBuffer.size() }; + std::copy(importedSignatureBuffer.begin(), importedSignatureBuffer.end(), importedSignature.begin()); + return S_OK; } @@ -453,7 +456,7 @@ HRESULT ImportTypeSpecBlob( mdhandle_t destinationModule, span typeSpecBlob, std::function onRowAdded, - malloc_span& importedTypeSpecBlob) + inline_span& importedTypeSpecBlob) { std::vector importedTypeSpecBlobBuffer; // Our imported blob will likely be a very similar size to the original blob. @@ -489,7 +492,7 @@ HRESULT ImportTypeSpecBlob( destinationModule, onRowAdded, &token); - + // We can safely continue walking the signature even if we failed to import the token. // We'll return the failure code when we're done. if (FAILED(localHR)) @@ -513,13 +516,15 @@ HRESULT ImportTypeSpecBlob( return E_INVALIDARG; } - uint8_t* buffer = (uint8_t*)std::malloc(importedTypeSpecBlobBuffer.size()); - if (buffer == nullptr) + try + { + importedTypeSpecBlob.resize(importedTypeSpecBlobBuffer.size()); + } + catch (std::bad_alloc const&) { return E_OUTOFMEMORY; } - std::memcpy(buffer, importedTypeSpecBlobBuffer.data(), importedTypeSpecBlobBuffer.size()); - importedTypeSpecBlob = { buffer, importedTypeSpecBlobBuffer.size() }; + std::copy(importedTypeSpecBlobBuffer.begin(), importedTypeSpecBlobBuffer.end(), importedTypeSpecBlob.begin()); return S_OK; -} \ No newline at end of file +} diff --git a/src/native/dnmd/src/interfaces/signatures.hpp b/src/native/dnmd/src/interfaces/signatures.hpp index a27b28e1cb2a3..1cdd6c621d3b9 100644 --- a/src/native/dnmd/src/interfaces/signatures.hpp +++ b/src/native/dnmd/src/interfaces/signatures.hpp @@ -6,10 +6,123 @@ #include +#include #include #include +#include -malloc_span GetMethodDefSigFromMethodRefSig(span methodRefSig); +/// @brief A span that that supports owning a specified number of elements in itself. +/// @tparam T The type of the elements in the span. +/// @tparam NumInlineElements The number of elements to store in the span itself. +template +struct base_inline_span : public span +{ + base_inline_span() : span() + { + this->_ptr = _storage.data(); + } + + base_inline_span(size_t size) : span() + { + this->_ptr = size > NumInlineElements ? base_inline_span::allocate_noninline_memory(size) : _storage.data(); + this->_size = size; + } + + base_inline_span(base_inline_span&& other) + { + *this = std::move(other); + } + + base_inline_span& operator=(base_inline_span&& other) noexcept + { + if (this->size() > NumInlineElements) + { + base_inline_span::free_noninline_memory(this->_ptr, this->size()); + this->_ptr = nullptr; + } + + if (other.size() > NumInlineElements) + { + this->_ptr = other._ptr; + other._ptr = nullptr; + } + else + { + std::copy(other.begin(), other.end(), _storage.begin()); + this->_ptr = _storage.data(); + this->_size = other._size; + } + + return *this; + } + + void resize(size_t newSize) + { + if (this->size() > NumInlineElements && newSize < NumInlineElements) + { + // Transitioning from a non-inline buffer to the inline buffer. + std::copy(this->begin(), this->begin() + newSize, _storage.begin()); + base_inline_span::free_noninline_memory(this->_ptr, this->size()); + this->_ptr = _storage.data(); + } + else if (this->size() <= NumInlineElements && newSize <= NumInlineElements) + { + // We're staying within the inline buffer, so just update the size. + this->_size = newSize; + } + else if (this->size() > NumInlineElements && newSize < this->size()) + { + // Shrinking the buffer, but still keeping it as a non-inline buffer. + this->_size = newSize; + } + else + { + // Growing the buffer from the inline buffer to a non-inline buffer. + assert(this->size() <= NumInlineElements && newSize > NumInlineElements); + T* newPtr = base_inline_span::allocate_noninline_memory(this->size()); + std::copy(this->begin(), this->end(), newPtr); + this->_ptr = newPtr; + this->_size = newSize; + } + } + + ~base_inline_span() + { + if (this->size() > NumInlineElements) + { + assert(this->_ptr != _storage.data()); + base_inline_span::free_noninline_memory(this->_ptr, this->size()); + this->_ptr = nullptr; + } + else + { + assert(this->_ptr == _storage.data()); + } + } + +private: + std::array _storage; + + static T* allocate_noninline_memory(size_t numElements) + { + assert(numElements > NumInlineElements); + return new T[numElements]; + } + + static void free_noninline_memory(T* ptr, size_t numElements) + { + UNREFERENCED_PARAMETER(numElements); + assert(numElements > NumInlineElements); + delete[] ptr; + } +}; + +/// @brief An span with inline storage for up to 64 bytes. +/// @tparam T The element type of the span. +template +using inline_span = base_inline_span; + +void GetMethodDefSigFromMethodRefSig(span methodRefSig, inline_span& methodDefSig); // Import a signature from one set of module and assembly metadata into another set of module and assembly metadata. // The module and assembly metadata for source or destination can be the same metadata. @@ -29,7 +142,7 @@ HRESULT ImportSignatureIntoModule( mdhandle_t destinationModule, span signature, std::function onRowAdded, - malloc_span& importedSignature); + inline_span& importedSignature); // Import a TypeSpecBlob (II.23.2.14) from one set of module and assembly metadata into another set of module and assembly metadata. HRESULT ImportTypeSpecBlob( @@ -40,6 +153,6 @@ HRESULT ImportTypeSpecBlob( mdhandle_t destinationModule, span typeSpecBlob, std::function onRowAdded, - malloc_span& importedTypeSpecBlob); + inline_span& importedTypeSpecBlob); #endif // _SRC_INTERFACES_SIGNATURES_HPP_