← Back to branch summary

~mmach/netext73/mesa-haswell

« back to all changes in this revision

Viewing changes to src/amd/addrlib/src/core/addrobject.cpp

  • Committer: mmach
  • Date: 2022-09-22 19:56:13 UTC
  • Revision ID: netbit73@gmail.com-20220922195613-wtik9mmy20tmor0i
2022-09-22 21:17:09

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/amd/addrlib/src/core/addrobject.cpp
1
 
/*
2
 
************************************************************************************************************************
3
 
*
4
 
*  Copyright (C) 2007-2022 Advanced Micro Devices, Inc.  All rights reserved.
5
 
*
6
 
* Permission is hereby granted, free of charge, to any person obtaining a
7
 
* copy of this software and associated documentation files (the "Software"),
8
 
* to deal in the Software without restriction, including without limitation
9
 
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
10
 
* and/or sell copies of the Software, and to permit persons to whom the
11
 
* Software is furnished to do so, subject to the following conditions:
12
 
*
13
 
* The above copyright notice and this permission notice shall be included in
14
 
* all copies or substantial portions of the Software.
15
 
*
16
 
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17
 
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18
 
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19
 
* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
20
 
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21
 
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22
 
* OTHER DEALINGS IN THE SOFTWARE
23
 
*
24
 
***********************************************************************************************************************/
25
 
 
26
 
 
27
 
/**
28
 
****************************************************************************************************
29
 
* @file  addrobject.cpp
30
 
* @brief Contains the Object base class implementation.
31
 
****************************************************************************************************
32
 
*/
33
 
 
34
 
#include "addrinterface.h"
35
 
#include "addrobject.h"
36
 
 
37
 
namespace Addr
38
 
