1 #define NVOC_MEM_H_PRIVATE_ACCESS_ALLOWED
2 #include "nvoc/runtime.h"
3 #include "nvoc/rtti.h"
4 #include "nvtypes.h"
5 #include "nvport/nvport.h"
6 #include "nvport/inline/util_valist.h"
7 #include "utils/nvassert.h"
8 #include "g_mem_nvoc.h"
9 
10 #ifdef DEBUG
11 char __nvoc_class_id_uniqueness_check_0x4789f2 = 1;
12 #endif
13 
14 extern const struct NVOC_CLASS_DEF __nvoc_class_def_Memory;
15 
16 extern const struct NVOC_CLASS_DEF __nvoc_class_def_Object;
17 
18 extern const struct NVOC_CLASS_DEF __nvoc_class_def_RsResource;
19 
20 extern const struct NVOC_CLASS_DEF __nvoc_class_def_RmResourceCommon;
21 
22 extern const struct NVOC_CLASS_DEF __nvoc_class_def_RmResource;
23 
24 void __nvoc_init_Memory(Memory*);
25 void __nvoc_init_funcTable_Memory(Memory*);
26 NV_STATUS __nvoc_ctor_Memory(Memory*, CALL_CONTEXT * arg_pCallContext, struct RS_RES_ALLOC_PARAMS_INTERNAL * arg_pParams);
27 void __nvoc_init_dataField_Memory(Memory*);
28 void __nvoc_dtor_Memory(Memory*);
29 extern const struct NVOC_EXPORT_INFO __nvoc_export_info_Memory;
30 
31 static const struct NVOC_RTTI __nvoc_rtti_Memory_Memory = {
32     /*pClassDef=*/          &__nvoc_class_def_Memory,
33     /*dtor=*/               (NVOC_DYNAMIC_DTOR) &__nvoc_dtor_Memory,
34     /*offset=*/             0,
35 };
36 
37 static const struct NVOC_RTTI __nvoc_rtti_Memory_Object = {
38     /*pClassDef=*/          &__nvoc_class_def_Object,
39     /*dtor=*/               &__nvoc_destructFromBase,
40     /*offset=*/             NV_OFFSETOF(Memory, __nvoc_base_RmResource.__nvoc_base_RsResource.__nvoc_base_Object),
41 };
42 
43 static const struct NVOC_RTTI __nvoc_rtti_Memory_RsResource = {
44     /*pClassDef=*/          &__nvoc_class_def_RsResource,
45     /*dtor=*/               &__nvoc_destructFromBase,
46     /*offset=*/             NV_OFFSETOF(Memory, __nvoc_base_RmResource.__nvoc_base_RsResource),
47 };
48 
49 static const struct NVOC_RTTI __nvoc_rtti_Memory_RmResourceCommon = {
50     /*pClassDef=*/          &__nvoc_class_def_RmResourceCommon,
51     /*dtor=*/               &__nvoc_destructFromBase,
52     /*offset=*/             NV_OFFSETOF(Memory, __nvoc_base_RmResource.__nvoc_base_RmResourceCommon),
53 };
54 
55 static const struct NVOC_RTTI __nvoc_rtti_Memory_RmResource = {
56     /*pClassDef=*/          &__nvoc_class_def_RmResource,
57     /*dtor=*/               &__nvoc_destructFromBase,
58     /*offset=*/             NV_OFFSETOF(Memory, __nvoc_base_RmResource),
59 };
60 
61 static const struct NVOC_CASTINFO __nvoc_castinfo_Memory = {
62     /*numRelatives=*/       5,
63     /*relatives=*/ {
64         &__nvoc_rtti_Memory_Memory,
65         &__nvoc_rtti_Memory_RmResource,
66         &__nvoc_rtti_Memory_RmResourceCommon,
67         &__nvoc_rtti_Memory_RsResource,
68         &__nvoc_rtti_Memory_Object,
69     },
70 };
71 
72 const struct NVOC_CLASS_DEF __nvoc_class_def_Memory =
73 {
74     /*classInfo=*/ {
75         /*size=*/               sizeof(Memory),
76         /*classId=*/            classId(Memory),
77         /*providerId=*/         &__nvoc_rtti_provider,
78 #if NV_PRINTF_STRINGS_ALLOWED
79         /*name=*/               "Memory",
80 #endif
81     },
82     /*objCreatefn=*/        (NVOC_DYNAMIC_OBJ_CREATE) &__nvoc_objCreateDynamic_Memory,
83     /*pCastInfo=*/          &__nvoc_castinfo_Memory,
84     /*pExportInfo=*/        &__nvoc_export_info_Memory
85 };
86 
87 static NV_STATUS __nvoc_thunk_Memory_resIsDuplicate(struct RsResource *pMemory, NvHandle hMemory, NvBool *pDuplicate) {
88     return memIsDuplicate((struct Memory *)(((unsigned char *)pMemory) - __nvoc_rtti_Memory_RsResource.offset), hMemory, pDuplicate);
89 }
90 
91 static NV_STATUS __nvoc_thunk_Memory_resControl(struct RsResource *pMemory, CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) {
92     return memControl((struct Memory *)(((unsigned char *)pMemory) - __nvoc_rtti_Memory_RsResource.offset), pCallContext, pParams);
93 }
94 
95 static NV_STATUS __nvoc_thunk_Memory_resMap(struct RsResource *pMemory, CALL_CONTEXT *pCallContext, struct RS_CPU_MAP_PARAMS *pParams, RsCpuMapping *pCpuMapping) {
96     return memMap((struct Memory *)(((unsigned char *)pMemory) - __nvoc_rtti_Memory_RsResource.offset), pCallContext, pParams, pCpuMapping);
97 }
98 
99 static NV_STATUS __nvoc_thunk_Memory_resUnmap(struct RsResource *pMemory, CALL_CONTEXT *pCallContext, RsCpuMapping *pCpuMapping) {
100     return memUnmap((struct Memory *)(((unsigned char *)pMemory) - __nvoc_rtti_Memory_RsResource.offset), pCallContext, pCpuMapping);
101 }
102 
103 static NV_STATUS __nvoc_thunk_Memory_rmresGetMemInterMapParams(struct RmResource *pMemory, RMRES_MEM_INTER_MAP_PARAMS *pParams) {
104     return memGetMemInterMapParams((struct Memory *)(((unsigned char *)pMemory) - __nvoc_rtti_Memory_RmResource.offset), pParams);
105 }
106 
107 static NV_STATUS __nvoc_thunk_Memory_rmresCheckMemInterUnmap(struct RmResource *pMemory, NvBool bSubdeviceHandleProvided) {
108     return memCheckMemInterUnmap((struct Memory *)(((unsigned char *)pMemory) - __nvoc_rtti_Memory_RmResource.offset), bSubdeviceHandleProvided);
109 }
110 
111 static NV_STATUS __nvoc_thunk_Memory_rmresGetMemoryMappingDescriptor(struct RmResource *pMemory, MEMORY_DESCRIPTOR **ppMemDesc) {
112     return memGetMemoryMappingDescriptor((struct Memory *)(((unsigned char *)pMemory) - __nvoc_rtti_Memory_RmResource.offset), ppMemDesc);
113 }
114 
115 static NvBool __nvoc_thunk_RmResource_memShareCallback(struct Memory *pResource, struct RsClient *pInvokingClient, struct RsResourceRef *pParentRef, RS_SHARE_POLICY *pSharePolicy) {
116     return rmresShareCallback((struct RmResource *)(((unsigned char *)pResource) + __nvoc_rtti_Memory_RmResource.offset), pInvokingClient, pParentRef, pSharePolicy);
117 }
118 
119 static NvU32 __nvoc_thunk_RsResource_memGetRefCount(struct Memory *pResource) {
120     return resGetRefCount((struct RsResource *)(((unsigned char *)pResource) + __nvoc_rtti_Memory_RsResource.offset));
121 }
122 
123 static NV_STATUS __nvoc_thunk_RsResource_memControlFilter(struct Memory *pResource, struct CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) {
124     return resControlFilter((struct RsResource *)(((unsigned char *)pResource) + __nvoc_rtti_Memory_RsResource.offset), pCallContext, pParams);
125 }
126 
127 static void __nvoc_thunk_RsResource_memAddAdditionalDependants(struct RsClient *pClient, struct Memory *pResource, RsResourceRef *pReference) {
128     resAddAdditionalDependants(pClient, (struct RsResource *)(((unsigned char *)pResource) + __nvoc_rtti_Memory_RsResource.offset), pReference);
129 }
130 
131 static NV_STATUS __nvoc_thunk_RsResource_memUnmapFrom(struct Memory *pResource, RS_RES_UNMAP_FROM_PARAMS *pParams) {
132     return resUnmapFrom((struct RsResource *)(((unsigned char *)pResource) + __nvoc_rtti_Memory_RsResource.offset), pParams);
133 }
134 
135 static NV_STATUS __nvoc_thunk_RmResource_memControlSerialization_Prologue(struct Memory *pResource, CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) {
136     return rmresControlSerialization_Prologue((struct RmResource *)(((unsigned char *)pResource) + __nvoc_rtti_Memory_RmResource.offset), pCallContext, pParams);
137 }
138 
139 static NV_STATUS __nvoc_thunk_RmResource_memControl_Prologue(struct Memory *pResource, CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) {
140     return rmresControl_Prologue((struct RmResource *)(((unsigned char *)pResource) + __nvoc_rtti_Memory_RmResource.offset), pCallContext, pParams);
141 }
142 
143 static NvBool __nvoc_thunk_RsResource_memCanCopy(struct Memory *pResource) {
144     return resCanCopy((struct RsResource *)(((unsigned char *)pResource) + __nvoc_rtti_Memory_RsResource.offset));
145 }
146 
147 static void __nvoc_thunk_RsResource_memPreDestruct(struct Memory *pResource) {
148     resPreDestruct((struct RsResource *)(((unsigned char *)pResource) + __nvoc_rtti_Memory_RsResource.offset));
149 }
150 
151 static NV_STATUS __nvoc_thunk_RsResource_memMapTo(struct Memory *pResource, RS_RES_MAP_TO_PARAMS *pParams) {
152     return resMapTo((struct RsResource *)(((unsigned char *)pResource) + __nvoc_rtti_Memory_RsResource.offset), pParams);
153 }
154 
155 static void __nvoc_thunk_RmResource_memControlSerialization_Epilogue(struct Memory *pResource, CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) {
156     rmresControlSerialization_Epilogue((struct RmResource *)(((unsigned char *)pResource) + __nvoc_rtti_Memory_RmResource.offset), pCallContext, pParams);
157 }
158 
159 static void __nvoc_thunk_RmResource_memControl_Epilogue(struct Memory *pResource, CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) {
160     rmresControl_Epilogue((struct RmResource *)(((unsigned char *)pResource) + __nvoc_rtti_Memory_RmResource.offset), pCallContext, pParams);
161 }
162 
163 static NV_STATUS __nvoc_thunk_RsResource_memControlLookup(struct Memory *pResource, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams, const struct NVOC_EXPORTED_METHOD_DEF **ppEntry) {
164     return resControlLookup((struct RsResource *)(((unsigned char *)pResource) + __nvoc_rtti_Memory_RsResource.offset), pParams, ppEntry);
165 }
166 
167 static NvBool __nvoc_thunk_RmResource_memAccessCallback(struct Memory *pResource, struct RsClient *pInvokingClient, void *pAllocParams, RsAccessRight accessRight) {
168     return rmresAccessCallback((struct RmResource *)(((unsigned char *)pResource) + __nvoc_rtti_Memory_RmResource.offset), pInvokingClient, pAllocParams, accessRight);
169 }
170 
171 #if !defined(NVOC_EXPORTED_METHOD_DISABLED_BY_FLAG)
172 #define NVOC_EXPORTED_METHOD_DISABLED_BY_FLAG(x)      (0)
173 #endif
174 
175 static const struct NVOC_EXPORTED_METHOD_DEF __nvoc_exported_method_def_Memory[] =
176 {
177     {               /*  [0] */
178 #if NVOC_EXPORTED_METHOD_DISABLED_BY_FLAG(0x10u)
179         /*pFunc=*/      (void (*)(void)) NULL,
180 #else
181         /*pFunc=*/      (void (*)(void)) memCtrlCmdGetSurfaceInfoLvm_IMPL,
182 #endif // NVOC_EXPORTED_METHOD_DISABLED_BY_FLAG(0x10u)
183         /*flags=*/      0x10u,
184         /*accessRight=*/0x0u,
185         /*methodId=*/   0x410110u,
186         /*paramSize=*/  sizeof(NV0041_CTRL_GET_SURFACE_INFO_PARAMS),
187         /*pClassInfo=*/ &(__nvoc_class_def_Memory.classInfo),
188 #if NV_PRINTF_STRINGS_ALLOWED
189         /*func=*/       "memCtrlCmdGetSurfaceInfoLvm"
190 #endif
191     },
192     {               /*  [1] */
193 #if NVOC_EXPORTED_METHOD_DISABLED_BY_FLAG(0x10u)
194         /*pFunc=*/      (void (*)(void)) NULL,
195 #else
196         /*pFunc=*/      (void (*)(void)) memCtrlCmdGetSurfaceCompressionCoverageLvm_IMPL,
197 #endif // NVOC_EXPORTED_METHOD_DISABLED_BY_FLAG(0x10u)
198         /*flags=*/      0x10u,
199         /*accessRight=*/0x0u,
200         /*methodId=*/   0x410112u,
201         /*paramSize=*/  sizeof(NV0041_CTRL_GET_SURFACE_COMPRESSION_COVERAGE_PARAMS),
202         /*pClassInfo=*/ &(__nvoc_class_def_Memory.classInfo),
203 #if NV_PRINTF_STRINGS_ALLOWED
204         /*func=*/       "memCtrlCmdGetSurfaceCompressionCoverageLvm"
205 #endif
206     },
207     {               /*  [2] */
208 #if NVOC_EXPORTED_METHOD_DISABLED_BY_FLAG(0x10u)
209         /*pFunc=*/      (void (*)(void)) NULL,
210 #else
211         /*pFunc=*/      (void (*)(void)) memCtrlCmdSurfaceFlushGpuCache_IMPL,
212 #endif // NVOC_EXPORTED_METHOD_DISABLED_BY_FLAG(0x10u)
213         /*flags=*/      0x10u,
214         /*accessRight=*/0x0u,
215         /*methodId=*/   0x410116u,
216         /*paramSize=*/  sizeof(NV0041_CTRL_SURFACE_FLUSH_GPU_CACHE_PARAMS),
217         /*pClassInfo=*/ &(__nvoc_class_def_Memory.classInfo),
218 #if NV_PRINTF_STRINGS_ALLOWED
219         /*func=*/       "memCtrlCmdSurfaceFlushGpuCache"
220 #endif
221     },
222     {               /*  [3] */
223 #if NVOC_EXPORTED_METHOD_DISABLED_BY_FLAG(0x10u)
224         /*pFunc=*/      (void (*)(void)) NULL,
225 #else
226         /*pFunc=*/      (void (*)(void)) memCtrlCmdGetMemPageSize_IMPL,
227 #endif // NVOC_EXPORTED_METHOD_DISABLED_BY_FLAG(0x10u)
228         /*flags=*/      0x10u,
229         /*accessRight=*/0x0u,
230         /*methodId=*/   0x410118u,
231         /*paramSize=*/  sizeof(NV0041_CTRL_GET_MEM_PAGE_SIZE_PARAMS),
232         /*pClassInfo=*/ &(__nvoc_class_def_Memory.classInfo),
233 #if NV_PRINTF_STRINGS_ALLOWED
234         /*func=*/       "memCtrlCmdGetMemPageSize"
235 #endif
236     },
237     {               /*  [4] */
238 #if NVOC_EXPORTED_METHOD_DISABLED_BY_FLAG(0x10u)
239         /*pFunc=*/      (void (*)(void)) NULL,
240 #else
241         /*pFunc=*/      (void (*)(void)) memCtrlCmdSetTag_IMPL,
242 #endif // NVOC_EXPORTED_METHOD_DISABLED_BY_FLAG(0x10u)
243         /*flags=*/      0x10u,
244         /*accessRight=*/0x0u,
245         /*methodId=*/   0x410120u,
246         /*paramSize=*/  sizeof(NV0041_CTRL_CMD_SET_TAG_PARAMS),
247         /*pClassInfo=*/ &(__nvoc_class_def_Memory.classInfo),
248 #if NV_PRINTF_STRINGS_ALLOWED
249         /*func=*/       "memCtrlCmdSetTag"
250 #endif
251     },
252     {               /*  [5] */
253 #if NVOC_EXPORTED_METHOD_DISABLED_BY_FLAG(0x10u)
254         /*pFunc=*/      (void (*)(void)) NULL,
255 #else
256         /*pFunc=*/      (void (*)(void)) memCtrlCmdGetTag_IMPL,
257 #endif // NVOC_EXPORTED_METHOD_DISABLED_BY_FLAG(0x10u)
258         /*flags=*/      0x10u,
259         /*accessRight=*/0x0u,
260         /*methodId=*/   0x410121u,
261         /*paramSize=*/  sizeof(NV0041_CTRL_CMD_GET_TAG_PARAMS),
262         /*pClassInfo=*/ &(__nvoc_class_def_Memory.classInfo),
263 #if NV_PRINTF_STRINGS_ALLOWED
264         /*func=*/       "memCtrlCmdGetTag"
265 #endif
266     },
267 
268 };
269 
270 const struct NVOC_EXPORT_INFO __nvoc_export_info_Memory =
271 {
272     /*numEntries=*/     6,
273     /*pExportEntries=*/ __nvoc_exported_method_def_Memory
274 };
275 
276 void __nvoc_dtor_RmResource(RmResource*);
277 void __nvoc_dtor_Memory(Memory *pThis) {
278     __nvoc_memDestruct(pThis);
279     __nvoc_dtor_RmResource(&pThis->__nvoc_base_RmResource);
280     PORT_UNREFERENCED_VARIABLE(pThis);
281 }
282 
283 void __nvoc_init_dataField_Memory(Memory *pThis) {
284     PORT_UNREFERENCED_VARIABLE(pThis);
285 }
286 
287 NV_STATUS __nvoc_ctor_RmResource(RmResource* , CALL_CONTEXT *, struct RS_RES_ALLOC_PARAMS_INTERNAL *);
288 NV_STATUS __nvoc_ctor_Memory(Memory *pThis, CALL_CONTEXT * arg_pCallContext, struct RS_RES_ALLOC_PARAMS_INTERNAL * arg_pParams) {
289     NV_STATUS status = NV_OK;
290     status = __nvoc_ctor_RmResource(&pThis->__nvoc_base_RmResource, arg_pCallContext, arg_pParams);
291     if (status != NV_OK) goto __nvoc_ctor_Memory_fail_RmResource;
292     __nvoc_init_dataField_Memory(pThis);
293 
294     status = __nvoc_memConstruct(pThis, arg_pCallContext, arg_pParams);
295     if (status != NV_OK) goto __nvoc_ctor_Memory_fail__init;
296     goto __nvoc_ctor_Memory_exit; // Success
297 
298 __nvoc_ctor_Memory_fail__init:
299     __nvoc_dtor_RmResource(&pThis->__nvoc_base_RmResource);
300 __nvoc_ctor_Memory_fail_RmResource:
301 __nvoc_ctor_Memory_exit:
302 
303     return status;
304 }
305 
306 static void __nvoc_init_funcTable_Memory_1(Memory *pThis) {
307     PORT_UNREFERENCED_VARIABLE(pThis);
308 
309     pThis->__memIsDuplicate__ = &memIsDuplicate_IMPL;
310 
311     pThis->__memGetMapAddrSpace__ = &memGetMapAddrSpace_IMPL;
312 
313     pThis->__memControl__ = &memControl_IMPL;
314 
315     pThis->__memMap__ = &memMap_IMPL;
316 
317     pThis->__memUnmap__ = &memUnmap_IMPL;
318 
319     pThis->__memGetMemInterMapParams__ = &memGetMemInterMapParams_IMPL;
320 
321     pThis->__memCheckMemInterUnmap__ = &memCheckMemInterUnmap_ac1694;
322 
323     pThis->__memGetMemoryMappingDescriptor__ = &memGetMemoryMappingDescriptor_IMPL;
324 
325     pThis->__memCheckCopyPermissions__ = &memCheckCopyPermissions_ac1694;
326 
327     pThis->__memIsReady__ = &memIsReady_IMPL;
328 
329     pThis->__memIsGpuMapAllowed__ = &memIsGpuMapAllowed_0c883b;
330 
331 #if !NVOC_EXPORTED_METHOD_DISABLED_BY_FLAG(0x10u)
332     pThis->__memCtrlCmdGetSurfaceCompressionCoverageLvm__ = &memCtrlCmdGetSurfaceCompressionCoverageLvm_IMPL;
333 #endif
334 
335 #if !NVOC_EXPORTED_METHOD_DISABLED_BY_FLAG(0x10u)
336     pThis->__memCtrlCmdGetSurfaceInfoLvm__ = &memCtrlCmdGetSurfaceInfoLvm_IMPL;
337 #endif
338 
339 #if !NVOC_EXPORTED_METHOD_DISABLED_BY_FLAG(0x10u)
340     pThis->__memCtrlCmdSurfaceFlushGpuCache__ = &memCtrlCmdSurfaceFlushGpuCache_IMPL;
341 #endif
342 
343 #if !NVOC_EXPORTED_METHOD_DISABLED_BY_FLAG(0x10u)
344     pThis->__memCtrlCmdGetMemPageSize__ = &memCtrlCmdGetMemPageSize_IMPL;
345 #endif
346 
347 #if !NVOC_EXPORTED_METHOD_DISABLED_BY_FLAG(0x10u)
348     pThis->__memCtrlCmdSetTag__ = &memCtrlCmdSetTag_IMPL;
349 #endif
350 
351 #if !NVOC_EXPORTED_METHOD_DISABLED_BY_FLAG(0x10u)
352     pThis->__memCtrlCmdGetTag__ = &memCtrlCmdGetTag_IMPL;
353 #endif
354 
355     pThis->__nvoc_base_RmResource.__nvoc_base_RsResource.__resIsDuplicate__ = &__nvoc_thunk_Memory_resIsDuplicate;
356 
357     pThis->__nvoc_base_RmResource.__nvoc_base_RsResource.__resControl__ = &__nvoc_thunk_Memory_resControl;
358 
359     pThis->__nvoc_base_RmResource.__nvoc_base_RsResource.__resMap__ = &__nvoc_thunk_Memory_resMap;
360 
361     pThis->__nvoc_base_RmResource.__nvoc_base_RsResource.__resUnmap__ = &__nvoc_thunk_Memory_resUnmap;
362 
363     pThis->__nvoc_base_RmResource.__rmresGetMemInterMapParams__ = &__nvoc_thunk_Memory_rmresGetMemInterMapParams;
364 
365     pThis->__nvoc_base_RmResource.__rmresCheckMemInterUnmap__ = &__nvoc_thunk_Memory_rmresCheckMemInterUnmap;
366 
367     pThis->__nvoc_base_RmResource.__rmresGetMemoryMappingDescriptor__ = &__nvoc_thunk_Memory_rmresGetMemoryMappingDescriptor;
368 
369     pThis->__memShareCallback__ = &__nvoc_thunk_RmResource_memShareCallback;
370 
371     pThis->__memGetRefCount__ = &__nvoc_thunk_RsResource_memGetRefCount;
372 
373     pThis->__memControlFilter__ = &__nvoc_thunk_RsResource_memControlFilter;
374 
375     pThis->__memAddAdditionalDependants__ = &__nvoc_thunk_RsResource_memAddAdditionalDependants;
376 
377     pThis->__memUnmapFrom__ = &__nvoc_thunk_RsResource_memUnmapFrom;
378 
379     pThis->__memControlSerialization_Prologue__ = &__nvoc_thunk_RmResource_memControlSerialization_Prologue;
380 
381     pThis->__memControl_Prologue__ = &__nvoc_thunk_RmResource_memControl_Prologue;
382 
383     pThis->__memCanCopy__ = &__nvoc_thunk_RsResource_memCanCopy;
384 
385     pThis->__memPreDestruct__ = &__nvoc_thunk_RsResource_memPreDestruct;
386 
387     pThis->__memMapTo__ = &__nvoc_thunk_RsResource_memMapTo;
388 
389     pThis->__memControlSerialization_Epilogue__ = &__nvoc_thunk_RmResource_memControlSerialization_Epilogue;
390 
391     pThis->__memControl_Epilogue__ = &__nvoc_thunk_RmResource_memControl_Epilogue;
392 
393     pThis->__memControlLookup__ = &__nvoc_thunk_RsResource_memControlLookup;
394 
395     pThis->__memAccessCallback__ = &__nvoc_thunk_RmResource_memAccessCallback;
396 }
397 
398 void __nvoc_init_funcTable_Memory(Memory *pThis) {
399     __nvoc_init_funcTable_Memory_1(pThis);
400 }
401 
402 void __nvoc_init_RmResource(RmResource*);
403 void __nvoc_init_Memory(Memory *pThis) {
404     pThis->__nvoc_pbase_Memory = pThis;
405     pThis->__nvoc_pbase_Object = &pThis->__nvoc_base_RmResource.__nvoc_base_RsResource.__nvoc_base_Object;
406     pThis->__nvoc_pbase_RsResource = &pThis->__nvoc_base_RmResource.__nvoc_base_RsResource;
407     pThis->__nvoc_pbase_RmResourceCommon = &pThis->__nvoc_base_RmResource.__nvoc_base_RmResourceCommon;
408     pThis->__nvoc_pbase_RmResource = &pThis->__nvoc_base_RmResource;
409     __nvoc_init_RmResource(&pThis->__nvoc_base_RmResource);
410     __nvoc_init_funcTable_Memory(pThis);
411 }
412 
413 NV_STATUS __nvoc_objCreate_Memory(Memory **ppThis, Dynamic *pParent, NvU32 createFlags, CALL_CONTEXT * arg_pCallContext, struct RS_RES_ALLOC_PARAMS_INTERNAL * arg_pParams) {
414     NV_STATUS status;
415     Object *pParentObj;
416     Memory *pThis;
417 
418     status = __nvoc_handleObjCreateMemAlloc(createFlags, sizeof(Memory), (void**)&pThis, (void**)ppThis);
419     if (status != NV_OK)
420         return status;
421 
422     portMemSet(pThis, 0, sizeof(Memory));
423 
424     __nvoc_initRtti(staticCast(pThis, Dynamic), &__nvoc_class_def_Memory);
425 
426     pThis->__nvoc_base_RmResource.__nvoc_base_RsResource.__nvoc_base_Object.createFlags = createFlags;
427 
428     if (pParent != NULL && !(createFlags & NVOC_OBJ_CREATE_FLAGS_PARENT_HALSPEC_ONLY))
429     {
430         pParentObj = dynamicCast(pParent, Object);
431         objAddChild(pParentObj, &pThis->__nvoc_base_RmResource.__nvoc_base_RsResource.__nvoc_base_Object);
432     }
433     else
434     {
435         pThis->__nvoc_base_RmResource.__nvoc_base_RsResource.__nvoc_base_Object.pParent = NULL;
436     }
437 
438     __nvoc_init_Memory(pThis);
439     status = __nvoc_ctor_Memory(pThis, arg_pCallContext, arg_pParams);
440     if (status != NV_OK) goto __nvoc_objCreate_Memory_cleanup;
441 
442     *ppThis = pThis;
443 
444     return NV_OK;
445 
446 __nvoc_objCreate_Memory_cleanup:
447     // do not call destructors here since the constructor already called them
448     if (createFlags & NVOC_OBJ_CREATE_FLAGS_IN_PLACE_CONSTRUCT)
449         portMemSet(pThis, 0, sizeof(Memory));
450     else
451         portMemFree(pThis);
452 
453     // coverity[leaked_storage:FALSE]
454     return status;
455 }
456 
457 NV_STATUS __nvoc_objCreateDynamic_Memory(Memory **ppThis, Dynamic *pParent, NvU32 createFlags, va_list args) {
458     NV_STATUS status;
459     CALL_CONTEXT * arg_pCallContext = va_arg(args, CALL_CONTEXT *);
460     struct RS_RES_ALLOC_PARAMS_INTERNAL * arg_pParams = va_arg(args, struct RS_RES_ALLOC_PARAMS_INTERNAL *);
461 
462     status = __nvoc_objCreate_Memory(ppThis, pParent, createFlags, arg_pCallContext, arg_pParams);
463 
464     return status;
465 }
466 
467