1// Licensed to the .NET Foundation under one or more agreements.
2// The .NET Foundation licenses this file to you under the MIT license.
3// See the LICENSE file in the project root for more information.
4//*****************************************************************************
5// TargetTypes.cpp
6//
7
8//
9//*****************************************************************************
10
11#include "stdafx.h"
12#include "targettypes.h"
13
14
15Target_CMiniMdSchemaBase::Target_CMiniMdSchemaBase() :
16m_ulReserved(0),
17m_major(0),
18m_minor(0),
19m_heaps(0),
20m_rid(0),
21m_maskvalid(0),
22m_sorted(0)
23{}
24
25HRESULT Target_CMiniMdSchemaBase::ReadFrom(DataTargetReader & reader)
26{
27 HRESULT hr = S_OK;
28 reader.Align(8); // this type needs 8 byte alignment from m_maskvalid
29 IfFailRet(reader.Read32(&m_ulReserved));
30 IfFailRet(reader.Read8(&m_major));
31 IfFailRet(reader.Read8(&m_minor));
32 IfFailRet(reader.Read8(&m_heaps));
33 IfFailRet(reader.Read8(&m_rid));
34 IfFailRet(reader.Read64(&m_maskvalid));
35 IfFailRet(reader.Read64(&m_sorted));
36 return S_OK;
37}
38
39Target_CMiniMdSchema::Target_CMiniMdSchema() :
40m_ulExtra(0)
41{
42 memset(&m_cRecs, 0, TBL_COUNT*sizeof(ULONG32));
43}
44
45HRESULT Target_CMiniMdSchema::ReadFrom(DataTargetReader & reader)
46{
47 HRESULT hr = S_OK;
48 IfFailRet(Target_CMiniMdSchemaBase::ReadFrom(reader));
49 reader.AlignBase();
50 for (int i = 0; i < TBL_COUNT; i++)
51 IfFailRet(reader.Read32(&(m_cRecs[i])));
52 IfFailRet(reader.Read32(&m_ulExtra));
53 return S_OK;
54}
55
56Target_CMiniColDef::Target_CMiniColDef() :
57m_Type(0),
58m_oColumn(0),
59m_cbColumn(0)
60{
61}
62
63HRESULT Target_CMiniColDef::ReadFrom(DataTargetReader & reader)
64{
65 HRESULT hr = S_OK;
66 IfFailRet(reader.Read8(&m_Type));
67 IfFailRet(reader.Read8(&m_oColumn));
68 IfFailRet(reader.Read8(&m_cbColumn));
69 return S_OK;
70}
71
72Target_CMiniTableDef::Target_CMiniTableDef() :
73m_pColDefs(NULL),
74m_cCols(0),
75m_iKey(0),
76m_cbRec(0)
77{}
78
79HRESULT Target_CMiniTableDef::ReadFrom(DataTargetReader & reader)
80{
81 HRESULT hr = S_OK;
82 CORDB_ADDRESS pColDefs = NULL;
83 IfFailRet(reader.ReadPointer(&pColDefs));
84 IfFailRet(reader.Read8(&m_cCols));
85 IfFailRet(reader.Read8(&m_iKey));
86 IfFailRet(reader.Read8(&m_cbRec));
87
88 // sanity check before allocating
89 if (m_cCols > 100)
90 return CLDB_E_FILE_CORRUPT;
91 m_pColDefs = new (nothrow) Target_CMiniColDef[m_cCols];
92 if (m_pColDefs == NULL)
93 return E_OUTOFMEMORY;
94 DataTargetReader colsReader = reader.CreateReaderAt(pColDefs);
95 for (int i = 0; i < m_cCols; i++)
96 {
97 IfFailRet(colsReader.Read(&m_pColDefs[i]));
98 }
99
100 return S_OK;
101}
102
103Target_CMiniMdBase::Target_CMiniMdBase() :
104m_TblCount(0),
105m_fVerifiedByTrustedSource(FALSE),
106m_iStringsMask(0),
107m_iGuidsMask(0),
108m_iBlobsMask(0)
109{}
110
111HRESULT Target_CMiniMdBase::ReadFrom(DataTargetReader & reader)
112{
113 HRESULT hr = S_OK;
114 IfFailRet(reader.SkipPointer()); // vtable
115 IfFailRet(reader.Read(&m_Schema));
116 IfFailRet(reader.Read32(&m_TblCount));
117 IfFailRet(reader.Read32((ULONG32*)&m_fVerifiedByTrustedSource));
118 for (int i = 0; i < TBL_COUNT; i++)
119 IfFailRet(reader.Read(&(m_TableDefs[i])));
120 IfFailRet(reader.Read32(&m_iStringsMask));
121 IfFailRet(reader.Read32(&m_iGuidsMask));
122 IfFailRet(reader.Read32(&m_iBlobsMask));
123 return S_OK;
124}
125
126Target_MapSHash::Target_MapSHash() :
127m_table(0),
128m_tableSize(0),
129m_tableCount(0),
130m_tableOccupied(0),
131m_tableMax(0)
132{}
133
134HRESULT Target_MapSHash::ReadFrom(DataTargetReader & reader)
135{
136 HRESULT hr = S_OK;
137 // Only the Windows MSVC compiler does this; not clang on Linux
138#ifdef _MSC_VER
139 IfFailRet(reader.Skip8()); // this byte gets used by the base class even though it has no members
140 // I'm guessing this is so the 2nd base class (noncopyable) doesn't start at the same
141 // location, but I can't be sure. Whatever the cause, the layout skips a byte.
142#endif // _MSC_VER
143 IfFailRet(reader.ReadPointer(&m_table));
144 IfFailRet(reader.Read32(&m_tableSize));
145 IfFailRet(reader.Read32(&m_tableCount));
146 IfFailRet(reader.Read32(&m_tableOccupied));
147 IfFailRet(reader.Read32(&m_tableMax));
148 return S_OK;
149}
150
151
152
153Target_StgPoolSeg::Target_StgPoolSeg() :
154m_pSegData(0),
155m_pNextSeg(0),
156m_cbSegSize(0),
157m_cbSegNext(0)
158{}
159
160HRESULT Target_StgPoolSeg::ReadFrom(DataTargetReader & reader)
161{
162 HRESULT hr = S_OK;
163 IfFailRet(reader.ReadPointer(&m_pSegData));
164 IfFailRet(reader.ReadPointer(&m_pNextSeg));
165 IfFailRet(reader.Read32(&m_cbSegSize));
166 IfFailRet(reader.Read32(&m_cbSegNext));
167 return S_OK;
168}
169
170
171Target_CChainedHash::Target_CChainedHash() :
172m_rgData(0),
173m_iBuckets(0),
174m_iSize(0),
175m_iCount(0),
176m_iMaxChain(0),
177m_iFree(0)
178{}
179
180HRESULT Target_CChainedHash::ReadFrom(DataTargetReader & reader)
181{
182 HRESULT hr = S_OK;
183 IfFailRet(reader.SkipPointer()); // __vfptr
184 IfFailRet(reader.ReadPointer(&m_rgData));
185 IfFailRet(reader.Read32(&m_iBuckets));
186 IfFailRet(reader.Read32(&m_iSize));
187 IfFailRet(reader.Read32(&m_iCount));
188 IfFailRet(reader.Read32(&m_iMaxChain));
189 IfFailRet(reader.Read32(&m_iFree));
190 return S_OK;
191}
192
193Target_CStringPoolHash::Target_CStringPoolHash() :
194m_Pool(0)
195{}
196
197HRESULT Target_CStringPoolHash::ReadFrom(DataTargetReader & reader)
198{
199 HRESULT hr = S_OK;
200 IfFailRet(Target_CChainedHash::ReadFrom(reader));
201 reader.AlignBase();
202 IfFailRet(reader.ReadPointer(&m_Pool));
203 return S_OK;
204}
205
206Target_CBlobPoolHash::Target_CBlobPoolHash() :
207m_Pool(0)
208{}
209
210HRESULT Target_CBlobPoolHash::ReadFrom(DataTargetReader & reader)
211{
212 HRESULT hr = S_OK;
213 IfFailRet(Target_CChainedHash::ReadFrom(reader));
214 reader.AlignBase();
215 IfFailRet(reader.ReadPointer(&m_Pool));
216 return S_OK;
217}
218
219
220Target_CGuidPoolHash::Target_CGuidPoolHash() :
221m_Pool(0)
222{ }
223
224HRESULT Target_CGuidPoolHash::ReadFrom(DataTargetReader & reader)
225{
226 HRESULT hr = S_OK;
227 IfFailRet(Target_CChainedHash::ReadFrom(reader));
228 reader.AlignBase();
229 IfFailRet(reader.ReadPointer(&m_Pool));
230 return S_OK;
231}
232
233Target_HotHeap::Target_HotHeap() :
234m_pHotHeapHeader(0)
235{}
236
237HRESULT Target_HotHeap::ReadFrom(DataTargetReader & reader)
238{
239 HRESULT hr = S_OK;
240 IfFailRet(reader.ReadPointer(&m_pHotHeapHeader));
241 return S_OK;
242}
243
244HRESULT Target_StgPoolReadOnly::ReadFrom(DataTargetReader & reader)
245{
246 HRESULT hr = S_OK;
247 IfFailRet(reader.SkipPointer()); // __vfptr
248 IfFailRet(Target_StgPoolSeg::ReadFrom(reader));
249 reader.AlignBase();
250 IfFailRet(reader.Read(&m_HotHeap));
251 return S_OK;
252}
253
254Target_StgPool::Target_StgPool() :
255m_ulGrowInc(0),
256m_pCurSeg(0),
257m_cbCurSegOffset(0),
258m_bFree(FALSE),
259m_bReadOnly(FALSE),
260m_nVariableAlignmentMask(0),
261m_cbStartOffsetOfEdit(0),
262m_fValidOffsetOfEdit(FALSE)
263{}
264
265HRESULT Target_StgPool::ReadFrom(DataTargetReader & reader)
266{
267 HRESULT hr = S_OK;
268 IfFailRet(Target_StgPoolReadOnly::ReadFrom(reader));
269 reader.AlignBase();
270 IfFailRet(reader.Read32(&m_ulGrowInc));
271 IfFailRet(reader.ReadPointer(&m_pCurSeg));
272 IfFailRet(reader.Read32(&m_cbCurSegOffset));
273 ULONG32 bitField;
274 IfFailRet(reader.Read32(&bitField));
275 m_bFree = (bitField & 0x1) != 0;
276 m_bReadOnly = (bitField & 0x2) != 0;
277 IfFailRet(reader.Read32(&m_nVariableAlignmentMask));
278 IfFailRet(reader.Read32(&m_cbStartOffsetOfEdit));
279 IfFailRet(reader.Read8((BYTE*)&m_fValidOffsetOfEdit));
280 return S_OK;
281}
282
283HRESULT Target_StgBlobPool::ReadFrom(DataTargetReader & reader)
284{
285 HRESULT hr = S_OK;
286 IfFailRet(Target_StgPool::ReadFrom(reader));
287 reader.AlignBase();
288 IfFailRet(reader.Read(&m_Hash));
289 return S_OK;
290}
291
292Target_StgStringPool::Target_StgStringPool() :
293m_bHash(FALSE)
294{
295}
296
297HRESULT Target_StgStringPool::ReadFrom(DataTargetReader & reader)
298{
299 HRESULT hr = S_OK;
300 IfFailRet(Target_StgPool::ReadFrom(reader));
301 reader.AlignBase();
302 IfFailRet(reader.Read(&m_Hash));
303 IfFailRet(reader.Read8((BYTE*)&m_bHash));
304 return S_OK;
305}
306
307Target_StgGuidPool::Target_StgGuidPool() :
308m_bHash(FALSE)
309{}
310
311HRESULT Target_StgGuidPool::ReadFrom(DataTargetReader & reader)
312{
313 HRESULT hr = S_OK;
314 IfFailRet(Target_StgPool::ReadFrom(reader));
315 reader.AlignBase();
316 IfFailRet(reader.Read(&m_Hash));
317 IfFailRet(reader.Read8((BYTE*)&m_bHash));
318 return S_OK;
319}
320
321Target_RecordPool::Target_RecordPool() :
322m_cbRec(0)
323{}
324
325HRESULT Target_RecordPool::ReadFrom(DataTargetReader & reader)
326{
327 HRESULT hr = S_OK;
328 IfFailRet(Target_StgPool::ReadFrom(reader));
329 reader.AlignBase();
330 IfFailRet(reader.Read32(&m_cbRec));
331 return S_OK;
332}
333
334Target_OptionValue::Target_OptionValue() :
335m_DupCheck(0),
336m_RefToDefCheck(0),
337m_NotifyRemap(0),
338m_UpdateMode(0),
339m_ErrorIfEmitOutOfOrder(0),
340m_ThreadSafetyOptions(0),
341m_ImportOption(0),
342m_LinkerOption(0),
343m_GenerateTCEAdapters(0),
344m_RuntimeVersion(0),
345m_MetadataVersion(0),
346m_MergeOptions(0),
347m_InitialSize(0),
348m_LocalRefPreservation(0)
349{}
350
351HRESULT Target_OptionValue::ReadFrom(DataTargetReader & reader)
352{
353 HRESULT hr = S_OK;
354 IfFailRet(reader.Read32(&m_DupCheck));
355 IfFailRet(reader.Read32(&m_RefToDefCheck));
356 IfFailRet(reader.Read32(&m_NotifyRemap));
357 IfFailRet(reader.Read32(&m_UpdateMode));
358 IfFailRet(reader.Read32(&m_ErrorIfEmitOutOfOrder));
359 IfFailRet(reader.Read32(&m_ThreadSafetyOptions));
360 IfFailRet(reader.Read32(&m_ImportOption));
361 IfFailRet(reader.Read32(&m_LinkerOption));
362 IfFailRet(reader.Read32(&m_GenerateTCEAdapters));
363 IfFailRet(reader.ReadPointer(&m_RuntimeVersion));
364 IfFailRet(reader.Read32(&m_MetadataVersion));
365 IfFailRet(reader.Read32(&m_MergeOptions));
366 IfFailRet(reader.Read32(&m_InitialSize));
367 IfFailRet(reader.Read32(&m_LocalRefPreservation));
368 return S_OK;
369}
370
371Target_CMiniMdRW::Target_CMiniMdRW() :
372m_pMemberRefHash(0),
373m_pMemberDefHash(0),
374m_pNamedItemHash(0),
375m_maxRid(0),
376m_limRid(0),
377m_maxIx(0),
378m_limIx(0),
379m_eGrow(0),
380m_pHandler(0),
381m_cbSaveSize(0),
382m_fIsReadOnly(FALSE),
383m_bPreSaveDone(FALSE),
384m_bSaveCompressed(FALSE),
385m_bPostGSSMod(FALSE),
386m_pMethodMap(0),
387m_pFieldMap(0),
388m_pPropertyMap(0),
389m_pEventMap(0),
390m_pParamMap(0),
391m_pFilterTable(0),
392m_pHostFilter(0),
393m_pTokenRemapManager(0),
394dbg_m_pLock(0),
395m_fMinimalDelta(FALSE),
396m_rENCRecs(0)
397{
398 memset(&m_pLookUpHashs, 0, TBL_COUNT*sizeof(CORDB_ADDRESS));
399 memset(&m_pVS, 0, TBL_COUNT*sizeof(CORDB_ADDRESS));
400 memset(&m_bSortable, 0, TBL_COUNT*sizeof(BOOL));
401}
402
403HRESULT Target_CMiniMdRW::ReadFrom(DataTargetReader & reader)
404{
405 HRESULT hr = S_OK;
406 IfFailRet(Target_CMiniMdTemplate_CMiniMdRW::ReadFrom(reader));
407 reader.AlignBase();
408 IfFailRet(reader.ReadPointer(&m_pMemberRefHash));
409 IfFailRet(reader.ReadPointer(&m_pMemberDefHash));
410 for (int i = 0; i < TBL_COUNT; i++)
411 IfFailRet(reader.ReadPointer(&m_pLookUpHashs[i]));
412 IfFailRet(reader.Read(&m_StringPoolOffsetHash));
413 IfFailRet(reader.ReadPointer(&m_pNamedItemHash));
414 IfFailRet(reader.Read32(&m_maxRid));
415 IfFailRet(reader.Read32(&m_limRid));
416 IfFailRet(reader.Read32(&m_maxIx));
417 IfFailRet(reader.Read32(&m_limIx));
418 IfFailRet(reader.Read32(&m_eGrow));
419 for (int i = 0; i < TBL_COUNT; i++)
420 IfFailRet(reader.Read(&m_Tables[i]));
421 for (int i = 0; i < TBL_COUNT; i++)
422 IfFailRet(reader.ReadPointer(&m_pVS[i]));
423 IfFailRet(reader.Read(&m_StringHeap));
424 IfFailRet(reader.Read(&m_BlobHeap));
425 IfFailRet(reader.Read(&m_UserStringHeap));
426 IfFailRet(reader.Read(&m_GuidHeap));
427 IfFailRet(reader.ReadPointer(&m_pHandler));
428 IfFailRet(reader.Read32(&m_cbSaveSize));
429 ULONG32 bitField;
430 IfFailRet(reader.Read32(&bitField));
431 m_fIsReadOnly = (bitField & 0x1) != 0;
432 m_bPreSaveDone = (bitField & 0x2) != 0;
433 m_bSaveCompressed = (bitField & 0x4) != 0;
434 m_bPostGSSMod = (bitField & 0x8) != 0;
435 IfFailRet(reader.ReadPointer(&m_pMethodMap));
436 IfFailRet(reader.ReadPointer(&m_pFieldMap));
437 IfFailRet(reader.ReadPointer(&m_pPropertyMap));
438 IfFailRet(reader.ReadPointer(&m_pEventMap));
439 IfFailRet(reader.ReadPointer(&m_pParamMap));
440 IfFailRet(reader.ReadPointer(&m_pFilterTable));
441 IfFailRet(reader.ReadPointer(&m_pHostFilter));
442 IfFailRet(reader.ReadPointer(&m_pTokenRemapManager));
443 IfFailRet(reader.Read(&m_OptionValue));
444 IfFailRet(reader.Read(&m_StartupSchema));
445 for (int i = 0; i < TBL_COUNT; i++)
446 IfFailRet(reader.Read8((BYTE*)&m_bSortable[i]));
447 if (reader.IsDefined(1)) // replace this with DEFINE__DEBUG
448 {
449 IfFailRet(reader.ReadPointer(&dbg_m_pLock));
450 }
451 IfFailRet(reader.Read8((BYTE*)&m_fMinimalDelta));
452 IfFailRet(reader.ReadPointer(&m_rENCRecs));
453 return S_OK;
454}
455
456
457
458Target_CLiteWeightStgdb_CMiniMdRW::Target_CLiteWeightStgdb_CMiniMdRW() :
459m_pvMd(0),
460m_cbMd(0)
461{
462}
463
464HRESULT Target_CLiteWeightStgdb_CMiniMdRW::ReadFrom(DataTargetReader & reader)
465{
466 HRESULT hr = S_OK;
467 IfFailRet(reader.Read(&m_MiniMd));
468 IfFailRet(reader.ReadPointer(&m_pvMd));
469 IfFailRet(reader.Read32(&m_cbMd));
470 return S_OK;
471}
472
473Target_CLiteWeightStgdbRW::Target_CLiteWeightStgdbRW() :
474m_cbSaveSize(0),
475m_bSaveCompressed(FALSE),
476m_pImage(0),
477m_dwImageSize(0),
478m_dwPEKind(0),
479m_dwMachine(0),
480m_pStreamList(0),
481m_pNextStgdb(0),
482m_eFileType(0),
483m_wszFileName(0),
484m_dwDatabaseLFT(0),
485m_dwDatabaseLFS(0)
486{}
487
488HRESULT Target_CLiteWeightStgdbRW::ReadFrom(DataTargetReader & reader)
489{
490 HRESULT hr = S_OK;
491 IfFailRet(Target_CLiteWeightStgdb_CMiniMdRW::ReadFrom(reader));
492 reader.AlignBase();
493 IfFailRet(reader.Read32(&m_cbSaveSize));
494 IfFailRet(reader.Read8((BYTE*)&m_bSaveCompressed));
495 IfFailRet(reader.ReadPointer(&m_pImage));
496 IfFailRet(reader.Read32(&m_dwImageSize));
497 IfFailRet(reader.Read32(&m_dwPEKind));
498 IfFailRet(reader.Read32(&m_dwMachine));
499 IfFailRet(reader.ReadPointer(&m_pStreamList));
500 IfFailRet(reader.ReadPointer(&m_pNextStgdb));
501 IfFailRet(reader.Read32(&m_eFileType));
502 IfFailRet(reader.ReadPointer(&m_wszFileName));
503 IfFailRet(reader.Read32(&m_dwDatabaseLFT));
504 IfFailRet(reader.Read32(&m_dwDatabaseLFS));
505 IfFailRet(reader.ReadPointer(&m_pStgIO));
506 return S_OK;
507}
508
509
510
511Target_MDInternalRW::Target_MDInternalRW() :
512m_tdModule(0),
513m_cRefs(0),
514m_fOwnStgdb(FALSE),
515m_pUnk(0),
516m_pUserUnk(0),
517m_pIMetaDataHelper(0),
518m_pSemReadWrite(0),
519m_fOwnSem(FALSE)
520{
521}
522
523HRESULT Target_MDInternalRW::ReadFrom(DataTargetReader & reader)
524{
525 HRESULT hr = S_OK;
526 IfFailRet(reader.SkipPointer()); // IMDInternalImportENC vtable
527 IfFailRet(reader.SkipPointer()); // IMDCommon vtable
528 IfFailRet(reader.ReadPointer(&m_pStgdb));
529 IfFailRet(reader.Read32(&m_tdModule));
530 IfFailRet(reader.Read32(&m_cRefs));
531 IfFailRet(reader.Read8((BYTE*)&m_fOwnStgdb));
532 IfFailRet(reader.ReadPointer(&m_pUnk));
533 IfFailRet(reader.ReadPointer(&m_pUserUnk));
534 IfFailRet(reader.ReadPointer(&m_pIMetaDataHelper));
535 IfFailRet(reader.ReadPointer(&m_pSemReadWrite));
536 IfFailRet(reader.Read8((BYTE*)&m_fOwnSem));
537 return S_OK;
538}
539