{
39
 
 
40
 
/**
41
 
****************************************************************************************************
42
 
*   Object::Object
43
 
*
44
 
*   @brief
45
 
*       Constructor for the Object class.
46
 
****************************************************************************************************
47
 
*/
48
 
Object::Object()
49
 
{
50
 
    m_client.handle = NULL;
51
 
    m_client.callbacks.allocSysMem = NULL;
52
 
    m_client.callbacks.freeSysMem = NULL;
53
 
    m_client.callbacks.debugPrint = NULL;
54
 
}
55
 
 
56
 
/**
57
 
****************************************************************************************************
58
 
*   Object::Object
59
 
*
60
 
*   @brief
61
 
*       Constructor for the Object class.
62
 
****************************************************************************************************
63
 
*/
64
 
Object::Object(const Client* pClient)
65
 
{
66
 
    m_client = *pClient;
67
 
}
68
 
 
69
 
/**
70
 
****************************************************************************************************
71
 
*   Object::~Object
72
 
*
73
 
*   @brief
74
 
*       Destructor for the Object class.
75
 
****************************************************************************************************
76
 
*/
77
 
Object::~Object()
78
 
{
79
 
}
80
 
 
81
 
/**
82
 
****************************************************************************************************
83
 
*   Object::ClientAlloc
84
 
*
85
 
*   @brief
86
 
*       Calls instanced allocSysMem inside Client
87
 
****************************************************************************************************
88
 
*/
89
 
VOID* Object::ClientAlloc(
90
 
    size_t         objSize,    ///< [in] Size to allocate
91
 
    const Client*  pClient)    ///< [in] Client pointer
92
 
{
93
 
    VOID* pObjMem = NULL;
94
 
 
95
 
    if (pClient->callbacks.allocSysMem != NULL)
96
 
    {
97
 
        ADDR_ALLOCSYSMEM_INPUT allocInput = {0};
98
 
 
99
 
        allocInput.size        = sizeof(ADDR_ALLOCSYSMEM_INPUT);
100
 
        allocInput.flags.value = 0;
101
 
        allocInput.sizeInBytes = static_cast<UINT_32>(objSize);
102
 
        allocInput.hClient     = pClient->handle;
103
 
 
104
 
        pObjMem = pClient->callbacks.allocSysMem(&allocInput);
105
 
    }
106
 
 
107
 
    return pObjMem;
108
 
}
109
 
 
110
 
/**
111
 
****************************************************************************************************
112
 
*   Object::Alloc
113
 
*
114
 
*   @brief
115
 
*       A wrapper of ClientAlloc
116
 
****************************************************************************************************
117
 
*/
118
 
VOID* Object::Alloc(
119
 
    size_t objSize      ///< [in] Size to allocate
120
 
    ) const
121
 
{
122
 
    return ClientAlloc(objSize, &m_client);;
123
 
}
124
 
 
125
 
/**
126
 
****************************************************************************************************
127
 
*   Object::ClientFree
128
 
*
129
 
*   @brief
130
 
*       Calls freeSysMem inside Client
131
 
****************************************************************************************************
132
 
*/
133
 
VOID Object::ClientFree(
134
 
    VOID*          pObjMem,    ///< [in] User virtual address to free.
135
 
    const Client*  pClient)    ///< [in] Client pointer
136
 
{
137
 
    if (pClient->callbacks.freeSysMem != NULL)
138
 
    {
139
 
        if (pObjMem != NULL)
140
 
        {
141
 
            ADDR_FREESYSMEM_INPUT freeInput = {0};
142
 
 
143
 
            freeInput.size      = sizeof(ADDR_FREESYSMEM_INPUT);
144
 
            freeInput.hClient   = pClient->handle;
145
 
            freeInput.pVirtAddr = pObjMem;
146
 
 
147
 
            pClient->callbacks.freeSysMem(&freeInput);
148
 
        }
149
 
    }
150
 
}
151
 
 
152
 
/**
153
 
****************************************************************************************************
154
 
*   Object::Free
155
 
*
156
 
*   @brief
157
 
*       A wrapper of ClientFree
158
 
****************************************************************************************************
159
 
*/
160
 
VOID Object::Free(
161
 
    VOID* pObjMem       ///< [in] User virtual address to free.
162
 
    ) const
163
 
{
164
 
    ClientFree(pObjMem, &m_client);
165
 
}
166
 
 
167
 
/**
168
 
****************************************************************************************************
169
 
*   Object::operator new
170
 
*
171
 
*   @brief
172
 
*       Placement new operator. (with pre-allocated memory pointer)
173
 
*
174
 
*   @return
175
 
*       Returns pre-allocated memory pointer.
176
 
****************************************************************************************************
177
 
*/
178
 
VOID* Object::operator new(
179
 
    size_t objSize,     ///< [in] Size to allocate
180
 
    VOID*  pMem        ///< [in] Pre-allocated pointer
181
 
    ) noexcept
182
 
{
183
 
    return pMem;
184
 
}
185
 
 
186
 
/**
187
 
****************************************************************************************************
188
 
*   Object::operator delete
189
 
*
190
 
*   @brief
191
 
*       Frees Object object memory.
192
 
****************************************************************************************************
193
 
*/
194
 
VOID Object::operator delete(
195
 
    VOID* pObjMem)      ///< [in] User virtual address to free.
196
 
{
197
 
    Object* pObj = static_cast<Object*>(pObjMem);
198
 
    ClientFree(pObjMem, &pObj->m_client);
199
 
}
200
 
 
201
 
/**
202
 
****************************************************************************************************
203
 
*   Object::DebugPrint
204
 
*
205
 
*   @brief
206
 
*       Print debug message
207
 
*
208
 
*   @return
209
 
*       N/A
210
 
****************************************************************************************************
211
 
*/
212
 
VOID Object::DebugPrint(
213
 
    const CHAR* pDebugString,     ///< [in] Debug string
214
 
    ...
215
 
    ) const
216
 
{
217
 
#if DEBUG
218
 
    if (m_client.callbacks.debugPrint != NULL)
219
 
    {
220
 
        va_list ap;
221
 
 
222
 
        va_start(ap, pDebugString);
223
 
 
224
 
        ADDR_DEBUGPRINT_INPUT debugPrintInput = {0};
225
 
 
226
 
        debugPrintInput.size         = sizeof(ADDR_DEBUGPRINT_INPUT);
227
 
        debugPrintInput.pDebugString = const_cast<CHAR*>(pDebugString);
228
 
        debugPrintInput.hClient      = m_client.handle;
229
 
        va_copy(debugPrintInput.ap, ap);
230
 
 
231
 
        m_client.callbacks.debugPrint(&debugPrintInput);
232
 
 
233
 
        va_end(ap);
234
 
        va_end(debugPrintInput.ap);
235
 
    }
236
 
#endif
237
 
}
238
 
 
239
 
} // Addr