Blame - glave-generate.py - platform/external/vulkan-validation-layers

return ("{%s.channelFormat = %%s, %s.numericFormat = %%s}" % (name, name), "string_XGL_CHANNEL_FORMAT(%s.channelFormat), string_XGL_NUM_FORMAT(%s.numericFormat)" % (name, name))

123

if output_param:

124

return ("%p", "(void*)*%s" % name)

125

return ("%p", "(void*)(%s)" % name)

126

127

def _generate_trace_func_ptrs(self):

128

func_ptrs = []

129

func_ptrs.append('// Pointers to real functions and declarations of hooked functions')

130

func_ptrs.append('#ifdef WIN32')

131

func_ptrs.append('extern INIT_ONCE gInitOnce;')

132

for proto in self.protos:

133

if True not in [skip_str in proto.name for skip_str in ['Dbg', 'Wsi']]: #Dbg' not in proto.name and 'Wsi' not in proto.name:

134

func_ptrs.append('#define __HOOKED_xgl%s hooked_xgl%s' % (proto.name, proto.name))

135

136

func_ptrs.append('\n#elif defined(PLATFORM_LINUX)')

137

func_ptrs.append('extern pthread_once_t gInitOnce;')

138

for proto in self.protos:

139

if True not in [skip_str in proto.name for skip_str in ['Dbg', 'Wsi']]:

140

func_ptrs.append('#define __HOOKED_xgl%s xgl%s' % (proto.name, proto.name))

141

142

func_ptrs.append('#endif\n')

143

return "\n".join(func_ptrs)

144

145

def _generate_trace_func_ptrs_ext(self, func_class='Wsi'):

146

func_ptrs = []

147

func_ptrs.append('#ifdef WIN32')

148

for proto in self.protos:

149

if func_class in proto.name:

150

func_ptrs.append('#define __HOOKED_xgl%s hooked_xgl%s' % (proto.name, proto.name))

151

152

func_ptrs.append('#elif defined(__linux__)')

153

for proto in self.protos:

154

if func_class in proto.name:

155

func_ptrs.append('#define __HOOKED_xgl%s xgl%s' % (proto.name, proto.name))

156

157

func_ptrs.append('#endif\n')

158

return "\n".join(func_ptrs)

159

160

def _generate_trace_func_protos(self):

161

func_protos = []

162

func_protos.append('// Hooked function prototypes\n')

163

for proto in self.protos:

164

if 'Dbg' not in proto.name and 'Wsi' not in proto.name:

165

func_protos.append('%s;' % proto.c_func(prefix="__HOOKED_xgl", attr="XGLAPI"))

166

167

return "\n".join(func_protos)

168

169

def _generate_trace_func_protos_ext(self, func_class='Wsi'):

170

func_protos = []

171

func_protos.append('// Hooked function prototypes\n')

172

for proto in self.protos:

173

if func_class in proto.name:

174

func_protos.append('%s;' % proto.c_func(prefix="__HOOKED_xgl", attr="XGLAPI"))

175

176

return "\n".join(func_protos)

177

178

179

def _generate_func_ptr_assignments(self):

180

func_ptr_assign = []

181

for proto in self.protos:

182

if 'Dbg' not in proto.name and 'Wsi' not in proto.name:

183

func_ptr_assign.append('static %s( XGLAPI * real_xgl%s)(' % (proto.ret, proto.name))

184

for p in proto.params:

185

if 'color' == p.name:

186

func_ptr_assign.append(' %s %s[4],' % (p.ty.replace('[4]', ''), p.name))

187

else:

188

func_ptr_assign.append(' %s %s,' % (p.ty, p.name))

189

func_ptr_assign[-1] = func_ptr_assign[-1].replace(',', ') = xgl%s;\n' % (proto.name))

190

func_ptr_assign.append('static BOOL isHooked = FALSE;\n')

191

return "\n".join(func_ptr_assign)

192

193

def _generate_func_ptr_assignments_ext(self, func_class='Wsi'):

194

func_ptr_assign = []

195

for proto in self.protos:

196

if func_class in proto.name:

197

func_ptr_assign.append('static %s( XGLAPI * real_xgl%s)(' % (proto.ret, proto.name))

198

for p in proto.params:

199

func_ptr_assign.append(' %s %s,' % (p.ty, p.name))

200

func_ptr_assign[-1] = func_ptr_assign[-1].replace(',', ') = xgl%s;\n' % (proto.name))

201

return "\n".join(func_ptr_assign)

202

203

def _generate_attach_hooks(self):

204

hooks_txt = []

205

hooks_txt.append('void AttachHooks()\n{\n BOOL hookSuccess = TRUE;\n#if defined(WIN32)')

206

hooks_txt.append(' Mhook_BeginMultiOperation(FALSE);')

207

hooks_txt.append(' if (real_xglInitAndEnumerateGpus != NULL)')

208

hooks_txt.append(' {\n isHooked = TRUE;')

209

hook_operator = '='

210

for proto in self.protos:

211

if 'Dbg' not in proto.name and 'Wsi' not in proto.name:

212

hooks_txt.append(' hookSuccess %s Mhook_SetHook((PVOID*)&real_xgl%s, hooked_xgl%s);' % (hook_operator, proto.name, proto.name))

213

hook_operator = '&='

214

hooks_txt.append(' }\n')

215

hooks_txt.append(' if (!hookSuccess)\n {')

216

hooks_txt.append(' glv_LogError("Failed to hook XGL.");\n }\n')

217

hooks_txt.append(' Mhook_EndMultiOperation();\n')

218

hooks_txt.append('#elif defined(__linux__)')

219

hooks_txt.append(' if (real_xglInitAndEnumerateGpus == xglInitAndEnumerateGpus)')

220

hooks_txt.append(' hookSuccess = glv_platform_get_next_lib_sym((PVOID*)&real_xglInitAndEnumerateGpus,"xglInitAndEnumerateGpus");')

221

hooks_txt.append(' isHooked = TRUE;')

222

for proto in self.protos:

223

if 'Dbg' not in proto.name and 'Wsi' not in proto.name and 'InitAndEnumerateGpus' not in proto.name:

224

hooks_txt.append(' hookSuccess %s glv_platform_get_next_lib_sym((PVOID*)&real_xgl%s, "xgl%s");' % (hook_operator, proto.name, proto.name))

225

hooks_txt.append(' if (!hookSuccess)\n {')

226

hooks_txt.append(' glv_LogError("Failed to hook XGL.");\n }\n')

227

hooks_txt.append('#endif\n}\n')

228

return "\n".join(hooks_txt)

229

230

def _generate_attach_hooks_ext(self, func_class='Wsi'):

231

func_ext_dict = {'Wsi': '_xglwsix11ext', 'Dbg': '_xgldbg'}

232

first_proto_dict = {'Wsi': 'WsiX11AssociateConnection', 'Dbg': 'DbgSetValidationLevel'}

233

hooks_txt = []

234

hooks_txt.append('void AttachHooks%s()\n{\n BOOL hookSuccess = TRUE;\n#if defined(WIN32)' % func_ext_dict[func_class])

235

hooks_txt.append(' Mhook_BeginMultiOperation(FALSE);')

236

hooks_txt.append(' if (real_xgl%s != NULL)' % first_proto_dict[func_class])

237

hooks_txt.append(' {')

238

hook_operator = '='

239

for proto in self.protos:

240

if func_class in proto.name:

241

hooks_txt.append(' hookSuccess %s Mhook_SetHook((PVOID*)&real_xgl%s, hooked_xgl%s);' % (hook_operator, proto.name, proto.name))

242

hook_operator = '&='

243

hooks_txt.append(' }\n')

244

hooks_txt.append(' if (!hookSuccess)\n {')

245

hooks_txt.append(' glv_LogError("Failed to hook XGL ext %s.");\n }\n' % func_class)

246

hooks_txt.append(' Mhook_EndMultiOperation();\n')

247

hooks_txt.append('#elif defined(__linux__)')

248

hooks_txt.append(' hookSuccess = glv_platform_get_next_lib_sym((PVOID*)&real_xgl%s, "xgl%s");' % (first_proto_dict[func_class], first_proto_dict[func_class]))

249

for proto in self.protos:

250

if func_class in proto.name and first_proto_dict[func_class] not in proto.name:

251

hooks_txt.append(' hookSuccess %s glv_platform_get_next_lib_sym((PVOID*)&real_xgl%s, "xgl%s");' % (hook_operator, proto.name, proto.name))

252

hooks_txt.append(' if (!hookSuccess)\n {')

253

hooks_txt.append(' glv_LogError("Failed to hook XGL ext %s.");\n }\n' % func_class)

254

hooks_txt.append('#endif\n}\n')

255

return "\n".join(hooks_txt)

256

257

def _generate_detach_hooks(self):

258

hooks_txt = []

259

hooks_txt.append('void DetachHooks()\n{\n#ifdef __linux__\n return;\n#elif defined(WIN32)')

260

hooks_txt.append(' BOOL unhookSuccess = TRUE;\n if (real_xglGetGpuInfo != NULL)\n {')

261

hook_operator = '='

262

for proto in self.protos:

263

if 'Dbg' not in proto.name and 'Wsi' not in proto.name:

264

hooks_txt.append(' unhookSuccess %s Mhook_Unhook((PVOID*)&real_xgl%s);' % (hook_operator, proto.name))

265

hook_operator = '&='

266

hooks_txt.append(' }\n isHooked = FALSE;')

267

hooks_txt.append(' if (!unhookSuccess)\n {')

268

hooks_txt.append(' glv_LogError("Failed to unhook XGL.");\n }')

269

hooks_txt.append('#endif\n}')

270

hooks_txt.append('#ifdef WIN32\nINIT_ONCE gInitOnce = INIT_ONCE_STATIC_INIT;\n#elif defined(PLATFORM_LINUX)\npthread_once_t gInitOnce = PTHREAD_ONCE_INIT;\n#endif\n')

271

return "\n".join(hooks_txt)

272

273

def _generate_detach_hooks_ext(self, func_class='Wsi'):

274

func_ext_dict = {'Wsi': '_xglwsix11ext', 'Dbg': '_xgldbg'}

275

first_proto_dict = {'Wsi': 'WsiX11AssociateConnection', 'Dbg': 'DbgSetValidationLevel'}

276

hooks_txt = []

277

hooks_txt.append('void DetachHooks%s()\n{\n#ifdef WIN32' % func_ext_dict[func_class])

278

hooks_txt.append(' BOOL unhookSuccess = TRUE;\n if (real_xgl%s != NULL)\n {' % first_proto_dict[func_class])

279

hook_operator = '='

280

for proto in self.protos:

281

if func_class in proto.name:

282

hooks_txt.append(' unhookSuccess %s Mhook_Unhook((PVOID*)&real_xgl%s);' % (hook_operator, proto.name))

283

hook_operator = '&='

284

hooks_txt.append(' }')

285

hooks_txt.append(' if (!unhookSuccess)\n {')

286

hooks_txt.append(' glv_LogError("Failed to unhook XGL ext %s.");\n }' % func_class)

287

hooks_txt.append('#elif defined(__linux__)\n return;\n#endif\n}\n')

288

return "\n".join(hooks_txt)

289

290

def _generate_init_tracer(self):

291

init_tracer = []

292

init_tracer.append('void InitTracer()\n{')

293

init_tracer.append(' gMessageStream = glv_MessageStream_create(FALSE, "127.0.0.1", GLV_BASE_PORT + GLV_TID_XGL);')

294

init_tracer.append(' glv_trace_set_trace_file(glv_FileLike_create_msg(gMessageStream));')

295

init_tracer.append('// glv_tracelog_set_log_file(glv_FileLike_create_file(fopen("glv_log_traceside.txt","w")));')

296

init_tracer.append(' glv_tracelog_set_tracer_id(GLV_TID_XGL);\n}\n')

297

return "\n".join(init_tracer)

298

299

# InitAndEnumerateGpus is unique enough that it gets custom generation code

300

def _gen_iande_gpus(self):

301

iae_body = []

302

iae_body.append('GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglInitAndEnumerateGpus(')

303

iae_body.append(' const XGL_APPLICATION_INFO* pAppInfo,')

304

iae_body.append(' const XGL_ALLOC_CALLBACKS* pAllocCb,')

305

iae_body.append(' XGL_UINT maxGpus,')

306

iae_body.append(' XGL_UINT* pGpuCount,')

307

iae_body.append(' XGL_PHYSICAL_GPU* pGpus)')

308

iae_body.append('{')

309

iae_body.append(' glv_trace_packet_header* pHeader;')

310

iae_body.append(' XGL_RESULT result;')

311

iae_body.append(' uint64_t startTime;')

312

iae_body.append(' struct_xglInitAndEnumerateGpus* pPacket;')

313

iae_body.append('')

314

iae_body.append(' glv_platform_thread_once(&gInitOnce, InitTracer);')

315

iae_body.append(' SEND_ENTRYPOINT_ID(xglInitAndEnumerateGpus);')

316

iae_body.append(' if (real_xglInitAndEnumerateGpus == xglInitAndEnumerateGpus)')

317

iae_body.append(' {')

318

iae_body.append(' glv_platform_get_next_lib_sym((void **) &real_xglInitAndEnumerateGpus,"xglInitAndEnumerateGpus");')

319

iae_body.append(' }')

320

iae_body.append(' startTime = glv_get_time();')

321

iae_body.append(' result = real_xglInitAndEnumerateGpus(pAppInfo, pAllocCb, maxGpus, pGpuCount, pGpus);')

322

iae_body.append('')

323

iae_body.append(' // since we do not know how many gpus will be found must create trace packet after calling xglInit')

324

iae_body.append(' CREATE_TRACE_PACKET(xglInitAndEnumerateGpus, calc_size_XGL_APPLICATION_INFO(pAppInfo) + ((pAllocCb == NULL) ? 0 :sizeof(XGL_ALLOC_CALLBACKS))')

325

iae_body.append(' + sizeof(XGL_UINT) + ((pGpus && pGpuCount) ? *pGpuCount * sizeof(XGL_PHYSICAL_GPU) : 0));')

326

iae_body.append(' pHeader->entrypoint_begin_time = startTime;')

327

iae_body.append(' if (isHooked == FALSE) {')

328

iae_body.append(' AttachHooks();')

329

iae_body.append(' AttachHooks_xgldbg();')

330

iae_body.append(' AttachHooks_xglwsix11ext();')

331

iae_body.append(' }')

332

iae_body.append(' pPacket = interpret_body_as_xglInitAndEnumerateGpus(pHeader);')

333

iae_body.append(' add_XGL_APPLICATION_INFO_to_packet(pHeader, (XGL_APPLICATION_INFO**)&(pPacket->pAppInfo), pAppInfo);')

334

iae_body.append(' if (pAllocCb) {')

335

iae_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocCb), sizeof(XGL_ALLOC_CALLBACKS), pAllocCb);')

336

iae_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocCb));')

337

iae_body.append(' }')

338

iae_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pGpuCount), sizeof(XGL_UINT), pGpuCount);')

339

iae_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pGpuCount));')

340

iae_body.append(' if (pGpuCount && pGpus)')

341

iae_body.append(' {')

342

iae_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pGpus), sizeof(XGL_PHYSICAL_GPU) * *pGpuCount, pGpus);')

343

iae_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pGpus));')

344

iae_body.append(' }')

345

iae_body.append(' pPacket->maxGpus = maxGpus;')

346

iae_body.append(' pPacket->result = result;')

347

iae_body.append(' FINISH_TRACE_PACKET();')

348

iae_body.append(' return result;')

349

iae_body.append('}\n')

350

return "\n".join(iae_body)

351

352

def _gen_unmap_memory(self):

353

um_body = []

354

um_body.append('GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglUnmapMemory(')

355

um_body.append(' XGL_GPU_MEMORY mem)')

356

um_body.append('{')

357

um_body.append(' glv_trace_packet_header* pHeader;')

358

um_body.append(' XGL_RESULT result;')

359

um_body.append(' struct_xglUnmapMemory* pPacket;')

360

um_body.append(' XGLAllocInfo *entry;')

361

um_body.append(' SEND_ENTRYPOINT_PARAMS("xglUnmapMemory(mem %p)\\n", mem);')

362

um_body.append(' // insert into packet the data that was written by CPU between the xglMapMemory call and here')

363

um_body.append(' // Note must do this prior to the real xglUnMap() or else may get a FAULT')

364

um_body.append(' entry = find_mem_info_entry(mem);')

365

um_body.append(' CREATE_TRACE_PACKET(xglUnmapMemory, (entry) ? entry->size : 0);')

366

um_body.append(' pPacket = interpret_body_as_xglUnmapMemory(pHeader);')

367

um_body.append(' if (entry)')

368

um_body.append(' {')

369

um_body.append(' assert(entry->handle == mem);')

370

um_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**) &(pPacket->pData), entry->size, entry->pData);')

371

um_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pData));')

372

um_body.append(' entry->pData = NULL;')

373

um_body.append(' }')

374

um_body.append(' result = real_xglUnmapMemory(mem);')

375

um_body.append(' pPacket->mem = mem;')

376

um_body.append(' pPacket->result = result;')

377

um_body.append(' FINISH_TRACE_PACKET();')

378

um_body.append(' return result;')

379

um_body.append('}\n')

380

return "\n".join(um_body)

381

382

#EL == EnumerateLayers

383

#I think this another case where you have to make the real call prior to CREATE_TRACE_PACKET(). SInce you

384

#don't know how many layers will be returned or how big the strings will be. Alternatively, could be

385

#on the safe side of CREATE_TRACE_PACKET with maxStringSize*maxLayerCount.

386

#EL also needs a loop where add a trace buffer for each layer, depending on how you CREATE_TRACE_PACKET.

387

388

def _generate_trace_funcs(self):

389

func_body = []

390

for proto in self.protos:

391

if 'InitAndEnumerateGpus' == proto.name:

392

func_body.append(self._gen_iande_gpus())

393

elif 'UnmapMemory' == proto.name:

394

func_body.append(self._gen_unmap_memory())

395

elif 'Dbg' not in proto.name and 'Wsi' not in proto.name:

396

packet_update_txt = ''

397

return_txt = ''

398

packet_size = ''

399

in_data_size = False # flag when we need to capture local input size variable for in/out size

400

buff_ptr_indices = []

401

func_body.append('GLVTRACER_EXPORT %s XGLAPI __HOOKED_xgl%s(' % (proto.ret, proto.name))

402

for p in proto.params: # TODO : For all of the ptr types, check them for NULL and return 0 is NULL

403

if 'color' == p.name:

404

func_body.append(' %s %s[4],' % (p.ty.replace('[4]', ''), p.name))

405

else:

406

func_body.append(' %s %s,' % (p.ty, p.name))

407

if '*' in p.ty and 'pSysMem' != p.name and 'pReserved' != p.name:

408

if 'pData' == p.name:

409

if 'dataSize' == proto.params[proto.params.index(p)-1].name:

410

packet_size += 'dataSize + '

411

elif 'counterCount' == proto.params[proto.params.index(p)-1].name:

412

packet_size += 'sizeof(%s) + ' % p.ty.strip('*').strip('const ')

413

else:

414

packet_size += '((pDataSize != NULL && pData != NULL) ? *pDataSize : 0) + '

415

elif '**' in p.ty and 'VOID' in p.ty:

416

packet_size += 'sizeof(XGL_VOID*) + '

417

elif 'VOID' in p.ty:

418

packet_size += 'sizeof(%s) + ' % p.name

419

elif 'CHAR' in p.ty:

420

packet_size += '((%s != NULL) ? strlen((const char *)%s) + 1 : 0) + ' % (p.name, p.name)

421

elif 'DEVICE_CREATE_INFO' in p.ty:

422

packet_size += 'calc_size_XGL_DEVICE_CREATE_INFO(pCreateInfo) + '

423

elif 'pDataSize' in p.name:

424

packet_size += '((pDataSize != NULL) ? sizeof(XGL_SIZE) : 0) + '

425

in_data_size = True;

426

elif 'IMAGE_SUBRESOURCE' in p.ty and 'pSubresource' == p.name:

427

packet_size += '((pSubresource != NULL) ? sizeof(XGL_IMAGE_SUBRESOURCE) : 0) + '

428

else:

429

packet_size += 'sizeof(%s) + ' % p.ty.strip('*').strip('const ')

430

buff_ptr_indices.append(proto.params.index(p))

431

else:

432

if 'color' == p.name:

433

packet_update_txt += ' memcpy((void*)pPacket->color, color, 4 * sizeof(XGL_UINT32));\n'

434

else:

435

packet_update_txt += ' pPacket->%s = %s;\n' % (p.name, p.name)

436

if 'Count' in p.name and proto.params[-1].name != p.name and p.name not in ['queryCount', 'vertexCount', 'indexCount', 'startCounter'] and proto.name not in ['CmdLoadAtomicCounters', 'CmdSaveAtomicCounters']:

437

packet_size += '%s*' % p.name

438

if '' == packet_size:

439

packet_size = '0'

440

else:

441

packet_size = packet_size.strip(' + ')

442

func_body[-1] = func_body[-1].replace(',', ')')

443

func_body.append('{\n glv_trace_packet_header* pHeader;')

444

if 'VOID' not in proto.ret or '*' in proto.ret:

445

func_body.append(' %s result;' % proto.ret)

446

return_txt = 'result = '

447

if in_data_size:

448

func_body.append(' XGL_SIZE dataSizeIn = (pDataSize == NULL) ? 0 : *pDataSize;')

449

func_body.append(' struct_xgl%s* pPacket = NULL;' % proto.name)

450

func_body.append(' SEND_ENTRYPOINT_ID(xgl%s);' % proto.name)

451

if 'EnumerateLayers' == proto.name:

452

func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))

453

func_body.append(' XGL_SIZE totStringSize = 0;')

454

func_body.append(' uint32_t i = 0;')

455

func_body.append(' for (i = 0; i < *pOutLayerCount; i++)')

456

func_body.append(' totStringSize += (pOutLayers[i] != NULL) ? strlen((const char*)pOutLayers[i]) + 1: 0;')

457

func_body.append(' CREATE_TRACE_PACKET(xgl%s, totStringSize + sizeof(XGL_SIZE));' % (proto.name))

458

elif proto.name in ['CreateShader', 'CreateGraphicsPipeline', 'CreateComputePipeline']:

459

func_body.append(' size_t customSize;')

460

if 'CreateShader' == proto.name:

461

func_body.append(' customSize = (pCreateInfo != NULL) ? pCreateInfo->codeSize : 0;')

462

func_body.append(' CREATE_TRACE_PACKET(xglCreateShader, sizeof(XGL_SHADER_CREATE_INFO) + sizeof(XGL_SHADER) + customSize);')

463

elif 'CreateGraphicsPipeline' == proto.name:

464

func_body.append(' customSize = calculate_pipeline_state_size(pCreateInfo->pNext);')

465

func_body.append(' CREATE_TRACE_PACKET(xglCreateGraphicsPipeline, sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO) + sizeof(XGL_PIPELINE) + customSize);')

466

else: #'CreateComputePipeline'

467

func_body.append(' customSize = calculate_pipeline_state_size(pCreateInfo->pNext);')

468

func_body.append(' CREATE_TRACE_PACKET(xglCreateComputePipeline, sizeof(XGL_COMPUTE_PIPELINE_CREATE_INFO) + sizeof(XGL_PIPELINE) + customSize + calculate_pipeline_shader_size(&pCreateInfo->cs));')

469

func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))

470

else:

471

func_body.append(' CREATE_TRACE_PACKET(xgl%s, %s);' % (proto.name, packet_size))

472

func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))

473

func_body.append(' pPacket = interpret_body_as_xgl%s(pHeader);' % proto.name)

474

func_body.append(packet_update_txt.strip('\n'))

475

if 'MapMemory' == proto.name: # Custom code for MapMem case

476

func_body.append(' if (ppData != NULL)')

477

func_body.append(' {')

478

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->ppData), sizeof(XGL_VOID*), *ppData);')

479

func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->ppData));')

480

func_body.append(' add_data_to_mem_info(mem, *ppData);')

481

func_body.append(' }')

482

func_body.append(' pPacket->result = result;')

483

func_body.append(' FINISH_TRACE_PACKET();')

484

elif 'EnumerateLayers' == proto.name: #custom code for EnumerateLayers case

485

func_body.append(' pPacket->gpu = gpu;')

486

func_body.append(' pPacket->maxLayerCount = maxLayerCount;')

487

func_body.append(' pPacket->maxStringSize = maxStringSize;')

488

func_body.append(' for (i = 0; i < *pOutLayerCount; i++) {')

489

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pOutLayers[i]), ((pOutLayers[i] != NULL) ? strlen((const char *)pOutLayers[i]) + 1 : 0), pOutLayers[i]);')

490

func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pOutLayers[i]));')

491

func_body.append(' }')

492

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pOutLayerCount), sizeof(XGL_SIZE), pOutLayerCount);')

493

func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pOutLayerCount));')

494

495

func_body.append(' pPacket->pReserved = pReserved;')

496

func_body.append(' pPacket->result = result;')

497

func_body.append(' FINISH_TRACE_PACKET();')

498

else:

499

# TODO : Clean this up. Too much custom code and branching.

500

for idx in buff_ptr_indices:

501

if 'DEVICE_CREATE_INFO' in proto.params[idx].ty:

502

func_body.append(' add_XGL_DEVICE_CREATE_INFO_to_packet(pHeader, (XGL_DEVICE_CREATE_INFO**) &(pPacket->pCreateInfo), pCreateInfo);')

503

elif 'CHAR' in proto.params[idx].ty:

504

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), ((%s != NULL) ? strlen((const char *)%s) + 1 : 0), %s);' % (proto.params[idx].name, proto.params[idx].name, proto.params[idx].name, proto.params[idx].name))

505

elif 'Count' in proto.params[idx-1].name and 'queryCount' != proto.params[idx-1].name:

506

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), %s*sizeof(%s), %s);' % (proto.params[idx].name, proto.params[idx-1].name, proto.params[idx].ty.strip('*').strip('const '), proto.params[idx].name))

507

elif 'dataSize' == proto.params[idx].name:

508

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), dataSize, %s);' % (proto.params[idx].name, proto.params[idx].name))

509

elif 'pDataSize' == proto.params[idx].name:

510

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), sizeof(XGL_SIZE), &dataSizeIn);' % (proto.params[idx].name))

511

elif 'pData' == proto.params[idx].name:

512

if 'dataSize' == proto.params[idx-1].name:

513

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), dataSize, %s);' % (proto.params[idx].name, proto.params[idx].name))

514

elif in_data_size:

515

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), dataSizeIn, %s);' % (proto.params[idx].name, proto.params[idx].name))

516

else:

517

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), (pDataSize != NULL && pData != NULL) ? *pDataSize : 0, %s);' % (proto.params[idx].name, proto.params[idx].name))

518

else:

519

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), sizeof(%s), %s);' % (proto.params[idx].name, proto.params[idx].ty.strip('*').strip('const '), proto.params[idx].name))

520

# Some custom add_* and finalize_* function calls for Create* API calls

521

if proto.name in ['CreateShader', 'CreateGraphicsPipeline', 'CreateComputePipeline']:

522

if 'CreateShader' == proto.name:

523

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pCode), customSize, pCreateInfo->pCode);')

524

func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pCode));')

525

elif 'CreateGraphicsPipeline' == proto.name:

526

func_body.append(' add_pipeline_state_to_trace_packet(pHeader, (XGL_VOID**)&pPacket->pCreateInfo->pNext, pCreateInfo->pNext);')

527

else:

528

func_body.append(' add_pipeline_state_to_trace_packet(pHeader, (XGL_VOID**)&(pPacket->pCreateInfo->pNext), pCreateInfo->pNext);')

529

func_body.append(' add_pipeline_shader_to_trace_packet(pHeader, (XGL_PIPELINE_SHADER*)&pPacket->pCreateInfo->cs, &pCreateInfo->cs);')

530

func_body.append(' finalize_pipeline_shader_address(pHeader, &pPacket->pCreateInfo->cs);')

531

if 'VOID' not in proto.ret or '*' in proto.ret:

532

func_body.append(' pPacket->result = result;')

533

for idx in buff_ptr_indices:

534

if 'DEVICE_CREATE_INFO' not in proto.params[idx].ty:

535

func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s));' % (proto.params[idx].name))

536

func_body.append(' FINISH_TRACE_PACKET();')

537

if 'AllocMemory' in proto.name:

538

func_body.append(' add_new_handle_to_mem_info(*pMem, pAllocInfo->allocationSize, NULL);')

539

elif 'FreeMemory' in proto.name:

540

func_body.append(' rm_handle_from_mem_info(mem);')

541

if 'VOID' not in proto.ret or '*' in proto.ret:

542

func_body.append(' return result;')

543

func_body.append('}\n')

544

return "\n".join(func_body)

545

546

def _generate_trace_funcs_ext(self, func_class='Wsi'):

547

thread_once_funcs = ['DbgRegisterMsgCallback', 'DbgUnregisterMsgCallback', 'DbgSetGlobalOption']

548

func_body = []

549

for proto in self.protos:

550

if func_class in proto.name:

551

packet_update_txt = ''

552

return_txt = ''

553

packet_size = ''

554

buff_ptr_indices = []

555

func_body.append('GLVTRACER_EXPORT %s XGLAPI __HOOKED_xgl%s(' % (proto.ret, proto.name))

556

for p in proto.params: # TODO : For all of the ptr types, check them for NULL and return 0 is NULL

557

func_body.append(' %s %s,' % (p.ty, p.name))

558

if 'Size' in p.name:

559

packet_size += p.name

560

if '*' in p.ty and 'pSysMem' != p.name:

561

if 'CHAR' in p.ty:

562

packet_size += '((%s != NULL) ? strlen((const char *)%s) + 1 : 0) + ' % (p.name, p.name)

563

elif 'Size' not in packet_size:

564

packet_size += 'sizeof(%s) + ' % p.ty.strip('*').strip('const ')

565

buff_ptr_indices.append(proto.params.index(p))

566

if 'pConnectionInfo' in p.name:

567

packet_size += '((pConnectionInfo->pConnection != NULL) ? sizeof(void *) : 0)'

568

else:

569

packet_update_txt += ' pPacket->%s = %s;\n' % (p.name, p.name)

570

if '' == packet_size:

571

packet_size = '0'

572

else:

573

packet_size = packet_size.strip(' + ')

574

func_body[-1] = func_body[-1].replace(',', ')')

575

func_body.append('{\n glv_trace_packet_header* pHeader;')

576

if 'VOID' not in proto.ret or '*' in proto.ret:

577

func_body.append(' %s result;' % proto.ret)

578

return_txt = 'result = '

579

func_body.append(' struct_xgl%s* pPacket = NULL;' % proto.name)

580

if proto.name in thread_once_funcs:

581

func_body.append(' glv_platform_thread_once(&gInitOnce, InitTracer);')

582

func_body.append(' SEND_ENTRYPOINT_ID(xgl%s);' % proto.name)

583

func_body.append(' CREATE_TRACE_PACKET(xgl%s, %s);' % (proto.name, packet_size))

584

func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))

585

func_body.append(' pPacket = interpret_body_as_xgl%s(pHeader);' % proto.name)

586

func_body.append(packet_update_txt.strip('\n'))

587

for idx in buff_ptr_indices:

588

if 'CHAR' in proto.params[idx].ty:

589

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), ((%s != NULL) ? strlen((const char *)%s) + 1 : 0), %s);' % (proto.params[idx].name, proto.params[idx].name, proto.params[idx].name, proto.params[idx].name))

590

elif 'Size' in proto.params[idx-1].name:

591

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), %s, %s);' % (proto.params[idx].name, proto.params[idx-1].name, proto.params[idx].name))

592

else:

593

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), sizeof(%s), %s);' % (proto.params[idx].name, proto.params[idx].ty.strip('*').strip('const '), proto.params[idx].name))

594

if 'WsiX11AssociateConnection' in proto.name:

595

func_body.append(' if (pConnectionInfo->pConnection != NULL) {')

596

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**) &(pPacket->pConnectionInfo->pConnection), sizeof(void *), pConnectionInfo->pConnection);')

597

func_body.append(' glv_finalize_buffer_address(pHeader, (void**) &(pPacket->pConnectionInfo->pConnection));')

598

func_body.append(' }')

599

if 'VOID' not in proto.ret or '*' in proto.ret:

600

func_body.append(' pPacket->result = result;')

601

for idx in buff_ptr_indices:

602

func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s));' % (proto.params[idx].name))

603

func_body.append(' FINISH_TRACE_PACKET();')

604

if 'VOID' not in proto.ret or '*' in proto.ret:

605

func_body.append(' return result;')

606

func_body.append('}\n')

607

return "\n".join(func_body)

608

609

def _generate_helper_funcs(self):

610

hf_body = []

611

hf_body.append('// Support for shadowing CPU mapped memory')

612

hf_body.append('typedef struct _XGLAllocInfo {')

613

hf_body.append(' XGL_GPU_SIZE size;')

614

hf_body.append(' XGL_GPU_MEMORY handle;')

615

hf_body.append(' XGL_VOID *pData;')

616

hf_body.append(' BOOL valid;')

617

hf_body.append('} XGLAllocInfo;')

618

hf_body.append('typedef struct _XGLMemInfo {')

619

hf_body.append(' unsigned int numEntrys;')

620

hf_body.append(' XGLAllocInfo *pEntrys;')

621

hf_body.append(' XGLAllocInfo *pLastMapped;')

622

hf_body.append(' unsigned int capacity;')

623

hf_body.append('} XGLMemInfo;')

624

hf_body.append('')

625

hf_body.append('static XGLMemInfo mInfo = {0, NULL, NULL, 0};')

626

hf_body.append('')

627

hf_body.append('static void init_mem_info_entrys(XGLAllocInfo *ptr, const unsigned int num)')

628

hf_body.append('{')

629

hf_body.append(' unsigned int i;')

630

hf_body.append(' for (i = 0; i < num; i++)')

631

hf_body.append(' {')

632

hf_body.append(' XGLAllocInfo *entry = ptr + i;')

633

hf_body.append(' entry->pData = NULL;')

634

hf_body.append(' entry->size = 0;')

635

hf_body.append(' entry->handle = NULL;')

636

hf_body.append(' entry->valid = FALSE;')

hf_body.append(' }')

hf_body.append('}')

hf_body.append('')

hf_body.append('static void init_mem_info()')

641

hf_body.append('{')

642

hf_body.append(' mInfo.numEntrys = 0;')

643

hf_body.append(' mInfo.capacity = 1024;')

644

hf_body.append(' mInfo.pLastMapped = NULL;')

645

hf_body.append('')

646

hf_body.append(' mInfo.pEntrys = GLV_NEW_ARRAY(XGLAllocInfo, mInfo.capacity);')

647

hf_body.append('')

648

hf_body.append(' if (mInfo.pEntrys == NULL)')

649

hf_body.append(' glv_LogError("init_mem_info() malloc failed\\n");')

650

hf_body.append(' else')

651

hf_body.append(' init_mem_info_entrys(mInfo.pEntrys, mInfo.capacity);')

652

hf_body.append('}')

653

hf_body.append('')

654

hf_body.append('static void delete_mem_info()')

655

hf_body.append('{')

656

hf_body.append(' GLV_DELETE(mInfo.pEntrys);')

657

hf_body.append(' mInfo.pEntrys = NULL;')

658

hf_body.append(' mInfo.numEntrys = 0;')

659

hf_body.append(' mInfo.capacity = 0;')

660

hf_body.append(' mInfo.pLastMapped = NULL;')

661

hf_body.append('}')

662

hf_body.append('')

663

hf_body.append('static XGLAllocInfo * get_mem_info_entry()')

664

hf_body.append('{')

665

hf_body.append(' unsigned int i;')

666

hf_body.append(' XGLAllocInfo *entry;')

667

hf_body.append(' if (mInfo.numEntrys > mInfo.capacity)')

668

hf_body.append(' {')

669

hf_body.append(' glv_LogError("get_mem_info_entry() bad internal state numEntrys\\n");')

670

hf_body.append(' return NULL;')

671

hf_body.append(' }')

672

hf_body.append('')

673

hf_body.append(' if (mInfo.numEntrys == mInfo.capacity)')

674

hf_body.append(' { // grow the array 2x')

675

hf_body.append(' mInfo.capacity *= 2;')

676

hf_body.append(' mInfo.pEntrys = (XGLAllocInfo *) GLV_REALLOC(mInfo.pEntrys, mInfo.capacity * sizeof(XGLAllocInfo));')

677

hf_body.append(' //init the newly added entrys')

678

hf_body.append(' init_mem_info_entrys(mInfo.pEntrys + mInfo.capacity / 2, mInfo.capacity / 2);')

679

hf_body.append(' }')

680

hf_body.append('')

681

hf_body.append(' assert(mInfo.numEntrys < mInfo.capacity);')

682

hf_body.append(' entry = mInfo.pEntrys;')

683

hf_body.append(' for (i = 0; i < mInfo.capacity; i++)')

684

hf_body.append(' {')

685

hf_body.append(' if ((entry + i)->valid == FALSE)')

686

hf_body.append(' return entry + i;')

687

hf_body.append(' }')

688

hf_body.append('')

689

hf_body.append(' glv_LogError("get_mem_info_entry() did not find an entry\\n");')

690

hf_body.append(' return NULL;')

691

hf_body.append('}')

692

hf_body.append('')

693

hf_body.append('static XGLAllocInfo * find_mem_info_entry(const XGL_GPU_MEMORY handle)')

694

hf_body.append('{')

695

hf_body.append(' XGLAllocInfo *entry = mInfo.pEntrys;')

696

hf_body.append(' unsigned int i;')

697

hf_body.append(' if (mInfo.pLastMapped && mInfo.pLastMapped->handle == handle && mInfo.pLastMapped->valid)')

698

hf_body.append(' return mInfo.pLastMapped;')

699

hf_body.append(' for (i = 0; i < mInfo.numEntrys; i++)')

700

hf_body.append(' {')

701

hf_body.append(' if ((entry + i)->valid && (handle == (entry + i)->handle))')

702

hf_body.append(' return entry + i;')

703

hf_body.append(' }')

704

hf_body.append('')

705

hf_body.append(' return NULL;')

706

hf_body.append('}')

707

hf_body.append('')

708

hf_body.append('static void add_new_handle_to_mem_info(const XGL_GPU_MEMORY handle, XGL_GPU_SIZE size, XGL_VOID *pData)')

709

hf_body.append('{')

710

hf_body.append(' XGLAllocInfo *entry;')

711

hf_body.append('')

712

hf_body.append(' if (mInfo.capacity == 0)')

713

hf_body.append(' init_mem_info();')

714

hf_body.append('')

715

hf_body.append(' entry = get_mem_info_entry();')

716

hf_body.append(' if (entry)')

717

hf_body.append(' {')

718

hf_body.append(' entry->valid = TRUE;')

719

hf_body.append(' entry->handle = handle;')

720

hf_body.append(' entry->size = size;')

721

hf_body.append(' entry->pData = pData; // NOTE: xglFreeMemory will free this mem, so no malloc()')

722

hf_body.append(' mInfo.numEntrys++;')

hf_body.append(' }')

hf_body.append('}')

hf_body.append('')

hf_body.append('static void add_data_to_mem_info(const XGL_GPU_MEMORY handle, XGL_VOID *pData)')

727

hf_body.append('{')

728

hf_body.append(' XGLAllocInfo *entry = find_mem_info_entry(handle);')

729

hf_body.append('')

730

hf_body.append(' if (entry)')

731

hf_body.append(' {')

732

hf_body.append(' entry->pData = pData;')

733

hf_body.append(' }')

734

hf_body.append(' mInfo.pLastMapped = entry;')

735

hf_body.append('}')

736

hf_body.append('')

737

hf_body.append('static void rm_handle_from_mem_info(const XGL_GPU_MEMORY handle)')

738

hf_body.append('{')

739

hf_body.append(' XGLAllocInfo *entry = find_mem_info_entry(handle);')

740

hf_body.append('')

741

hf_body.append(' if (entry)')

742

hf_body.append(' {')

743

hf_body.append(' entry->valid = FALSE;')

744

hf_body.append(' entry->pData = NULL;')

745

hf_body.append(' entry->size = 0;')

746

hf_body.append(' entry->handle = NULL;')

747

hf_body.append('')

748

hf_body.append(' mInfo.numEntrys--;')

749

hf_body.append(' if (entry == mInfo.pLastMapped)')

750

hf_body.append(' mInfo.pLastMapped = NULL;')

751

hf_body.append(' if (mInfo.numEntrys == 0)')

752

hf_body.append(' delete_mem_info();')

hf_body.append(' }')

hf_body.append('}')

hf_body.append('')

hf_body.append('static size_t calculate_pipeline_shader_size(const XGL_PIPELINE_SHADER* shader)')

757

hf_body.append('{')

758

hf_body.append(' size_t size = 0;')

759

hf_body.append(' XGL_UINT i, j;')

760

hf_body.append(' ')

761

hf_body.append(' size += sizeof(XGL_PIPELINE_SHADER);')

762

hf_body.append(' // descriptor sets')

763

hf_body.append(' for (i = 0; i < XGL_MAX_DESCRIPTOR_SETS; i++)')

764

hf_body.append(' {')

765

hf_body.append(' for (j = 0; j < shader->descriptorSetMapping[i].descriptorCount; j++)')

766

hf_body.append(' {')

767

hf_body.append(' size += sizeof(XGL_DESCRIPTOR_SLOT_INFO);')

768

hf_body.append(' if (shader->descriptorSetMapping[i].pDescriptorInfo[j].slotObjectType == XGL_SLOT_NEXT_DESCRIPTOR_SET)')

769

hf_body.append(' {')

770

hf_body.append(' size += sizeof(XGL_DESCRIPTOR_SET_MAPPING);')

hf_body.append(' }')

hf_body.append(' }')

hf_body.append(' }')

hf_body.append('')

hf_body.append(' // constant buffers')

776

hf_body.append(' if (shader->linkConstBufferCount > 0 && shader->pLinkConstBufferInfo != NULL)')

777

hf_body.append(' {')

778

hf_body.append(' XGL_UINT i;')

779

hf_body.append(' for (i = 0; i < shader->linkConstBufferCount; i++)')

780

hf_body.append(' {')

781

hf_body.append(' size += sizeof(XGL_LINK_CONST_BUFFER);')

782

hf_body.append(' size += shader->pLinkConstBufferInfo[i].bufferSize;')

783

hf_body.append(' }')

784

hf_body.append(' }')

785

hf_body.append(' return size;')

786

hf_body.append('}')

787

hf_body.append('')

788

hf_body.append('static void add_pipeline_shader_to_trace_packet(glv_trace_packet_header* pHeader, XGL_PIPELINE_SHADER* packetShader, const XGL_PIPELINE_SHADER* paramShader)')

789

hf_body.append('{')

790

hf_body.append(' XGL_UINT i, j;')

791

hf_body.append(' // descriptor sets')

792

hf_body.append(' for (i = 0; i < XGL_MAX_DESCRIPTOR_SETS; i++)')

793

hf_body.append(' {')

794

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(packetShader->descriptorSetMapping[i].pDescriptorInfo), sizeof(XGL_DESCRIPTOR_SLOT_INFO)* paramShader->descriptorSetMapping[i].descriptorCount, paramShader->descriptorSetMapping[i].pDescriptorInfo);')

795

hf_body.append(' for (j = 0; j < paramShader->descriptorSetMapping[i].descriptorCount; j++)')

796

hf_body.append(' {')

797

hf_body.append(' if (paramShader->descriptorSetMapping[i].pDescriptorInfo[j].slotObjectType == XGL_SLOT_NEXT_DESCRIPTOR_SET)')

798

hf_body.append(' {')

799

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(packetShader->descriptorSetMapping[i].pDescriptorInfo[j].pNextLevelSet), sizeof(XGL_DESCRIPTOR_SET_MAPPING), paramShader->descriptorSetMapping[i].pDescriptorInfo[j].pNextLevelSet);')

800

hf_body.append(' }')

801

hf_body.append(' }')

802

hf_body.append(' packetShader->descriptorSetMapping[i].descriptorCount = paramShader->descriptorSetMapping[i].descriptorCount;')

803

hf_body.append(' }')

804

hf_body.append('')

805

hf_body.append(' // constant buffers')

806

hf_body.append(' if (paramShader->linkConstBufferCount > 0 && paramShader->pLinkConstBufferInfo != NULL)')

807

hf_body.append(' {')

808

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(packetShader->pLinkConstBufferInfo), sizeof(XGL_LINK_CONST_BUFFER) * paramShader->linkConstBufferCount, paramShader->pLinkConstBufferInfo);')

809

hf_body.append(' for (i = 0; i < paramShader->linkConstBufferCount; i++)')

810

hf_body.append(' {')

811

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(packetShader->pLinkConstBufferInfo[i].pBufferData), packetShader->pLinkConstBufferInfo[i].bufferSize, paramShader->pLinkConstBufferInfo[i].pBufferData);')

hf_body.append(' }')

hf_body.append(' }')

hf_body.append('}')

hf_body.append('')

hf_body.append('static void finalize_pipeline_shader_address(glv_trace_packet_header* pHeader, const XGL_PIPELINE_SHADER* packetShader)')

817

hf_body.append('{')

818

hf_body.append(' XGL_UINT i, j;')

819

hf_body.append(' // descriptor sets')

820

hf_body.append(' for (i = 0; i < XGL_MAX_DESCRIPTOR_SETS; i++)')

821

hf_body.append(' {')

822

hf_body.append(' for (j = 0; j < packetShader->descriptorSetMapping[i].descriptorCount; j++)')

823

hf_body.append(' {')

824

hf_body.append(' if (packetShader->descriptorSetMapping[i].pDescriptorInfo[j].slotObjectType == XGL_SLOT_NEXT_DESCRIPTOR_SET)')

825

hf_body.append(' {')

826

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(packetShader->descriptorSetMapping[i].pDescriptorInfo[j].pNextLevelSet));')

827

hf_body.append(' }')

828

hf_body.append(' }')

829

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(packetShader->descriptorSetMapping[i].pDescriptorInfo));')

830

hf_body.append(' }')

831

hf_body.append('')

832

hf_body.append(' // constant buffers')

833

hf_body.append(' if (packetShader->linkConstBufferCount > 0 && packetShader->pLinkConstBufferInfo != NULL)')

834

hf_body.append(' {')

835

hf_body.append(' for (i = 0; i < packetShader->linkConstBufferCount; i++)')

836

hf_body.append(' {')

837

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(packetShader->pLinkConstBufferInfo[i].pBufferData));')

838

hf_body.append(' }')

839

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(packetShader->pLinkConstBufferInfo));')

hf_body.append(' }')

hf_body.append('}')

hf_body.append('')

hf_body.append('static size_t calculate_pipeline_state_size(const XGL_VOID* pState)')

844

hf_body.append('{')

845

hf_body.append(' const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pNext = pState;')

846

hf_body.append(' size_t totalStateSize = 0;')

847

hf_body.append(' while (pNext)')

848

hf_body.append(' {')

849

hf_body.append(' switch (pNext->sType)')

850

hf_body.append(' {')

851

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:')

852

hf_body.append(' totalStateSize += sizeof(XGL_PIPELINE_IA_STATE_CREATE_INFO);')

853

hf_body.append(' break;')

854

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:')

855

hf_body.append(' totalStateSize += sizeof(XGL_PIPELINE_TESS_STATE_CREATE_INFO);')

856

hf_body.append(' break;')

857

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:')

858

hf_body.append(' totalStateSize += sizeof(XGL_PIPELINE_RS_STATE_CREATE_INFO);')

859

hf_body.append(' break;')

860

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO:')

861

hf_body.append(' totalStateSize += sizeof(XGL_PIPELINE_DB_STATE_CREATE_INFO);')

862

hf_body.append(' break;')

863

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:')

864

hf_body.append(' totalStateSize += sizeof(XGL_PIPELINE_CB_STATE);')

865

hf_body.append(' break;')

866

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:')

867

hf_body.append(' {')

868

hf_body.append(' const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pShaderStage = (const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext;')

869

hf_body.append(' totalStateSize += (sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO) + calculate_pipeline_shader_size(&pShaderStage->shader));')

870

hf_body.append(' break;')

871

hf_body.append(' }')

872

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:')

873

hf_body.append(' {')

874

hf_body.append(' const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pVi = (const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO*)pNext;')

875

hf_body.append(' totalStateSize += sizeof(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO) + pVi->bindingCount * sizeof(XGL_VERTEX_INPUT_BINDING_DESCRIPTION)')

876

hf_body.append(' + pVi->attributeCount * sizeof(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION);')

877

hf_body.append(' break;')

878

hf_body.append(' }')

879

hf_body.append(' default:')

880

hf_body.append(' assert(0);')

881

hf_body.append(' }')

882

hf_body.append(' pNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO*)pNext->pNext;')

883

hf_body.append(' }')

884

hf_body.append(' return totalStateSize;')

885

hf_body.append('}')

886

hf_body.append('')

887

hf_body.append('static void add_pipeline_state_to_trace_packet(glv_trace_packet_header* pHeader, XGL_VOID** ppOut, const XGL_VOID* pIn)')

888

hf_body.append('{')

889

hf_body.append(' const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInNow = pIn;')

890

hf_body.append(' XGL_GRAPHICS_PIPELINE_CREATE_INFO** ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)ppOut;')

891

hf_body.append(' while (pInNow != NULL)')

892

hf_body.append(' {')

893

hf_body.append(' XGL_GRAPHICS_PIPELINE_CREATE_INFO** ppOutNow = ppOutNext;')

894

hf_body.append(' ppOutNext = NULL;')

895

hf_body.append('')

896

hf_body.append(' switch (pInNow->sType)')

897

hf_body.append(' {')

898

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:')

899

hf_body.append(' {')

900

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_IA_STATE_CREATE_INFO), pInNow);')

901

hf_body.append(' ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;')

902

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')

903

hf_body.append(' break;')

904

hf_body.append(' }')

905

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:')

906

hf_body.append(' {')

907

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_TESS_STATE_CREATE_INFO), pInNow);')

908

hf_body.append(' ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;')

909

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')

910

hf_body.append(' break;')

911

hf_body.append(' }')

912

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:')

913

hf_body.append(' {')

914

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_RS_STATE_CREATE_INFO), pInNow);')

915

hf_body.append(' ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;')

916

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')

917

hf_body.append(' break;')

918

hf_body.append(' }')

919

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO:')

920

hf_body.append(' {')

921

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_DB_STATE_CREATE_INFO), pInNow);')

922

hf_body.append(' ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;')

923

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')

924

hf_body.append(' break;')

925

hf_body.append(' }')

926

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:')

927

hf_body.append(' {')

928

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_CB_STATE), pInNow);')

929

hf_body.append(' ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;')

930

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')

931

hf_body.append(' break;')

932

hf_body.append(' }')

933

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:')

934

hf_body.append(' {')

935

hf_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pPacket = NULL;')

936

hf_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInPacket = NULL;')

937

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO), pInNow);')

938

hf_body.append(' pPacket = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*) *ppOutNow;')

939

hf_body.append(' pInPacket = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*) pInNow;')

940

hf_body.append(' add_pipeline_shader_to_trace_packet(pHeader, &pPacket->shader, &pInPacket->shader);')

941

hf_body.append(' finalize_pipeline_shader_address(pHeader, &pPacket->shader);')

942

hf_body.append(' ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;')

943

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')

944

hf_body.append(' break;')

945

hf_body.append(' }')

946

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:')

947

hf_body.append(' {')

948

hf_body.append(' XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *pPacket = NULL;')

949

hf_body.append(' XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *pIn = NULL;')

950

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO), pInNow);')

951

hf_body.append(' pPacket = (XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO*) *ppOutNow;')

952

hf_body.append(' pIn = (XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO*) pInNow;')

953

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pVertexBindingDescriptions, pIn->bindingCount * sizeof(XGL_VERTEX_INPUT_BINDING_DESCRIPTION), pIn->pVertexBindingDescriptions);')

954

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pVertexBindingDescriptions));')

955

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pVertexAttributeDescriptions, pIn->attributeCount * sizeof(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION), pIn->pVertexAttributeDescriptions);')

956

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pVertexAttributeDescriptions));')

957

hf_body.append(' ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;')

958

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')

959

hf_body.append(' break;')

960

hf_body.append(' }')

961

hf_body.append(' default:')

962

hf_body.append(' assert(!"Encountered an unexpected type in pipeline state list");')

963

hf_body.append(' }')

964

hf_body.append(' pInNow = (XGL_GRAPHICS_PIPELINE_CREATE_INFO*)pInNow->pNext;')

965

hf_body.append(' }')

966

hf_body.append(' return;')

967

hf_body.append('}')

968

return "\n".join(hf_body)

969

970

def _generate_packet_id_enum(self):

971

pid_enum = []

972

pid_enum.append('enum GLV_TRACE_PACKET_ID_XGL')

973

pid_enum.append('{')

974

first_func = True

975

for proto in self.protos:

976

if first_func:

977

first_func = False

978

pid_enum.append(' GLV_TPI_XGL_xgl%s = GLV_TPI_BEGIN_API_HERE,' % proto.name)

979

else:

980

pid_enum.append(' GLV_TPI_XGL_xgl%s,' % proto.name)

981

pid_enum.append('};\n')

982

return "\n".join(pid_enum)

983

984

def _generate_stringify_func(self):

985

func_body = []

986

func_body.append('static const char *stringify_xgl_packet_id(const enum GLV_TRACE_PACKET_ID_XGL id, const glv_trace_packet_header* pHeader)')

987

func_body.append('{')

988

func_body.append(' static char str[1024];')

989

func_body.append(' switch(id) {')

990

for proto in self.protos:

991

func_body.append(' case GLV_TPI_XGL_xgl%s:' % proto.name)

992

func_body.append(' {')

993

func_str = 'xgl%s(' % proto.name

994

print_vals = ''

995

create_func = False

996

if 'Create' in proto.name or 'Alloc' in proto.name or 'MapMemory' in proto.name:

997

create_func = True

998

for p in proto.params:

999

last_param = False

1000

if (p.name == proto.params[-1].name):

1001

last_param = True

1002

if last_param and create_func: # last param of create func

1003

(pft, pfi) = self._get_printf_params(p.ty,'pPacket->%s' % p.name, True)

1004

else:

1005

(pft, pfi) = self._get_printf_params(p.ty, 'pPacket->%s' % p.name, False)

1006

if last_param == True:

1007

func_str += '%s = %s)' % (p.name, pft)

1008

print_vals += ', %s' % (pfi)

1009

else:

1010

func_str += '%s = %s, ' % (p.name, pft)

1011

print_vals += ', %s' % (pfi)

1012

func_body.append(' struct_xgl%s* pPacket = (struct_xgl%s*)(pHeader->pBody);' % (proto.name, proto.name))

1013

func_body.append(' snprintf(str, 1024, "%s"%s);' % (func_str, print_vals))

1014

func_body.append(' return str;')

1015

func_body.append(' }')

1016

func_body.append(' default:')

1017

func_body.append(' return NULL;')

1018

func_body.append(' }')

1019

func_body.append('};\n')

1020

return "\n".join(func_body)

1021

1022

def _generate_interp_func(self):

1023

interp_func_body = []

1024

interp_func_body.append('static glv_trace_packet_header* interpret_trace_packet_xgl(glv_trace_packet_header* pHeader)')

1025

interp_func_body.append('{')

1026

interp_func_body.append(' if (pHeader == NULL)')

1027

interp_func_body.append(' {')

1028

interp_func_body.append(' return NULL;')

1029

interp_func_body.append(' }')

1030

interp_func_body.append(' switch (pHeader->packet_id)')

1031

interp_func_body.append(' {')

1032

for proto in self.protos:

1033

interp_func_body.append(' case GLV_TPI_XGL_xgl%s:\n {' % proto.name)

1034

header_prefix = 'h'

1035

if 'Wsi' in proto.name or 'Dbg' in proto.name:

1036

header_prefix = 'pH'

1037

interp_func_body.append(' return interpret_body_as_xgl%s(pHeader)->%seader;\n }' % (proto.name, header_prefix))

1038

interp_func_body.append(' default:')

1039

interp_func_body.append(' return NULL;')

1040

interp_func_body.append(' }')

1041

interp_func_body.append(' return NULL;')

1042

interp_func_body.append('}')

1043

return "\n".join(interp_func_body)

1044

1045

def _generate_struct_util_funcs(self):

1046

pid_enum = []

1047

pid_enum.append('//=============================================================================')

1048

pid_enum.append('static uint64_t calc_size_XGL_APPLICATION_INFO(const XGL_APPLICATION_INFO* pStruct)')

1049

pid_enum.append('{')

1050

pid_enum.append(' return ((pStruct == NULL) ? 0 : sizeof(XGL_APPLICATION_INFO)) + strlen((const char *)pStruct->pAppName) + 1 + strlen((const char *)pStruct->pEngineName) + 1;')

1051

pid_enum.append('}\n')

1052

pid_enum.append('static void add_XGL_APPLICATION_INFO_to_packet(glv_trace_packet_header* pHeader, XGL_APPLICATION_INFO** ppStruct, const XGL_APPLICATION_INFO *pInStruct)')

1053

pid_enum.append('{')

1054

pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(XGL_APPLICATION_INFO), pInStruct);')

1055

pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->pAppName), strlen((const char *)pInStruct->pAppName) + 1, (const char *)pInStruct->pAppName);')

1056

pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->pEngineName), strlen((const char *)pInStruct->pEngineName) + 1, (const char *)pInStruct->pEngineName);')

1057

pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pAppName));')

1058

pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pEngineName));')

1059

pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&*ppStruct);')

1060

pid_enum.append('};\n')

1061

pid_enum.append('//=============================================================================\n')

1062

pid_enum.append('static uint64_t calc_size_XGL_DEVICE_CREATE_INFO(const XGL_DEVICE_CREATE_INFO* pStruct)')

1063

pid_enum.append('{')

1064

pid_enum.append(' uint64_t total_size_ppEnabledExtensionNames = pStruct->extensionCount * sizeof(XGL_CHAR *);')

1065

pid_enum.append(' uint32_t i;')

1066

pid_enum.append(' for (i = 0; i < pStruct->extensionCount; i++)')

1067

pid_enum.append(' {')

1068

pid_enum.append(' total_size_ppEnabledExtensionNames += strlen((const char *)pStruct->ppEnabledExtensionNames[i]) + 1;')

1069

pid_enum.append(' }')

1070

pid_enum.append(' return sizeof(XGL_DEVICE_CREATE_INFO) + (pStruct->queueRecordCount*sizeof(XGL_DEVICE_CREATE_INFO)) + total_size_ppEnabledExtensionNames;')

1071

pid_enum.append('}\n')

1072

pid_enum.append('static void add_XGL_DEVICE_CREATE_INFO_to_packet(glv_trace_packet_header* pHeader, XGL_DEVICE_CREATE_INFO** ppStruct, const XGL_DEVICE_CREATE_INFO *pInStruct)')

1073

pid_enum.append('{')

1074

pid_enum.append(' uint32_t i;')

1075

pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(XGL_DEVICE_CREATE_INFO), pInStruct);')

1076

pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(*ppStruct)->pRequestedQueues, pInStruct->queueRecordCount*sizeof(XGL_DEVICE_CREATE_INFO), pInStruct->pRequestedQueues);')

1077

pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&(*ppStruct)->pRequestedQueues);')

1078

pid_enum.append(' if (pInStruct->extensionCount > 0) ')

1079

pid_enum.append(' {')

1080

pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&(*ppStruct)->ppEnabledExtensionNames), pInStruct->extensionCount * sizeof(XGL_CHAR *), pInStruct->ppEnabledExtensionNames);')

1081

pid_enum.append(' for (i = 0; i < pInStruct->extensionCount; i++)')

1082

pid_enum.append(' {')

1083

pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&((*ppStruct)->ppEnabledExtensionNames[i])), strlen((const char *)pInStruct->ppEnabledExtensionNames[i]) + 1, (const char *)pInStruct->ppEnabledExtensionNames[i]);')

1084

pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)(&((*ppStruct)->ppEnabledExtensionNames[i])));')

1085

pid_enum.append(' }')

1086

pid_enum.append(' glv_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledExtensionNames);')

1087

pid_enum.append(' }')

1088

pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)ppStruct);')

1089

pid_enum.append('}\n')

1090

pid_enum.append('static XGL_DEVICE_CREATE_INFO* interpret_XGL_DEVICE_CREATE_INFO(glv_trace_packet_header* pHeader, intptr_t ptr_variable)')

1091

pid_enum.append('{')

1092

pid_enum.append(' XGL_DEVICE_CREATE_INFO* pXGL_DEVICE_CREATE_INFO = (XGL_DEVICE_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)ptr_variable);\n')

1093

pid_enum.append(' if (pXGL_DEVICE_CREATE_INFO != NULL)')

1094

pid_enum.append(' {')

1095

pid_enum.append(' pXGL_DEVICE_CREATE_INFO->pRequestedQueues = (const XGL_DEVICE_QUEUE_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pXGL_DEVICE_CREATE_INFO->pRequestedQueues);\n')

1096

pid_enum.append(' if (pXGL_DEVICE_CREATE_INFO->extensionCount > 0)')

1097

pid_enum.append(' {')

1098

pid_enum.append(' const XGL_CHAR** pNames;')

1099

pid_enum.append(' uint32_t i;')

1100

pid_enum.append(' pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames = (const XGL_CHAR *const*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames);')

1101

pid_enum.append(' pNames = (const XGL_CHAR**)pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames;')

1102

pid_enum.append(' for (i = 0; i < pXGL_DEVICE_CREATE_INFO->extensionCount; i++)')

1103

pid_enum.append(' {')

1104

pid_enum.append(' pNames[i] = (const XGL_CHAR*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames[i]));')

1105

pid_enum.append(' }')

1106

pid_enum.append(' }')

1107

pid_enum.append(' }\n')

1108

pid_enum.append(' return pXGL_DEVICE_CREATE_INFO;')

1109

pid_enum.append('}\n')

1110

pid_enum.append('static void interpret_pipeline_shader(glv_trace_packet_header* pHeader, XGL_PIPELINE_SHADER* pShader)')

1111

pid_enum.append('{')

1112

pid_enum.append(' XGL_UINT i, j;')

1113

pid_enum.append(' if (pShader != NULL)')

1114

pid_enum.append(' {')

1115

pid_enum.append(' // descriptor sets')

1116

pid_enum.append(' // TODO: need to ensure XGL_MAX_DESCRIPTOR_SETS is equal in replay as it was at trace time - meta data')

1117

pid_enum.append(' for (i = 0; i < XGL_MAX_DESCRIPTOR_SETS; i++)')

1118

pid_enum.append(' {')

1119

pid_enum.append(' pShader->descriptorSetMapping[i].pDescriptorInfo = (const XGL_DESCRIPTOR_SLOT_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->descriptorSetMapping[i].pDescriptorInfo);')

1120

pid_enum.append(' for (j = 0; j < pShader->descriptorSetMapping[i].descriptorCount; j++)')

1121

pid_enum.append(' {')

1122

pid_enum.append(' if (pShader->descriptorSetMapping[i].pDescriptorInfo[j].slotObjectType == XGL_SLOT_NEXT_DESCRIPTOR_SET)')

1123

pid_enum.append(' {')

1124

pid_enum.append(' XGL_DESCRIPTOR_SLOT_INFO* pInfo = (XGL_DESCRIPTOR_SLOT_INFO*)pShader->descriptorSetMapping[i].pDescriptorInfo;')

1125

pid_enum.append(' pInfo[j].pNextLevelSet = (const XGL_DESCRIPTOR_SET_MAPPING*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->descriptorSetMapping[i].pDescriptorInfo[j].pNextLevelSet);')

1126

pid_enum.append(' }')

1127

pid_enum.append(' }')

1128

pid_enum.append(' }\n')

1129

pid_enum.append(' // constant buffers')

1130

pid_enum.append(' if (pShader->linkConstBufferCount > 0)')

1131

pid_enum.append(' {')

1132

pid_enum.append(' XGL_UINT i;')

1133

pid_enum.append(' pShader->pLinkConstBufferInfo = (const XGL_LINK_CONST_BUFFER*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->pLinkConstBufferInfo);')

1134

pid_enum.append(' for (i = 0; i < pShader->linkConstBufferCount; i++)')

1135

pid_enum.append(' {')

1136

pid_enum.append(' XGL_LINK_CONST_BUFFER* pBuffer = (XGL_LINK_CONST_BUFFER*)pShader->pLinkConstBufferInfo;')

1137

pid_enum.append(' pBuffer[i].pBufferData = (const XGL_VOID*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->pLinkConstBufferInfo[i].pBufferData);')

1138

pid_enum.append(' }')

1139

pid_enum.append(' }')

1140

pid_enum.append(' }')

1141

pid_enum.append('}\n')

1142

pid_enum.append('//=============================================================================')

1143

return "\n".join(pid_enum)

1144

1145

def _generate_interp_funcs(self):

1146

# Custom txt for given function and parameter. First check if param is NULL, then insert txt if not

1147

custom_case_dict = { 'InitAndEnumerateGpus' : {'param': 'pAppInfo', 'txt': ['XGL_APPLICATION_INFO* pInfo = (XGL_APPLICATION_INFO*)pPacket->pAppInfo;\n', 'pInfo->pAppName = (const XGL_CHAR*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAppInfo->pAppName);\n', 'pInfo->pEngineName = (const XGL_CHAR*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAppInfo->pEngineName);']},

1148

'CreateShader' : {'param': 'pCreateInfo', 'txt': ['XGL_SHADER_CREATE_INFO* pInfo = (XGL_SHADER_CREATE_INFO*)pPacket->pCreateInfo;\n', 'pInfo->pCode = glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pCode);']},

1149

'CreateGraphicsPipeline' : {'param': 'pCreateInfo', 'txt': ['assert(pPacket->pCreateInfo->sType == XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO);\n', '// need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one\n','XGL_VOID** ppNextVoidPtr = (XGL_VOID**)&pPacket->pCreateInfo->pNext;\n','*ppNextVoidPtr = (XGL_VOID*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pNext);\n',

1150

'XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacket->pCreateInfo->pNext;\n', 'while ((NULL != pNext) && (XGL_NULL_HANDLE != pNext))\n', '{\n',

1151

' switch(pNext->sType)\n', ' {\n',

1152

' case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:\n',

1153

' case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:\n',

1154

' case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:\n',

1155

' case XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO:\n',

1156

' case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:\n',

1157

' {\n',

1158

' XGL_VOID** ppNextVoidPtr = (XGL_VOID**)&pNext->pNext;\n',

1159

' *ppNextVoidPtr = (XGL_VOID*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',

1160

' break;\n',

1161

' }\n',

1162

' case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:\n',

1163

' {\n',

1164

' XGL_VOID** ppNextVoidPtr = (XGL_VOID**)&pNext->pNext;\n',

1165

' *ppNextVoidPtr = (XGL_VOID*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',

1166

' interpret_pipeline_shader(pHeader, &pNext->shader);\n',

1167

' break;\n',

1168

' }\n',

1169

' case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:\n',

1170

' {\n',

1171

' XGL_VOID** ppNextVoidPtr = (XGL_VOID**)&pNext->pNext;\n',

1172

' XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *pVi = (XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *) pNext;\n',

1173

' *ppNextVoidPtr = (XGL_VOID*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',

1174

' pVi->pVertexBindingDescriptions = (XGL_VERTEX_INPUT_BINDING_DESCRIPTION*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVi->pVertexBindingDescriptions);\n',

1175

' pVi->pVertexAttributeDescriptions = (XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVi->pVertexAttributeDescriptions);\n',

' break;\n',

' }\n',

' default:\n',

' assert(!"Encountered an unexpected type in pipeline state list");\n',

1180

' }\n',

1181

' pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext->pNext;\n',

1182

'}']},

1183

'CreateComputePipeline' : {'param': 'pCreateInfo', 'txt': ['interpret_pipeline_shader(pHeader, (XGL_PIPELINE_SHADER*)(&pPacket->pCreateInfo->cs));']}}

1184

if_body = []

1185

for proto in self.protos:

1186

if 'Wsi' not in proto.name and 'Dbg' not in proto.name:

1187

if 'UnmapMemory' == proto.name:

1188

proto.params = proto.params + (xgl.Param("XGL_VOID*", "pData"),)

1189

if_body.append('typedef struct struct_xgl%s {' % proto.name)

1190

if_body.append(' glv_trace_packet_header* header;')

1191

for p in proto.params:

1192

if '[4]' in p.ty:

1193

if_body.append(' %s %s[4];' % (p.ty.strip('[4]'), p.name))

1194

else:

1195

if_body.append(' %s %s;' % (p.ty, p.name))

1196

if 'XGL_VOID' != proto.ret:

1197

if_body.append(' %s result;' % proto.ret)

1198

if_body.append('} struct_xgl%s;\n' % proto.name)

1199

if_body.append('static struct_xgl%s* interpret_body_as_xgl%s(glv_trace_packet_header* pHeader)' % (proto.name, proto.name))

1200

if_body.append('{')

1201

if_body.append(' struct_xgl%s* pPacket = (struct_xgl%s*)pHeader->pBody;' % (proto.name, proto.name))

1202

if_body.append(' pPacket->header = pHeader;')

1203

for p in proto.params:

1204

if '*' in p.ty:

1205

if 'DEVICE_CREATE_INFO' in p.ty:

1206

if_body.append(' pPacket->%s = interpret_XGL_DEVICE_CREATE_INFO(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.name))

1207

else:

1208

if_body.append(' pPacket->%s = (%s)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.ty, p.name))

1209

if proto.name in custom_case_dict and p.name == custom_case_dict[proto.name]['param']:

1210

if_body.append(' if (pPacket->%s != NULL)' % custom_case_dict[proto.name]['param'])

1211

if_body.append(' {')

1212

if_body.append(' %s' % " ".join(custom_case_dict[proto.name]['txt']))

1213

if_body.append(' }')

1214

if_body.append(' return pPacket;')

1215

if_body.append('}\n')

1216

return "\n".join(if_body)

1217

1218

def _generate_interp_funcs_ext(self, func_class='Wsi'):

1219

if_body = []

1220

for proto in self.protos:

1221

if func_class in proto.name:

1222

if_body.append('typedef struct struct_xgl%s {' % proto.name)

1223

if_body.append(' glv_trace_packet_header* pHeader;')

1224

for p in proto.params:

1225

if_body.append(' %s %s;' % (p.ty, p.name))

1226

if 'XGL_VOID' != proto.ret:

1227

if_body.append(' %s result;' % proto.ret)

1228

if_body.append('} struct_xgl%s;\n' % proto.name)

1229

if_body.append('static struct_xgl%s* interpret_body_as_xgl%s(glv_trace_packet_header* pHeader)' % (proto.name, proto.name))

1230

if_body.append('{')

1231

if_body.append(' struct_xgl%s* pPacket = (struct_xgl%s*)pHeader->pBody;' % (proto.name, proto.name))

1232

if_body.append(' pPacket->pHeader = pHeader;')

1233

for p in proto.params:

1234

if '*' in p.ty:

1235

if_body.append(' pPacket->%s = (%s)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.ty, p.name))

1236

if_body.append(' return pPacket;')

1237

if_body.append('}\n')

1238

return "\n".join(if_body)

1239

1240

def _generate_replay_class_decls(self):

1241

cd_body = []

1242

cd_body.append('class ApiReplay {')

1243

cd_body.append('public:')

1244

cd_body.append(' virtual ~ApiReplay() { }')

1245

cd_body.append(' virtual enum glv_replay::GLV_REPLAY_RESULT replay(glv_trace_packet_header * packet) = 0;')

1246

cd_body.append(' virtual int init(glv_replay::Display & disp) = 0;')

1247

cd_body.append('};\n')

1248

cd_body.append('class xglDisplay: public glv_replay::DisplayImp {')

1249

cd_body.append('friend class xglReplay;')

1250

cd_body.append('public:')

1251

cd_body.append(' xglDisplay();')

1252

cd_body.append(' ~xglDisplay();')

1253

cd_body.append(' int init(const unsigned int gpu_idx);')

1254

cd_body.append(' int set_window(glv_window_handle hWindow, unsigned int width, unsigned int height);')

1255

cd_body.append(' int create_window(const unsigned int width, const unsigned int height);')

1256

cd_body.append(' void resize_window(const unsigned int width, const unsigned int height);')

1257

cd_body.append(' void process_event();')

1258

cd_body.append(' // XGL_DEVICE get_device() { return m_dev[m_gpuIdx];}')

1259

cd_body.append('#if defined(WIN32)')

1260

cd_body.append(' HWND get_window_handle() { return m_windowHandle; }')

1261

cd_body.append('#elif defined(PLATFORM_LINUX)')

1262

cd_body.append(' xcb_window_t get_window_handle() { return m_XcbWindow; }')

1263

cd_body.append('#endif')

1264

cd_body.append('private:')

1265

cd_body.append(' XGL_RESULT init_xgl(const unsigned int gpu_idx);')

1266

cd_body.append(' bool m_initedXGL;')

1267

cd_body.append('#if defined(WIN32)')

1268

cd_body.append(' HWND m_windowHandle;')

1269

cd_body.append('#elif defined(PLATFORM_LINUX)')

1270

cd_body.append(' XGL_WSI_X11_CONNECTION_INFO m_WsiConnection;')

1271

cd_body.append(' xcb_screen_t *m_pXcbScreen;')

1272

cd_body.append(' xcb_window_t m_XcbWindow;')

1273

cd_body.append('#endif')

1274

cd_body.append(' unsigned int m_windowWidth;')

1275

cd_body.append(' unsigned int m_windowHeight;')

1276

cd_body.append('#if 0')

1277

cd_body.append(' XGL_DEVICE m_dev[XGL_MAX_PHYSICAL_GPUS];')

1278

cd_body.append(' XGL_UINT32 m_gpuCount;')

1279

cd_body.append(' unsigned int m_gpuIdx;')

1280

cd_body.append(' XGL_PHYSICAL_GPU m_gpus[XGL_MAX_PHYSICAL_GPUS];')

1281

cd_body.append(' XGL_PHYSICAL_GPU_PROPERTIES m_gpuProps[XGL_MAX_PHYSICAL_GPUS];')

1282

cd_body.append('#endif')

1283

cd_body.append(' std::vector<XGL_CHAR *>m_extensions;')

1284

cd_body.append('};\n')

1285

cd_body.append('typedef struct _XGLAllocInfo {')

1286

cd_body.append(' XGL_GPU_SIZE size;')

1287

cd_body.append(' XGL_VOID *pData;')

1288

cd_body.append('} XGLAllocInfo;')

1289

return "\n".join(cd_body)

1290

1291

def _generate_replay_func_ptrs(self):

1292

xf_body = []

1293

xf_body.append('struct xglFuncs {')

1294

xf_body.append(' void init_funcs(void * libHandle);')

1295

xf_body.append(' void *m_libHandle;\n')

1296

for proto in self.protos:

1297

xf_body.append(' typedef %s( XGLAPI * type_xgl%s)(' % (proto.ret, proto.name))

1298

for p in proto.params:

1299

if '[4]' in p.ty:

1300

xf_body.append(' %s %s[4],' % (p.ty.strip('[4]'), p.name))

1301

else:

1302

xf_body.append(' %s %s,' % (p.ty, p.name))

1303

xf_body[-1] = xf_body[-1].replace(',', ');')

1304

xf_body.append(' type_xgl%s real_xgl%s;' % (proto.name, proto.name))

1305

xf_body.append('};')

1306

return "\n".join(xf_body)

1307

1308

def _map_decl(self, type1, type2, name):

1309

return ' std::map<%s, %s> %s;' % (type1, type2, name)

1310

1311

def _add_to_map_decl(self, type1, type2, name):

1312

txt = ' void add_to_map(%s* pTraceVal, %s* pReplayVal)\n {\n' % (type1, type2)

1313

txt += ' assert(pTraceVal != NULL);\n'

1314

txt += ' assert(pReplayVal != NULL);\n'

1315

txt += ' %s[*pTraceVal] = *pReplayVal;\n }' % name

1316

return txt

1317

1318

def _rm_from_map_decl(self, ty, name):

1319

txt = ' void rm_from_map(const %s& key)\n {\n' % (ty)

1320

txt += ' %s.erase(key);\n }' % name

1321

return txt

1322

1323

def _remap_decl(self, ty, name):

1324

txt = ' %s remap(const %s& value)\n {\n' % (ty, ty)

1325

txt += ' std::map<%s, %s>::const_iterator q = %s.find(value);\n' % (ty, ty, name)

1326

txt += ' return (q == %s.end()) ? XGL_NULL_HANDLE : q->second;\n }' % name

1327

return txt

1328

1329

def _generate_replay_class(self):

1330

obj_map_dict = {'m_gpus': 'XGL_PHYSICAL_GPU',

1331

'm_devices': 'XGL_DEVICE',

1332

'm_queues': 'XGL_QUEUE',

1333

'm_memories': 'XGL_GPU_MEMORY',

1334

'm_images': 'XGL_IMAGE',

1335

'm_imageViews': 'XGL_IMAGE_VIEW',

1336

'm_colorTargetViews': 'XGL_COLOR_ATTACHMENT_VIEW',

1337

'm_depthStencilViews': 'XGL_DEPTH_STENCIL_VIEW',

1338

'm_shader': 'XGL_SHADER',

1339

'm_pipeline': 'XGL_PIPELINE',

1340

'm_pipelineDelta': 'XGL_PIPELINE_DELTA',

1341

'm_sampler': 'XGL_SAMPLER',

1342

'm_descriptorSets': 'XGL_DESCRIPTOR_SET',

1343

'm_viewportStates': 'XGL_VIEWPORT_STATE_OBJECT',

1344

'm_rasterStates': 'XGL_RASTER_STATE_OBJECT',

1345

'm_msaaStates': 'XGL_MSAA_STATE_OBJECT',

1346

'm_colorBlendStates': 'XGL_COLOR_BLEND_STATE_OBJECT',

1347

'm_depthStencilStates': 'XGL_DEPTH_STENCIL_STATE_OBJECT',

1348

'm_cmdBuffers': 'XGL_CMD_BUFFER',

1349

'm_fences': 'XGL_FENCE',

1350

'm_queue_semaphores': 'XGL_QUEUE_SEMAPHORE',

1351

'm_events': 'XGL_EVENT',

1352

'm_queryPools': 'XGL_QUERY_POOL',

1353

}

1354

rc_body = []

1355

rc_body.append('class xglReplay : public ApiReplay {')

1356

rc_body.append('public:')

1357

rc_body.append(' ~xglReplay();')

1358

rc_body.append(' xglReplay(unsigned int debugLevel);\n')

1359

rc_body.append(' int init(glv_replay::Display & disp);')

1360

rc_body.append(' xglDisplay * get_display() {return m_display;}')

1361

rc_body.append(' glv_replay::GLV_REPLAY_RESULT replay(glv_trace_packet_header *packet);')

1362

rc_body.append(' glv_replay::GLV_REPLAY_RESULT handle_replay_errors(const char* entrypointName, const XGL_RESULT resCall, const XGL_RESULT resTrace, const glv_replay::GLV_REPLAY_RESULT resIn);\n')

1363

rc_body.append('private:')

1364

rc_body.append(' struct xglFuncs m_xglFuncs;')

1365

rc_body.append(' void copy_mem_remap_range_struct(XGL_VIRTUAL_MEMORY_REMAP_RANGE *outRange, const XGL_VIRTUAL_MEMORY_REMAP_RANGE *inRange);')

1366

rc_body.append(' unsigned int m_debugLevel;')

1367

rc_body.append(' xglDisplay *m_display;')

1368

rc_body.append(' XGL_MEMORY_HEAP_PROPERTIES m_heapProps[XGL_MAX_MEMORY_HEAPS];')

1369

rc_body.append(' struct shaderPair {')

1370

rc_body.append(' XGL_SHADER *addr;')

1371

rc_body.append(' XGL_SHADER val;')

1372

rc_body.append(' };')

1373

rc_body.append(self._map_decl('XGL_GPU_MEMORY', 'XGLAllocInfo', 'm_mapData'))

1374

# Custom code for 1-off memory mapping functions

1375

rc_body.append(' void add_entry_to_mapData(XGL_GPU_MEMORY handle, XGL_GPU_SIZE size)')

1376

rc_body.append(' {')

1377

rc_body.append(' XGLAllocInfo info;')

1378

rc_body.append(' info.pData = NULL;')

1379

rc_body.append(' info.size = size;')

1380

rc_body.append(' m_mapData.insert(std::pair<XGL_GPU_MEMORY, XGLAllocInfo>(handle, info));')

1381

rc_body.append(' }')

1382

rc_body.append(' void add_mapping_to_mapData(XGL_GPU_MEMORY handle, XGL_VOID *pData)')

1383

rc_body.append(' {')

1384

rc_body.append(' std::map<XGL_GPU_MEMORY,XGLAllocInfo>::iterator it = m_mapData.find(handle);')

1385

rc_body.append(' if (it == m_mapData.end())')

1386

rc_body.append(' {')

1387

rc_body.append(' glv_LogWarn("add_mapping_to_mapData() could not find entry\\n");')

1388

rc_body.append(' return;')

1389

rc_body.append(' }')

1390

rc_body.append(' XGLAllocInfo &info = it->second;')

1391

rc_body.append(' if (info.pData != NULL)')

1392

rc_body.append(' {')

1393

rc_body.append(' glv_LogWarn("add_mapping_to_mapData() data already mapped overwrite old mapping\\n");')

1394

rc_body.append(' }')

1395

rc_body.append(' info.pData = pData;')

1396

rc_body.append(' }')

1397

rc_body.append(' void rm_entry_from_mapData(XGL_GPU_MEMORY handle)')

1398

rc_body.append(' {')

1399

rc_body.append(' std::map<XGL_GPU_MEMORY,XGLAllocInfo>::iterator it = m_mapData.find(handle);')

1400

rc_body.append(' if (it == m_mapData.end())')

1401

rc_body.append(' return;')

1402

rc_body.append(' m_mapData.erase(it);')

1403

rc_body.append(' }')

1404

rc_body.append(' void rm_mapping_from_mapData(XGL_GPU_MEMORY handle, XGL_VOID* pData)')

1405

rc_body.append(' {')

1406

rc_body.append(' std::map<XGL_GPU_MEMORY,XGLAllocInfo>::iterator it = m_mapData.find(handle);')

1407

rc_body.append(' if (it == m_mapData.end())')

1408

rc_body.append(' return;\n')

1409

rc_body.append(' XGLAllocInfo &info = it->second;')

1410

rc_body.append(' if (!pData || !info.pData)')

1411

rc_body.append(' {')

1412

rc_body.append(' glv_LogWarn("rm_mapping_from_mapData() null src or dest pointers\\n");')

1413

rc_body.append(' info.pData = NULL;')

1414

rc_body.append(' return;')

1415

rc_body.append(' }')

1416

rc_body.append(' memcpy(info.pData, pData, info.size);')

1417

rc_body.append(' info.pData = NULL;')

1418

rc_body.append(' }\n')

1419

rc_body.append(' /*std::map<XGL_PHYSICAL_GPU, XGL_PHYSICAL_GPU> m_gpus;')

1420

rc_body.append(' void add_to_map(XGL_PHYSICAL_GPU* pTraceGpu, XGL_PHYSICAL_GPU* pReplayGpu)')

1421

rc_body.append(' {')

1422

rc_body.append(' assert(pTraceGpu != NULL);')

1423

rc_body.append(' assert(pReplayGpu != NULL);')

1424

rc_body.append(' m_gpus[*pTraceGpu] = *pReplayGpu;')

1425

rc_body.append(' }\n')

1426

rc_body.append(' XGL_PHYSICAL_GPU remap(const XGL_PHYSICAL_GPU& gpu)')

1427

rc_body.append(' {')

1428

rc_body.append(' std::map<XGL_PHYSICAL_GPU, XGL_PHYSICAL_GPU>::const_iterator q = m_gpus.find(gpu);')

1429

rc_body.append(' return (q == m_gpus.end()) ? XGL_NULL_HANDLE : q->second;')

1430

rc_body.append(' }*/\n')

1431

rc_body.append(' void clear_all_map_handles()\n {')

1432

for var in sorted(obj_map_dict):

1433

rc_body.append(' %s.clear();' % var)

1434

rc_body.append(' }')

1435

for var in sorted(obj_map_dict):

1436

rc_body.append(self._map_decl(obj_map_dict[var], obj_map_dict[var], var))

1437

rc_body.append(self._add_to_map_decl(obj_map_dict[var], obj_map_dict[var], var))

1438

rc_body.append(self._rm_from_map_decl(obj_map_dict[var], var))

1439

rc_body.append(self._remap_decl(obj_map_dict[var], var))

1440

# XGL_STATE_OBJECT code

1441

state_obj_remap_types = ['XGL_VIEWPORT_STATE_OBJECT', 'XGL_RASTER_STATE_OBJECT', 'XGL_MSAA_STATE_OBJECT', 'XGL_COLOR_BLEND_STATE_OBJECT', 'XGL_DEPTH_STENCIL_STATE_OBJECT']

1442

rc_body.append(' XGL_STATE_OBJECT remap(const XGL_STATE_OBJECT& state)\n {')

1443

rc_body.append(' XGL_STATE_OBJECT obj;')

1444

for t in state_obj_remap_types:

1445

rc_body.append(' if ((obj = remap(static_cast <%s> (state))) != XGL_NULL_HANDLE)' % t)

1446

rc_body.append(' return obj;')

1447

rc_body.append(' return XGL_NULL_HANDLE;\n }')

1448

rc_body.append(' void rm_from_map(const XGL_STATE_OBJECT& state)\n {')

1449

for t in state_obj_remap_types:

1450

rc_body.append(' rm_from_map(static_cast <%s> (state));' % t)

1451

rc_body.append(' }')

1452

# OBJECT code

1453

rc_body.append(' XGL_OBJECT remap(const XGL_OBJECT& object)\n {')

1454

rc_body.append(' XGL_OBJECT obj;')

1455

obj_remap_types = ['XGL_CMD_BUFFER', 'XGL_IMAGE', 'XGL_IMAGE_VIEW', 'XGL_COLOR_ATTACHMENT_VIEW', 'XGL_DEPTH_STENCIL_VIEW', 'XGL_SHADER', 'XGL_PIPELINE', 'XGL_PIPELINE_DELTA', 'XGL_SAMPLER', 'XGL_DESCRIPTOR_SET', 'XGL_STATE_OBJECT', 'XGL_FENCE', 'XGL_QUEUE_SEMAPHORE', 'XGL_EVENT', 'XGL_QUERY_POOL']

1456

for var in obj_remap_types:

1457

rc_body.append(' if ((obj = remap(static_cast <%s> (object))) != XGL_NULL_HANDLE)' % (var))

1458

rc_body.append(' return obj;')

1459

rc_body.append(' return XGL_NULL_HANDLE;\n }')

1460

rc_body.append(' void rm_from_map(const XGL_OBJECT & objKey)\n {')

1461

for var in obj_remap_types:

1462

rc_body.append(' rm_from_map(static_cast <%s> (objKey));' % (var))

1463

rc_body.append(' }')

1464

rc_body.append(' XGL_BASE_OBJECT remap(const XGL_BASE_OBJECT& object)\n {')

1465

rc_body.append(' XGL_BASE_OBJECT obj;')

1466

base_obj_remap_types = ['XGL_DEVICE', 'XGL_QUEUE', 'XGL_GPU_MEMORY', 'XGL_OBJECT']

1467

for t in base_obj_remap_types:

1468

rc_body.append(' if ((obj = remap(static_cast <%s> (object))) != XGL_NULL_HANDLE)' % t)

1469

rc_body.append(' return obj;')

1470

rc_body.append(' return XGL_NULL_HANDLE;\n }')

1471

rc_body.append('};')

1472

return "\n".join(rc_body)

1473

1474

def _generate_replay_display_init_xgl(self):

1475

dix_body = []

1476

dix_body.append('XGL_RESULT xglDisplay::init_xgl(unsigned int gpu_idx)')

1477

dix_body.append('{')

1478

dix_body.append('#if 0')

1479

dix_body.append(' XGL_APPLICATION_INFO appInfo = {};')

1480

dix_body.append(' appInfo.pAppName = APP_NAME;')

1481

dix_body.append(' appInfo.pEngineName = "";')

1482

dix_body.append(' appInfo.apiVersion = XGL_API_VERSION;')

1483

dix_body.append(' XGL_RESULT res = xglInitAndEnumerateGpus(&appInfo, NULL, XGL_MAX_PHYSICAL_GPUS, &m_gpuCount, m_gpus);')

1484

dix_body.append(' if ( res == XGL_SUCCESS ) {')

1485

dix_body.append(' // retrieve the GPU information for all GPUs')

1486

dix_body.append(' for( XGL_UINT32 gpu = 0; gpu < m_gpuCount; gpu++)')

1487

dix_body.append(' {')

1488

dix_body.append(' XGL_SIZE gpuInfoSize = sizeof(m_gpuProps[0]);\n')

1489

dix_body.append(' // get the GPU physical properties:')

1490

dix_body.append(' res = xglGetGpuInfo( m_gpus[gpu], XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, &gpuInfoSize, &m_gpuProps[gpu]);')

1491

dix_body.append(' if (res != XGL_SUCCESS)')

1492

dix_body.append(' glv_LogWarn("Failed to retrieve properties for gpu[%d] result %d\\n", gpu, res);')

1493

dix_body.append(' }')

1494

dix_body.append(' res = XGL_SUCCESS;')

1495

dix_body.append(' } else if ((gpu_idx + 1) > m_gpuCount) {')

1496

dix_body.append(' glv_LogError("xglInitAndEnumerate number of gpus does not include requested index: num %d, requested %d\\n", m_gpuCount, gpu_idx);')

1497

dix_body.append(' return -1;')

1498

dix_body.append(' } else {')

1499

dix_body.append(' glv_LogError("xglInitAndEnumerate failed\\n");')

1500

dix_body.append(' return res;')

1501

dix_body.append(' }')

1502

dix_body.append(' // TODO add multi-gpu support always use gpu[gpu_idx] for now')

1503

dix_body.append(' // get all extensions supported by this device gpu[gpu_idx]')

1504

dix_body.append(' // first check if extensions are available and save a list of them')

1505

dix_body.append(' bool foundWSIExt = false;')

1506

dix_body.append(' for( int ext = 0; ext < sizeof( extensions ) / sizeof( extensions[0] ); ext++)')

1507

dix_body.append(' {')

1508

dix_body.append(' res = xglGetExtensionSupport( m_gpus[gpu_idx], extensions[ext] );')

1509

dix_body.append(' if (res == XGL_SUCCESS) {')

1510

dix_body.append(' m_extensions.push_back((XGL_CHAR *) extensions[ext]);')

1511

dix_body.append(' if (!strcmp(extensions[ext], "XGL_WSI_WINDOWS"))')

1512

dix_body.append(' foundWSIExt = true;')

1513

dix_body.append(' }')

1514

dix_body.append(' }')

1515

dix_body.append(' if (!foundWSIExt) {')

1516

dix_body.append(' glv_LogError("XGL_WSI_WINDOWS extension not supported by gpu[%d]\\n", gpu_idx);')

1517

dix_body.append(' return XGL_ERROR_INCOMPATIBLE_DEVICE;')

1518

dix_body.append(' }')

1519

dix_body.append(' // TODO generalize this: use one universal queue for now')

1520

dix_body.append(' XGL_DEVICE_QUEUE_CREATE_INFO dqci = {};')

1521

dix_body.append(' dqci.queueCount = 1;')

1522

dix_body.append(' dqci.queueType = XGL_QUEUE_UNIVERSAL;')

1523

dix_body.append(' // create the device enabling validation level 4')

1524

dix_body.append(' const XGL_CHAR * const * extNames = &m_extensions[0];')

1525

dix_body.append(' XGL_DEVICE_CREATE_INFO info = {};')

1526

dix_body.append(' info.queueRecordCount = 1;')

1527

dix_body.append(' info.pRequestedQueues = &dqci;')

1528

dix_body.append(' info.extensionCount = static_cast <XGL_UINT> (m_extensions.size());')

1529

dix_body.append(' info.ppEnabledExtensionNames = extNames;')

1530

dix_body.append(' info.flags = XGL_DEVICE_CREATE_VALIDATION;')

1531

dix_body.append(' info.maxValidationLevel = XGL_VALIDATION_LEVEL_4;')

1532

dix_body.append(' XGL_BOOL xglTrue = XGL_TRUE;')

1533

dix_body.append(' res = xglDbgSetGlobalOption( XGL_DBG_OPTION_BREAK_ON_ERROR, sizeof( xglTrue ), &xglTrue );')

1534

dix_body.append(' if (res != XGL_SUCCESS)')

1535

dix_body.append(' glv_LogWarn("Could not set debug option break on error\\n");')

1536

dix_body.append(' res = xglCreateDevice( m_gpus[0], &info, &m_dev[gpu_idx]);')

1537

dix_body.append(' return res;')

1538

dix_body.append('#else')

1539

dix_body.append(' return XGL_ERROR_INITIALIZATION_FAILED;')

1540

dix_body.append('#endif')

1541

dix_body.append('}')

1542

return "\n".join(dix_body)

1543

1544

def _generate_replay_display_init(self):

1545

di_body = []

1546

di_body.append('int xglDisplay::init(const unsigned int gpu_idx)')

1547

di_body.append('{')

1548

di_body.append(' //m_gpuIdx = gpu_idx;')

1549

di_body.append('#if 0')

1550

di_body.append(' XGL_RESULT result = init_xgl(gpu_idx);')

1551

di_body.append(' if (result != XGL_SUCCESS) {')

1552

di_body.append(' glv_LogError("could not init xgl library");')

1553

di_body.append(' return -1;')

1554

di_body.append(' } else {')

1555

di_body.append(' m_initedXGL = true;')

1556

di_body.append(' }')

1557

di_body.append('#endif')

1558

di_body.append('#if defined(PLATFORM_LINUX)')

1559

di_body.append(' const xcb_setup_t *setup;')

1560

di_body.append(' xcb_screen_iterator_t iter;')

1561

di_body.append(' int scr;')

1562

di_body.append(' xcb_connection_t *pConnection;')

1563

di_body.append(' pConnection = xcb_connect(NULL, &scr);')

1564

di_body.append(' setup = xcb_get_setup(pConnection);')

1565

di_body.append(' iter = xcb_setup_roots_iterator(setup);')

1566

di_body.append(' while (scr-- > 0)')

1567

di_body.append(' xcb_screen_next(&iter);')

1568

di_body.append(' m_pXcbScreen = iter.data;')

1569

di_body.append(' m_WsiConnection.pConnection = pConnection;')

1570

di_body.append(' m_WsiConnection.root = m_pXcbScreen->root;')

1571

di_body.append('#endif')

1572

di_body.append(' return 0;')

1573

di_body.append('}')

1574

return "\n".join(di_body)

1575

1576

def _generate_replay_display_structors(self):

1577

ds_body = []

1578

ds_body.append('xglDisplay::xglDisplay()')

1579

ds_body.append(' : m_initedXGL(false),')

1580

ds_body.append(' m_windowWidth(0),')

1581

ds_body.append(' m_windowHeight(0)')

1582

ds_body.append('{')

1583

ds_body.append('#if defined(WIN32)')

1584

ds_body.append(' m_windowHandle = NULL;')

1585

ds_body.append('#elif defined(PLATFORM_LINUX)')

1586

ds_body.append(' m_WsiConnection.pConnection = NULL;')

1587

ds_body.append(' m_WsiConnection.root = 0;')

1588

ds_body.append(' m_WsiConnection.provider = 0;')

1589

ds_body.append(' m_pXcbScreen = NULL;')

1590

ds_body.append(' m_XcbWindow = 0;')

1591

ds_body.append('#endif')

1592

ds_body.append('}')

1593

ds_body.append('xglDisplay::~xglDisplay()')

1594

ds_body.append('{')

1595

ds_body.append('#ifdef PLATFORM_LINUX')

1596

ds_body.append(' if (m_XcbWindow != 0)')

1597

ds_body.append(' {')

1598

ds_body.append(' xcb_destroy_window(m_WsiConnection.pConnection, m_XcbWindow);')

1599

ds_body.append(' }')

1600

ds_body.append(' if (m_WsiConnection.pConnection != NULL)')

1601

ds_body.append(' {')

1602

ds_body.append(' xcb_disconnect(m_WsiConnection.pConnection);')

1603

ds_body.append(' }')

1604

ds_body.append('#endif')

1605

ds_body.append('}')

1606

return "\n".join(ds_body)

1607

1608

def _generate_replay_display_window(self):

1609

dw_body = []

1610

dw_body.append('#if defined(WIN32)')

1611

dw_body.append('LRESULT WINAPI WindowProcXgl( HWND window, unsigned int msg, WPARAM wp, LPARAM lp)')

1612

dw_body.append('{')

1613

dw_body.append(' switch(msg)')

1614

dw_body.append(' {')

1615

dw_body.append(' case WM_CLOSE:')

1616

dw_body.append(' DestroyWindow( window);')

1617

dw_body.append(' // fall-thru')

1618

dw_body.append(' case WM_DESTROY:')

1619

dw_body.append(' PostQuitMessage(0) ;')

1620

dw_body.append(' return 0L ;')

1621

dw_body.append(' default:')

1622

dw_body.append(' return DefWindowProc( window, msg, wp, lp ) ;')

1623

dw_body.append(' }')

1624

dw_body.append('}')

1625

dw_body.append('#endif')

1626

dw_body.append('int xglDisplay::set_window(glv_window_handle hWindow, unsigned int width, unsigned int height)')

1627

dw_body.append('{')

1628

dw_body.append('#if defined(WIN32)')

1629

dw_body.append(' m_windowHandle = hWindow;')

1630

dw_body.append('#elif defined(PLATFORM_LINUX)')

1631

dw_body.append(' m_XcbWindow = hWindow;')

1632

dw_body.append('#endif')

1633

dw_body.append(' m_windowWidth = width;')

1634

dw_body.append(' m_windowHeight = height;')

1635

dw_body.append(' return 0;')

1636

dw_body.append('}\n')

1637

dw_body.append('int xglDisplay::create_window(const unsigned int width, const unsigned int height)')

1638

dw_body.append('{')

1639

dw_body.append('#if defined(WIN32)')

1640

dw_body.append(' // Register Window class')

1641

dw_body.append(' WNDCLASSEX wcex = {};')

1642

dw_body.append(' wcex.cbSize = sizeof( WNDCLASSEX);')

1643

dw_body.append(' wcex.style = CS_HREDRAW | CS_VREDRAW;')

1644

dw_body.append(' wcex.lpfnWndProc = WindowProcXgl;')

1645

dw_body.append(' wcex.cbClsExtra = 0;')

1646

dw_body.append(' wcex.cbWndExtra = 0;')

1647

dw_body.append(' wcex.hInstance = GetModuleHandle(0);')

1648

dw_body.append(' wcex.hIcon = LoadIcon(wcex.hInstance, MAKEINTRESOURCE( IDI_ICON));')

1649

dw_body.append(' wcex.hCursor = LoadCursor( NULL, IDC_ARROW);')

1650

dw_body.append(' wcex.hbrBackground = ( HBRUSH )( COLOR_WINDOW + 1);')

1651

dw_body.append(' wcex.lpszMenuName = NULL;')

1652

dw_body.append(' wcex.lpszClassName = APP_NAME;')

1653

dw_body.append(' wcex.hIconSm = LoadIcon( wcex.hInstance, MAKEINTRESOURCE( IDI_ICON));')

1654

dw_body.append(' if( !RegisterClassEx( &wcex))')

1655

dw_body.append(' {')

1656

dw_body.append(' glv_LogError("Failed to register windows class\\n");')

1657

dw_body.append(' return -1;')

1658

dw_body.append(' }\n')

1659

dw_body.append(' // create the window')

1660

dw_body.append(' m_windowHandle = CreateWindow(APP_NAME, APP_NAME, WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU, 0, 0,')

1661

dw_body.append(' width, height, NULL, NULL, wcex.hInstance, NULL);\n')

1662

dw_body.append(' if (m_windowHandle)')

1663

dw_body.append(' {')

1664

dw_body.append(' ShowWindow( m_windowHandle, SW_SHOWDEFAULT);')

1665

dw_body.append(' m_windowWidth = width;')

1666

dw_body.append(' m_windowHeight = height;')

1667

dw_body.append(' } else {')

1668

dw_body.append(' glv_LogError("Failed to create window\\n");')

1669

dw_body.append(' return -1;')

1670

dw_body.append(' }')

1671

dw_body.append(' return 0;')

1672

dw_body.append('#elif defined(PLATFORM_LINUX)\n')

1673

dw_body.append(' uint32_t value_mask, value_list[32];')

1674

dw_body.append(' m_XcbWindow = xcb_generate_id(m_WsiConnection.pConnection);\n')

1675

dw_body.append(' value_mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;')

1676

dw_body.append(' value_list[0] = m_pXcbScreen->black_pixel;')

1677

dw_body.append(' value_list[1] = XCB_EVENT_MASK_KEY_RELEASE |')

1678

dw_body.append(' XCB_EVENT_MASK_EXPOSURE;\n')

1679

dw_body.append(' xcb_create_window(m_WsiConnection.pConnection,')

1680

dw_body.append(' XCB_COPY_FROM_PARENT,')

1681

dw_body.append(' m_XcbWindow, m_WsiConnection.root,')

1682

dw_body.append(' 0, 0, width, height, 0,')

1683

dw_body.append(' XCB_WINDOW_CLASS_INPUT_OUTPUT,')

1684

dw_body.append(' m_pXcbScreen->root_visual,')

1685

dw_body.append(' value_mask, value_list);\n')

1686

dw_body.append(' xcb_map_window(m_WsiConnection.pConnection, m_XcbWindow);')

1687

dw_body.append(' xcb_flush(m_WsiConnection.pConnection);')

1688

dw_body.append(' return 0;')

1689

dw_body.append('#endif')

1690

dw_body.append('}\n')

1691

dw_body.append('void xglDisplay::resize_window(const unsigned int width, const unsigned int height)')

1692

dw_body.append('{')

1693

dw_body.append('#if defined(WIN32)')

1694

dw_body.append(' if (width != m_windowWidth || height != m_windowHeight)')

1695

dw_body.append(' {')

1696

dw_body.append(' SetWindowPos(get_window_handle(), HWND_TOP, 0, 0, width, height, SWP_NOMOVE);')

1697

dw_body.append(' m_windowWidth = width;')

1698

dw_body.append(' m_windowHeight = height;')

1699

dw_body.append(' }')

1700

dw_body.append('#elif defined(PLATFORM_LINUX)')

1701

dw_body.append(' if (width != m_windowWidth || height != m_windowHeight)')

1702

dw_body.append(' {')

1703

dw_body.append(' uint32_t values[2];')

1704

dw_body.append(' values[0] = width;')

1705

dw_body.append(' values[1] = height;')

1706

dw_body.append(' xcb_configure_window(m_WsiConnection.pConnection, m_XcbWindow, XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT, values);')

1707

dw_body.append(' m_windowWidth = width;')

1708

dw_body.append(' m_windowHeight = height;')

1709

dw_body.append(' }')

1710

dw_body.append('#endif')

1711

dw_body.append('}\n')

1712

dw_body.append('void xglDisplay::process_event()')

1713

dw_body.append('{')

1714

dw_body.append('}')

1715

return "\n".join(dw_body)

1716

1717

def _generate_replay_structors(self):

1718

rs_body = []

1719

rs_body.append('xglReplay::xglReplay(unsigned int debugLevel)')

1720

rs_body.append('{')

1721

rs_body.append(' m_display = new xglDisplay();')

1722

rs_body.append(' m_debugLevel = debugLevel;')

1723

rs_body.append('}\n')

1724

rs_body.append('xglReplay::~xglReplay()')

1725

rs_body.append('{')

1726

rs_body.append(' delete m_display;')

1727

rs_body.append(' glv_platform_close_library(m_xglFuncs.m_libHandle);')

1728

rs_body.append('}')

1729

return "\n".join(rs_body)

1730

1731

def _generate_replay_init(self):

1732

ri_body = []

1733

ri_body.append('int xglReplay::init(glv_replay::Display & disp)')

1734

ri_body.append('{')

1735

ri_body.append(' int err;')

1736

ri_body.append('#if defined _WIN64')

1737

ri_body.append(' HMODULE handle = LoadLibrary("xgl64.dll" );')

1738

ri_body.append('#elif defined _WIN32')

1739

ri_body.append(' HMODULE handle = LoadLibrary("xgl32.dll" );')

1740

ri_body.append('#elif defined PLATFORM_LINUX')

1741

ri_body.append(' void * handle = dlopen("libXGL.so", RTLD_LAZY);')

1742

ri_body.append('#endif\n')

1743

ri_body.append(' if (handle == NULL) {')

1744

ri_body.append(' glv_LogError("Failed to open xgl library.\\n");')

1745

ri_body.append(' return -1;')

1746

ri_body.append(' }')

1747

ri_body.append(' m_xglFuncs.init_funcs(handle);')

1748

ri_body.append(' disp.set_implementation(m_display);')

1749

ri_body.append(' if ((err = m_display->init(disp.get_gpu())) != 0) {')

1750

ri_body.append(' glv_LogError("Failed to init XGL display.\\n");')

1751

ri_body.append(' return err;')

1752

ri_body.append(' }')

1753

ri_body.append(' if (disp.get_window_handle() == 0)')

1754

ri_body.append(' {')

1755

ri_body.append(' if ((err = m_display->create_window(disp.get_width(), disp.get_height())) != 0) {')

1756

ri_body.append(' glv_LogError("Failed to create Window\\n");')

1757

ri_body.append(' return err;')

1758

ri_body.append(' }')

1759

ri_body.append(' }')

1760

ri_body.append(' else')

1761

ri_body.append(' {')

1762

ri_body.append(' if ((err = m_display->set_window(disp.get_window_handle(), disp.get_width(), disp.get_height())) != 0)')

1763

ri_body.append(' {')

1764

ri_body.append(' glv_LogError("Failed to set Window\\n");')

1765

ri_body.append(' return err;')

1766

ri_body.append(' }')

1767

ri_body.append(' }')

1768

ri_body.append(' return 0;')

1769

ri_body.append('}')

1770

return "\n".join(ri_body)

1771

1772

def _generate_replay_remap(self):

1773

# values to map and bool indicates if remap required for source

1774

rr_dict = {'pageCount': False, 'realStartPage': False, 'realMem': True, 'virtualStartPage': False, 'virtualMem': True}

1775

rr_body = []

1776

rr_body.append('void xglReplay::copy_mem_remap_range_struct(XGL_VIRTUAL_MEMORY_REMAP_RANGE *outRange, const XGL_VIRTUAL_MEMORY_REMAP_RANGE *inRange)\n{')

1777

for k in rr_dict:

1778

if rr_dict[k]:

1779

rr_body.append(' outRange->%s = remap(inRange->%s);' % (k, k))

1780

else:

1781

rr_body.append(' outRange->%s = inRange->%s;' % (k, k))

1782

rr_body.append('}')

1783

return "\n".join(rr_body)

1784

1785

def _generate_replay_errors(self):

1786

re_body = []

1787

re_body.append('glv_replay::GLV_REPLAY_RESULT xglReplay::handle_replay_errors(const char* entrypointName, const XGL_RESULT resCall, const XGL_RESULT resTrace, const glv_replay::GLV_REPLAY_RESULT resIn)')

1788

re_body.append('{')

1789

re_body.append(' glv_replay::GLV_REPLAY_RESULT res = resIn;')

1790

re_body.append(' if (resCall != resTrace) {')

1791

re_body.append(' glv_LogWarn("Mismatched return from API call (%s) traced result %s, replay result %s\\n", entrypointName,')

1792

re_body.append(' string_XGL_RESULT(resTrace), string_XGL_RESULT(resCall));')

1793

re_body.append(' res = glv_replay::GLV_REPLAY_BAD_RETURN;')

1794

re_body.append(' }')

1795

re_body.append('#if 0')

1796

re_body.append(' if (resCall != XGL_SUCCESS) {')

1797

re_body.append(' glv_LogWarn("API call (%s) returned failed result %s\\n", entrypointName, string_XGL_RESULT(resCall));')

1798

re_body.append(' }')

1799

re_body.append('#endif')

1800

re_body.append(' return res;')

1801

re_body.append('}')

1802

return "\n".join(re_body)

1803

1804

def _generate_replay_init_funcs(self):

1805

rif_body = []

1806

rif_body.append('void xglFuncs::init_funcs(void * handle)\n{\n m_libHandle = handle;')

1807

for proto in self.protos:

1808

rif_body.append(' real_xgl%s = (type_xgl%s)(glv_platform_get_library_entrypoint(handle, "xgl%s"));' % (proto.name, proto.name, proto.name))

1809

rif_body.append('}')

1810

return "\n".join(rif_body)

1811

1812

def _get_packet_param(self, t, n):

1813

# list of types that require remapping

1814

remap_list = ['XGL_PHYSICAL_GPU', 'XGL_DEVICE', 'XGL_QUEUE', 'XGL_GPU_MEMORY', 'XGL_IMAGE', 'XGL_IMAGE_VIEW', 'XGL_COLOR_ATTACHMENT_VIEW',

1815

'XGL_DEPTH_STENCIL_VIEW', 'XGL_SHADER', 'XGL_PIPELINE', 'XGL_PIPELINE_DELTA', 'XGL_SAMPLER', 'XGL_DESCRIPTOR_SET',

1816

'XGL_VIEWPORT_STATE_OBJECT', 'XGL_RASTER_STATE_OBJECT', 'XGL_MSAA_STATE_OBJECT', 'XGL_COLOR_BLEND_STATE_OBJECT',

1817

'XGL_DEPTH_STENCIL_STATE_OBJECT', 'XGL_CMD_BUFFER', 'XGL_FENCE', 'XGL_QUEUE_SEMAPHORE', 'XGL_EVENT', 'XGL_QUERY_POOL',

1818

'XGL_STATE_OBJECT', 'XGL_BASE_OBJECT', 'XGL_OBJECT']

1819

param_exclude_list = ['p1', 'p2']

1820

if t.strip('*').strip('const ') in remap_list and n not in param_exclude_list:

1821

return 'remap(pPacket->%s)' % (n)

1822

return 'pPacket->%s' % (n)

1823

1824

def _gen_replay_init_and_enum_gpus(self):

1825

ieg_body = []

1826

ieg_body.append(' if (!m_display->m_initedXGL)')

1827

ieg_body.append(' {')

1828

ieg_body.append(' XGL_UINT gpuCount;')

1829

ieg_body.append(' XGL_PHYSICAL_GPU gpus[XGL_MAX_PHYSICAL_GPUS];')

1830

ieg_body.append(' XGL_UINT maxGpus = (pPacket->maxGpus < XGL_MAX_PHYSICAL_GPUS) ? pPacket->maxGpus : XGL_MAX_PHYSICAL_GPUS;')

1831

ieg_body.append(' replayResult = m_xglFuncs.real_xglInitAndEnumerateGpus(pPacket->pAppInfo, pPacket->pAllocCb, maxGpus, &gpuCount, &gpus[0]);')

1832

ieg_body.append(' CHECK_RETURN_VALUE(xglInitAndEnumerateGpus);')

1833

ieg_body.append(' //TODO handle different number of gpus in trace versus replay')

1834

ieg_body.append(' if (gpuCount != *(pPacket->pGpuCount))')

1835

ieg_body.append(' {')

1836

ieg_body.append(' glv_LogWarn("number of gpus mismatched in replay %u versus trace %u\\n", gpuCount, *(pPacket->pGpuCount));')

1837

ieg_body.append(' }')

1838

ieg_body.append(' else if (gpuCount == 0)')

1839

ieg_body.append(' {')

1840

ieg_body.append(' glv_LogError("xglInitAndEnumerateGpus number of gpus is zero\\n");')

1841

ieg_body.append(' }')

1842

ieg_body.append(' else')

1843

ieg_body.append(' {')

1844

ieg_body.append(' glv_LogInfo("Enumerated %d GPUs in the system\\n", gpuCount);')

1845

ieg_body.append(' }')

1846

ieg_body.append(' clear_all_map_handles();')

1847

ieg_body.append(' // TODO handle enumeration results in a different order from trace to replay')

1848

ieg_body.append(' for (XGL_UINT i = 0; i < gpuCount; i++)')

1849

ieg_body.append(' {')

1850

ieg_body.append(' if (pPacket->pGpus)')

1851

ieg_body.append(' add_to_map(&(pPacket->pGpus[i]), &(gpus[i]));')

1852

ieg_body.append(' }')

1853

ieg_body.append(' }')

1854

return "\n".join(ieg_body)

1855

1856

def _gen_replay_get_gpu_info(self):

1857

ggi_body = []

1858

ggi_body.append(' if (!m_display->m_initedXGL)')

1859

ggi_body.append(' {')

1860

ggi_body.append(' switch (pPacket->infoType) {')

1861

ggi_body.append(' case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:')

1862

ggi_body.append(' {')

1863

ggi_body.append(' XGL_PHYSICAL_GPU_PROPERTIES gpuProps;')

1864

ggi_body.append(' XGL_SIZE dataSize = sizeof(XGL_PHYSICAL_GPU_PROPERTIES);')

1865

ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &dataSize,')

1866

ggi_body.append(' (pPacket->pData == NULL) ? NULL : &gpuProps);')

1867

ggi_body.append(' if (pPacket->pData != NULL)')

1868

ggi_body.append(' {')

1869

ggi_body.append(' glv_LogInfo("Replay Gpu Properties\\n");')

1870

ggi_body.append(' glv_LogInfo("Vendor ID %x, Device ID %x, name %s\\n",gpuProps.vendorId, gpuProps.deviceId, gpuProps.gpuName);')

1871

ggi_body.append(' glv_LogInfo("API version %u, Driver version %u, gpu Type %u\\n",gpuProps.apiVersion, gpuProps.driverVersion, gpuProps.gpuType);')

1872

ggi_body.append(' }')

1873

ggi_body.append(' break;')

1874

ggi_body.append(' }')

1875

ggi_body.append(' case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:')

1876

ggi_body.append(' {')

1877

ggi_body.append(' XGL_PHYSICAL_GPU_PERFORMANCE gpuPerfs;')

1878

ggi_body.append(' XGL_SIZE dataSize = sizeof(XGL_PHYSICAL_GPU_PERFORMANCE);')

1879

ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &dataSize,')

1880

ggi_body.append(' (pPacket->pData == NULL) ? NULL : &gpuPerfs);')

1881

ggi_body.append(' if (pPacket->pData != NULL)')

1882

ggi_body.append(' {')

1883

ggi_body.append(' glv_LogInfo("Replay Gpu Performance\\n");')

1884

ggi_body.append(' glv_LogInfo("Max GPU clock %f, max shader ALUs/clock %f, max texel fetches/clock %f\\n",gpuPerfs.maxGpuClock, gpuPerfs.aluPerClock, gpuPerfs.texPerClock);')

1885

ggi_body.append(' glv_LogInfo("Max primitives/clock %f, Max pixels/clock %f\\n",gpuPerfs.primsPerClock, gpuPerfs.pixelsPerClock);')

1886

ggi_body.append(' }')

1887

ggi_body.append(' break;')

1888

ggi_body.append(' }')

1889

ggi_body.append(' case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:')

1890

ggi_body.append(' {')

1891

ggi_body.append(' XGL_PHYSICAL_GPU_QUEUE_PROPERTIES *pGpuQueue, *pQ;')

1892

ggi_body.append(' XGL_SIZE dataSize = sizeof(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES);')

1893

ggi_body.append(' XGL_SIZE numQueues = 1;')

1894

ggi_body.append(' assert(pPacket->pDataSize);')

1895

ggi_body.append(' if ((*(pPacket->pDataSize) % dataSize) != 0)')

1896

ggi_body.append(' glv_LogWarn("xglGetGpuInfo() for GPU_QUEUE_PROPERTIES not an integral data size assuming 1\\n");')

1897

ggi_body.append(' else')

1898

ggi_body.append(' numQueues = *(pPacket->pDataSize) / dataSize;')

1899

ggi_body.append(' dataSize = numQueues * dataSize;')

1900

ggi_body.append(' pQ = static_cast < XGL_PHYSICAL_GPU_QUEUE_PROPERTIES *> (glv_malloc(dataSize));')

1901

ggi_body.append(' pGpuQueue = pQ;')

1902

ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &dataSize,')

1903

ggi_body.append(' (pPacket->pData == NULL) ? NULL : pGpuQueue);')

1904

ggi_body.append(' if (pPacket->pData != NULL)')

1905

ggi_body.append(' {')

1906

ggi_body.append(' for (unsigned int i = 0; i < numQueues; i++)')

1907

ggi_body.append(' {')

1908

ggi_body.append(' glv_LogInfo("Replay Gpu Queue Property for index %d, flags %u\\n", i, pGpuQueue->queueFlags);')

1909

ggi_body.append(' glv_LogInfo("Max available count %u, max atomic counters %u, supports timestamps %u\\n",pGpuQueue->queueCount, pGpuQueue->maxAtomicCounters, pGpuQueue->supportsTimestamps);')

1910

ggi_body.append(' pGpuQueue++;')

1911

ggi_body.append(' }')

1912

ggi_body.append(' }')

1913

ggi_body.append(' glv_free(pQ);')

1914

ggi_body.append(' break;')

1915

ggi_body.append(' }')

1916

ggi_body.append(' default:')

1917

ggi_body.append(' {')

1918

ggi_body.append(' XGL_SIZE size = 0;')

1919

ggi_body.append(' void* pData = NULL;')

1920

ggi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')

1921

ggi_body.append(' {')

1922

ggi_body.append(' size = *pPacket->pDataSize;')

1923

ggi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')

1924

ggi_body.append(' }')

1925

ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &size, pData);')

1926

ggi_body.append(' if (replayResult == XGL_SUCCESS)')

1927

ggi_body.append(' {')

1928

ggi_body.append(' if (size != *pPacket->pDataSize && pData == NULL)')

1929

ggi_body.append(' {')

1930

ggi_body.append(' glv_LogWarn("xglGetGpuInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')

1931

ggi_body.append(' }')

1932

ggi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')

1933

ggi_body.append(' {')

1934

ggi_body.append(' glv_LogWarn("xglGetGpuInfo returned differing data contents than the trace file contained.\\n");')

1935

ggi_body.append(' }')

1936

ggi_body.append(' }')

1937

ggi_body.append(' glv_free(pData);')

1938

ggi_body.append(' break;')

1939

ggi_body.append(' }')

1940

ggi_body.append(' };')

1941

ggi_body.append(' CHECK_RETURN_VALUE(xglGetGpuInfo);')

1942

ggi_body.append(' }')

1943

return "\n".join(ggi_body)

1944

1945

def _gen_replay_create_device(self):

1946

cd_body = []

1947

cd_body.append(' if (!m_display->m_initedXGL)')

1948

cd_body.append(' {')

1949

cd_body.append(' XGL_DEVICE device;')

1950

cd_body.append(' XGL_DEVICE_CREATE_INFO cInfo;')

1951

cd_body.append(' if (m_debugLevel > 0)')

1952

cd_body.append(' {')

1953

cd_body.append(' memcpy(&cInfo, pPacket->pCreateInfo, sizeof(XGL_DEVICE_CREATE_INFO));')

1954

cd_body.append(' cInfo.flags = pPacket->pCreateInfo->flags | XGL_DEVICE_CREATE_VALIDATION_BIT;')

1955

cd_body.append(' cInfo.maxValidationLevel = (XGL_VALIDATION_LEVEL)((m_debugLevel <= 4) ? XGL_VALIDATION_LEVEL_0 + m_debugLevel : XGL_VALIDATION_LEVEL_0);')

1956

cd_body.append(' pPacket->pCreateInfo = &cInfo;')

1957

cd_body.append(' }')

1958

cd_body.append(' replayResult = m_xglFuncs.real_xglCreateDevice(remap(pPacket->gpu), pPacket->pCreateInfo, &device);')

1959

cd_body.append(' CHECK_RETURN_VALUE(xglCreateDevice);')

1960

cd_body.append(' if (replayResult == XGL_SUCCESS)')

1961

cd_body.append(' {')

1962

cd_body.append(' add_to_map(pPacket->pDevice, &device);')

1963

cd_body.append(' }')

1964

cd_body.append(' }')

1965

return "\n".join(cd_body)

1966

1967

def _gen_replay_get_extension_support(self):

1968

ges_body = []

1969

ges_body.append(' if (!m_display->m_initedXGL) {')

1970

ges_body.append(' replayResult = m_xglFuncs.real_xglGetExtensionSupport(remap(pPacket->gpu), pPacket->pExtName);')

1971

ges_body.append(' CHECK_RETURN_VALUE(xglGetExtensionSupport);')

1972

ges_body.append(' if (replayResult == XGL_SUCCESS) {')

1973

ges_body.append(' for (unsigned int ext = 0; ext < sizeof(g_extensions) / sizeof(g_extensions[0]); ext++)')

1974

ges_body.append(' {')

1975

ges_body.append(' if (!strncmp((const char *)g_extensions[ext], (const char *)pPacket->pExtName, strlen(g_extensions[ext]))) {')

1976

ges_body.append(' bool extInList = false;')

1977

ges_body.append(' for (unsigned int j = 0; j < m_display->m_extensions.size(); ++j) {')

1978

ges_body.append(' if (!strncmp((const char *)m_display->m_extensions[j], (const char *)g_extensions[ext], strlen(g_extensions[ext])))')

1979

ges_body.append(' extInList = true;')

1980

ges_body.append(' break;')

1981

ges_body.append(' }')

1982

ges_body.append(' if (!extInList)')

1983

ges_body.append(' m_display->m_extensions.push_back((XGL_CHAR *) g_extensions[ext]);')

1984

ges_body.append(' break;')

1985

ges_body.append(' }')

1986

ges_body.append(' }')

1987

ges_body.append(' }')

1988

ges_body.append(' }')

1989

return "\n".join(ges_body)

1990

1991

def _gen_replay_queue_submit(self):

1992

qs_body = []

1993

qs_body.append(' XGL_CMD_BUFFER *remappedBuffers = NULL;')

1994

qs_body.append(' if (pPacket->pCmdBuffers != NULL)')

1995

qs_body.append(' {')

1996

qs_body.append(' remappedBuffers = GLV_NEW_ARRAY( XGL_CMD_BUFFER, pPacket->cmdBufferCount);')

1997

qs_body.append(' for (XGL_UINT i = 0; i < pPacket->cmdBufferCount; i++)')

1998

qs_body.append(' {')

1999

qs_body.append(' *(remappedBuffers + i) = remap(*(pPacket->pCmdBuffers + i));')

2000

qs_body.append(' }')

2001

qs_body.append(' }')

2002

qs_body.append(' XGL_MEMORY_REF* memRefs = NULL;')

2003

qs_body.append(' if (pPacket->pMemRefs != NULL)')

2004

qs_body.append(' {')

2005

qs_body.append(' memRefs = GLV_NEW_ARRAY(XGL_MEMORY_REF, pPacket->memRefCount);')

2006

qs_body.append(' memcpy(memRefs, pPacket->pMemRefs, sizeof(XGL_MEMORY_REF) * pPacket->memRefCount);')

2007

qs_body.append(' for (XGL_UINT i = 0; i < pPacket->memRefCount; i++)')

2008

qs_body.append(' {')

2009

qs_body.append(' memRefs[i].mem = remap(pPacket->pMemRefs[i].mem);')

2010

qs_body.append(' }')

2011

qs_body.append(' }')

2012

qs_body.append(' replayResult = m_xglFuncs.real_xglQueueSubmit(remap(pPacket->queue), pPacket->cmdBufferCount, remappedBuffers, pPacket->memRefCount,')

2013

qs_body.append(' memRefs, remap(pPacket->fence));')

2014

qs_body.append(' GLV_DELETE(remappedBuffers);')

2015

qs_body.append(' GLV_DELETE(memRefs);')

2016

return "\n".join(qs_body)

2017

2018

def _gen_replay_get_memory_heap_count(self):

2019

mhc_body = []

2020

mhc_body.append(' XGL_UINT count;')

2021

mhc_body.append(' replayResult = m_xglFuncs.real_xglGetMemoryHeapCount(remap(pPacket->device), &count);')

2022

mhc_body.append(' if (count < 1 || count >= XGL_MAX_MEMORY_HEAPS)')

2023

mhc_body.append(' glv_LogError("xglGetMemoryHeapCount returned bad value count = %u\\n", count);')

2024

return "\n".join(mhc_body)

2025

2026

def _gen_replay_get_memory_heap_info(self):

2027

mhi_body = []

2028

mhi_body.append(' // TODO handle case where traced heap count, ids and properties do not match replay heaps')

2029

mhi_body.append(' XGL_SIZE dataSize = sizeof(XGL_MEMORY_HEAP_PROPERTIES);')

2030

mhi_body.append(' // TODO check returned properties match queried properties if this makes sense')

2031

mhi_body.append(' if (pPacket->heapId >= XGL_MAX_MEMORY_HEAPS)')

2032

mhi_body.append(' {')

2033

mhi_body.append(' glv_LogError("xglGetMemoryHeapInfo bad heapid (%d) skipping packet\\n");')

2034

mhi_body.append(' break;')

2035

mhi_body.append(' }')

2036

mhi_body.append(' replayResult = m_xglFuncs.real_xglGetMemoryHeapInfo(remap(pPacket->device), pPacket->heapId, pPacket->infoType, &dataSize,')

2037

mhi_body.append(' static_cast <XGL_VOID *> (&(m_heapProps[pPacket->heapId])));')

2038

mhi_body.append(' if (dataSize != sizeof(XGL_MEMORY_HEAP_PROPERTIES))')

2039

mhi_body.append(' glv_LogError("xglGetMemoryHeapInfo returned bad size = %u\\n", dataSize);')

2040

return "\n".join(mhi_body)

2041

2042

def _gen_replay_remap_virtual_memory_pages(self):

2043

rvm_body = []

2044

rvm_body.append(' XGL_VIRTUAL_MEMORY_REMAP_RANGE *pRemappedRanges = GLV_NEW_ARRAY( XGL_VIRTUAL_MEMORY_REMAP_RANGE, pPacket->rangeCount);')

2045

rvm_body.append(' for (XGL_UINT i = 0; i < pPacket->rangeCount; i++)')

2046

rvm_body.append(' {')

2047

rvm_body.append(' copy_mem_remap_range_struct(pRemappedRanges + i, (pPacket->pRanges + i));')

2048

rvm_body.append(' }')

2049

rvm_body.append(' XGL_QUEUE_SEMAPHORE *pRemappedPreSema = GLV_NEW_ARRAY(XGL_QUEUE_SEMAPHORE, pPacket->preWaitSemaphoreCount);')

2050

rvm_body.append(' for (XGL_UINT i = 0; i < pPacket->preWaitSemaphoreCount; i++)')

2051

rvm_body.append(' {')

2052

rvm_body.append(' *(pRemappedPreSema + i) = *(pPacket->pPreWaitSemaphores + i);')

2053

rvm_body.append(' }')

2054

rvm_body.append(' XGL_QUEUE_SEMAPHORE *pRemappedPostSema = GLV_NEW_ARRAY(XGL_QUEUE_SEMAPHORE, pPacket->postSignalSemaphoreCount);')

2055

rvm_body.append(' for (XGL_UINT i = 0; i < pPacket->postSignalSemaphoreCount; i++)')

2056

rvm_body.append(' {')

2057

rvm_body.append(' *(pRemappedPostSema + i) = *(pPacket->pPostSignalSemaphores + i);')

2058

rvm_body.append(' }')

2059

rvm_body.append(' replayResult = m_xglFuncs.real_xglRemapVirtualMemoryPages(remap(pPacket->device), pPacket->rangeCount, pRemappedRanges, pPacket->preWaitSemaphoreCount,')

2060

rvm_body.append(' pPacket->pPreWaitSemaphores, pPacket->postSignalSemaphoreCount, pPacket->pPostSignalSemaphores);')

2061

rvm_body.append(' GLV_DELETE(pRemappedRanges);')

2062

rvm_body.append(' GLV_DELETE(pRemappedPreSema);')

2063

rvm_body.append(' GLV_DELETE(pRemappedPostSema);')

2064

return "\n".join(rvm_body)

2065

2066

def _gen_replay_get_object_info(self):

2067

goi_body = []

2068

goi_body.append(' XGL_SIZE size = 0;')

2069

goi_body.append(' void* pData = NULL;')

2070

goi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')

2071

goi_body.append(' {')

2072

goi_body.append(' size = *pPacket->pDataSize;')

2073

goi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')

2074

goi_body.append(' memcpy(pData, pPacket->pData, *pPacket->pDataSize);')

2075

goi_body.append(' }')

2076

goi_body.append(' replayResult = m_xglFuncs.real_xglGetObjectInfo(remap(pPacket->object), pPacket->infoType, &size, pData);')

2077

goi_body.append(' if (replayResult == XGL_SUCCESS)')

2078

goi_body.append(' {')

2079

goi_body.append(' if (size != *pPacket->pDataSize && pData == NULL)')

2080

goi_body.append(' {')

2081

goi_body.append(' glv_LogWarn("xglGetObjectInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')

2082

goi_body.append(' }')

2083

goi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')

2084

goi_body.append(' {')

2085

goi_body.append(' glv_LogWarn("xglGetObjectInfo returned differing data contents than the trace file contained.\\n");')

2086

goi_body.append(' }')

2087

goi_body.append(' }')

2088

goi_body.append(' glv_free(pData);')

2089

return "\n".join(goi_body)

2090

2091

def _gen_replay_get_format_info(self):

2092

gfi_body = []

2093

gfi_body.append(' XGL_SIZE size = 0;')

2094

gfi_body.append(' void* pData = NULL;')

2095

gfi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')

2096

gfi_body.append(' {')

2097

gfi_body.append(' size = *pPacket->pDataSize;')

2098

gfi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')

2099

gfi_body.append(' }')

2100

gfi_body.append(' replayResult = m_xglFuncs.real_xglGetFormatInfo(remap(pPacket->device), pPacket->format, pPacket->infoType, &size, pData);')

2101

gfi_body.append(' if (replayResult == XGL_SUCCESS)')

2102

gfi_body.append(' {')

2103

gfi_body.append(' if (size != *pPacket->pDataSize && pData == NULL)')

2104

gfi_body.append(' {')

2105

gfi_body.append(' glv_LogWarn("xglGetFormatInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')

2106

gfi_body.append(' }')

2107

gfi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')

2108

gfi_body.append(' {')

2109

gfi_body.append(' glv_LogWarn("xglGetFormatInfo returned differing data contents than the trace file contained.\\n");')

2110

gfi_body.append(' }')

2111

gfi_body.append(' }')

2112

gfi_body.append(' glv_free(pData);')

2113

return "\n".join(gfi_body)

2114

2115

def _gen_replay_get_image_subresource_info(self):

2116

isi_body = []

2117

isi_body.append(' XGL_SIZE size = 0;')

2118

isi_body.append(' void* pData = NULL;')

2119

isi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')

2120

isi_body.append(' {')

2121

isi_body.append(' size = *pPacket->pDataSize;')

2122

isi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')

2123

isi_body.append(' }')

2124

isi_body.append(' replayResult = m_xglFuncs.real_xglGetImageSubresourceInfo(remap(pPacket->image), pPacket->pSubresource, pPacket->infoType, &size, pData);')

2125

isi_body.append(' if (replayResult == XGL_SUCCESS)')

2126

isi_body.append(' {')

2127

isi_body.append(' if (size != *pPacket->pDataSize && pData == NULL)')

2128

isi_body.append(' {')

2129

isi_body.append(' glv_LogWarn("xglGetImageSubresourceInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')

2130

isi_body.append(' }')

2131

isi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')

2132

isi_body.append(' {')

2133

isi_body.append(' glv_LogWarn("xglGetImageSubresourceInfo returned differing data contents than the trace file contained.\\n");')

2134

isi_body.append(' }')

2135

isi_body.append(' }')

2136

isi_body.append(' glv_free(pData);')

2137

return "\n".join(isi_body)

2138

2139

def _gen_replay_create_graphics_pipeline(self):

2140

cgp_body = []

2141

cgp_body.append(' XGL_GRAPHICS_PIPELINE_CREATE_INFO createInfo;')

2142

cgp_body.append(' struct shaderPair saveShader[10];')

2143

cgp_body.append(' unsigned int idx = 0;')

2144

cgp_body.append(' memcpy(&createInfo, pPacket->pCreateInfo, sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO));')

2145

cgp_body.append(' // Cast to shader type, as those are of primariy interest and all structs in LL have same header w/ sType & pNext')

2146

cgp_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pPacketNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacket->pCreateInfo->pNext;')

2147

cgp_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)createInfo.pNext;')

2148

cgp_body.append(' while (XGL_NULL_HANDLE != pPacketNext)')

2149

cgp_body.append(' {')

2150

cgp_body.append(' if (XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO == pNext->sType)')

2151

cgp_body.append(' {')

2152

cgp_body.append(' saveShader[idx].val = pNext->shader.shader;')

2153

cgp_body.append(' saveShader[idx++].addr = &(pNext->shader.shader);')

2154

cgp_body.append(' pNext->shader.shader = remap(pPacketNext->shader.shader);')

2155

cgp_body.append(' }')

2156

cgp_body.append(' pPacketNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacketNext->pNext;')

2157

cgp_body.append(' pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext->pNext;')

2158

cgp_body.append(' }')

2159

cgp_body.append(' XGL_PIPELINE pipeline;')

2160

cgp_body.append(' replayResult = m_xglFuncs.real_xglCreateGraphicsPipeline(remap(pPacket->device), &createInfo, &pipeline);')

2161

cgp_body.append(' if (replayResult == XGL_SUCCESS)')

2162

cgp_body.append(' {')

2163

cgp_body.append(' add_to_map(pPacket->pPipeline, &pipeline);')

2164

cgp_body.append(' }')

2165

cgp_body.append(' for (unsigned int i = 0; i < idx; i++)')

2166

cgp_body.append(' *(saveShader[i].addr) = saveShader[i].val;')

2167

return "\n".join(cgp_body)

2168

2169

def _gen_replay_store_pipeline(self):

2170

sp_body = []

2171

sp_body.append(' XGL_SIZE size = 0;')

2172

sp_body.append(' void* pData = NULL;')

2173

sp_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')

2174

sp_body.append(' {')

2175

sp_body.append(' size = *pPacket->pDataSize;')

2176

sp_body.append(' pData = glv_malloc(*pPacket->pDataSize);')

2177

sp_body.append(' }')

2178

sp_body.append(' replayResult = m_xglFuncs.real_xglStorePipeline(remap(pPacket->pipeline), &size, pData);')

2179

sp_body.append(' if (replayResult == XGL_SUCCESS)')

2180

sp_body.append(' {')

2181

sp_body.append(' if (size != *pPacket->pDataSize && pData == NULL)')

2182

sp_body.append(' {')

2183

sp_body.append(' glv_LogWarn("xglStorePipeline returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')

2184

sp_body.append(' }')

2185

sp_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')

2186

sp_body.append(' {')

2187

sp_body.append(' glv_LogWarn("xglStorePipeline returned differing data contents than the trace file contained.\\n");')

2188

sp_body.append(' }')

2189

sp_body.append(' }')

2190

sp_body.append(' glv_free(pData);')

2191

return "\n".join(sp_body)

2192

2193

def _gen_replay_cmd_bind_attachments(self):

2194

cba_body = []

2195

cba_body.append(' // adjust color targets')

2196

cba_body.append(' XGL_COLOR_ATTACHMENT_BIND_INFO* pColorAttachments = (XGL_COLOR_ATTACHMENT_BIND_INFO*)pPacket->pColorAttachments;')

2197

cba_body.append(' bool allocatedColorAttachments = false;')

2198

cba_body.append(' if (pColorAttachments != NULL)')

2199

cba_body.append(' {')

2200

cba_body.append(' allocatedColorAttachments = true;')

2201

cba_body.append(' pColorAttachments = GLV_NEW_ARRAY(XGL_COLOR_ATTACHMENT_BIND_INFO, pPacket->colorAttachmentCount);')

2202

cba_body.append(' memcpy(pColorAttachments, pPacket->pColorAttachments, sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO) * pPacket->colorAttachmentCount);')

2203

cba_body.append(' for (XGL_UINT i = 0; i < pPacket->colorAttachmentCount; i++)')

2204

cba_body.append(' {')

2205

cba_body.append(' pColorAttachments[i].view = remap(pPacket->pColorAttachments[i].view);')

2206

cba_body.append(' }')

2207

cba_body.append(' }')

2208

cba_body.append(' // adjust depth stencil target')

2209

cba_body.append(' const XGL_DEPTH_STENCIL_BIND_INFO* pDepthStencilAttachment = pPacket->pDepthStencilAttachment;')

2210

cba_body.append(' XGL_DEPTH_STENCIL_BIND_INFO depthTarget;')

2211

cba_body.append(' if (pDepthStencilAttachment != NULL)')

2212

cba_body.append(' {')

2213

cba_body.append(' memcpy(&depthTarget, pPacket->pDepthStencilAttachment, sizeof(XGL_DEPTH_STENCIL_BIND_INFO));')

2214

cba_body.append(' depthTarget.view = remap(pPacket->pDepthStencilAttachment->view);')

2215

cba_body.append(' pDepthStencilAttachment = &depthTarget;')

2216

cba_body.append(' }')

2217

cba_body.append(' // make call')

2218

cba_body.append(' m_xglFuncs.real_xglCmdBindAttachments(remap(pPacket->cmdBuffer), pPacket->colorAttachmentCount, pColorAttachments, pDepthStencilAttachment);')

2219

cba_body.append(' // cleanup')

2220

cba_body.append(' if (allocatedColorAttachments)')

2221

cba_body.append(' {')

2222

cba_body.append(' GLV_DELETE((void*)pColorAttachments);')

2223

cba_body.append(' }')

2224

return "\n".join(cba_body)

2225

2226

def _gen_replay_get_multi_gpu_compatibility(self):

2227

gmgc_body = []

2228

gmgc_body.append(' XGL_GPU_COMPATIBILITY_INFO cInfo;')

2229

gmgc_body.append(' XGL_PHYSICAL_GPU handle0, handle1;')

2230

gmgc_body.append(' handle0 = remap(pPacket->gpu0);')

2231

gmgc_body.append(' handle1 = remap(pPacket->gpu1);')

2232

gmgc_body.append(' replayResult = m_xglFuncs.real_xglGetMultiGpuCompatibility(handle0, handle1, &cInfo);')

2233

return "\n".join(gmgc_body)

2234

2235

def _gen_replay_destroy_object(self):

2236

do_body = []

2237

do_body.append(' XGL_OBJECT object = remap(pPacket->object);')

2238

do_body.append(' if (object != XGL_NULL_HANDLE)')

2239

do_body.append(' replayResult = m_xglFuncs.real_xglDestroyObject(object);')

2240

do_body.append(' if (replayResult == XGL_SUCCESS)')

2241

do_body.append(' rm_from_map(pPacket->object);')

2242

return "\n".join(do_body)

2243

2244

def _gen_replay_wait_for_fences(self):

2245

wf_body = []

2246

wf_body.append(' XGL_FENCE *pFence = GLV_NEW_ARRAY(XGL_FENCE, pPacket->fenceCount);')

2247

wf_body.append(' for (XGL_UINT i = 0; i < pPacket->fenceCount; i++)')

2248

wf_body.append(' {')

2249

wf_body.append(' *(pFence + i) = remap(*(pPacket->pFences + i));')

2250

wf_body.append(' }')

2251

wf_body.append(' replayResult = m_xglFuncs.real_xglWaitForFences(remap(pPacket->device), pPacket->fenceCount, pFence, pPacket->waitAll, pPacket->timeout);')

2252

wf_body.append(' GLV_DELETE(pFence);')

2253

return "\n".join(wf_body)

2254

2255

def _gen_replay_wsi_associate_connection(self):

2256

wac_body = []

2257

wac_body.append(' //associate with the replayers Wsi connection rather than tracers')

2258

wac_body.append(' replayResult = m_xglFuncs.real_xglWsiX11AssociateConnection(remap(pPacket->gpu), &(m_display->m_WsiConnection));')

2259

return "\n".join(wac_body)

2260

2261

def _gen_replay_wsi_get_msc(self):

2262

wgm_body = []

2263

wgm_body.append(' xcb_window_t window = m_display->m_XcbWindow;')

2264

wgm_body.append(' replayResult = m_xglFuncs.real_xglWsiX11GetMSC(remap(pPacket->device), window, pPacket->crtc, pPacket->pMsc);')

2265

return "\n".join(wgm_body)

2266

2267

def _gen_replay_wsi_create_presentable_image(self):

2268

cpi_body = []

2269

cpi_body.append(' XGL_IMAGE img;')

2270

cpi_body.append(' XGL_GPU_MEMORY mem;')

2271

cpi_body.append(' replayResult = m_xglFuncs.real_xglWsiX11CreatePresentableImage(remap(pPacket->device), pPacket->pCreateInfo, &img, &mem);')

2272

cpi_body.append(' if (replayResult == XGL_SUCCESS)')

2273

cpi_body.append(' {')

2274

cpi_body.append(' if (pPacket->pImage != NULL)')

2275

cpi_body.append(' add_to_map(pPacket->pImage, &img);')

2276

cpi_body.append(' if(pPacket->pMem != NULL)')

2277

cpi_body.append(' add_to_map(pPacket->pMem, &mem);')

2278

cpi_body.append(' }')

2279

return "\n".join(cpi_body)

2280

2281

def _gen_replay_wsi_queue_present(self):

2282

wqp_body = []

2283

wqp_body.append(' XGL_WSI_X11_PRESENT_INFO pInfo;')

2284

wqp_body.append(' memcpy(&pInfo, pPacket->pPresentInfo, sizeof(XGL_WSI_X11_PRESENT_INFO));')

2285

wqp_body.append(' pInfo.srcImage = remap(pPacket->pPresentInfo->srcImage);')

2286

wqp_body.append(' // use replayers Xcb window')

2287

wqp_body.append(' pInfo.destWindow = m_display->m_XcbWindow;')

2288

wqp_body.append(' replayResult = m_xglFuncs.real_xglWsiX11QueuePresent(remap(pPacket->queue), &pInfo, remap(pPacket->fence));')

2289

return "\n".join(wqp_body)

2290

2291

# I don't like making these 3 mem functions 'fully' custom, but just doing it for now to avoid being too cute

2292

def _gen_replay_free_memory(self):

2293

fm_body = []

2294

fm_body.append(' XGL_GPU_MEMORY handle = remap(pPacket->mem);')

2295

fm_body.append(' replayResult = m_xglFuncs.real_xglFreeMemory(handle);')

2296

fm_body.append(' if (replayResult == XGL_SUCCESS) ')

2297

fm_body.append(' {')

2298

fm_body.append(' rm_entry_from_mapData(handle);')

2299

fm_body.append(' rm_from_map(pPacket->mem);')

2300

fm_body.append(' }')

2301

return "\n".join(fm_body)

2302

2303

def _gen_replay_map_memory(self):

2304

mm_body = []

2305

mm_body.append(' XGL_GPU_MEMORY handle = remap(pPacket->mem);')

2306

mm_body.append(' XGL_VOID* pData;')

2307

mm_body.append(' replayResult = m_xglFuncs.real_xglMapMemory(handle, pPacket->flags, &pData);')

2308

mm_body.append(' if (replayResult == XGL_SUCCESS)')

2309

mm_body.append(' add_mapping_to_mapData(handle, pData);')

2310

return "\n".join(mm_body)

2311

2312

def _gen_replay_unmap_memory(self):

2313

um_body = []

2314

um_body.append(' XGL_GPU_MEMORY handle = remap(pPacket->mem);')

2315

um_body.append(' rm_mapping_from_mapData(handle, pPacket->pData); // copies data from packet into memory buffer')

2316

um_body.append(' replayResult = m_xglFuncs.real_xglUnmapMemory(handle);')

2317

return "\n".join(um_body)

2318

2319

def _gen_replay_bind_dynamic_memory_view(self):

2320

bdmv_body = []

2321

bdmv_body.append(' XGL_MEMORY_VIEW_ATTACH_INFO memView;')

2322

bdmv_body.append(' memcpy(&memView, pPacket->pMemView, sizeof(XGL_MEMORY_VIEW_ATTACH_INFO));')

2323

bdmv_body.append(' memView.mem = remap(pPacket->pMemView->mem);')

2324

bdmv_body.append(' m_xglFuncs.real_xglCmdBindDynamicMemoryView(remap(pPacket->cmdBuffer), pPacket->pipelineBindPoint, &memView);')

2325

return "\n".join(bdmv_body)

2326

2327

def _generate_replay(self):

2328

# map protos to custom functions if body is fully custom

2329

custom_body_dict = {'InitAndEnumerateGpus': self._gen_replay_init_and_enum_gpus,

2330

'GetGpuInfo': self._gen_replay_get_gpu_info,

2331

'CreateDevice': self._gen_replay_create_device,

2332

'GetExtensionSupport': self._gen_replay_get_extension_support,

2333

'QueueSubmit': self._gen_replay_queue_submit,

2334

'GetMemoryHeapCount': self._gen_replay_get_memory_heap_count,

2335

'GetMemoryHeapInfo': self._gen_replay_get_memory_heap_info,

2336

'RemapVirtualMemoryPages': self._gen_replay_remap_virtual_memory_pages,

2337

'GetObjectInfo': self._gen_replay_get_object_info,

2338

'GetFormatInfo': self._gen_replay_get_format_info,

2339

'GetImageSubresourceInfo': self._gen_replay_get_image_subresource_info,

2340

'CreateGraphicsPipeline': self._gen_replay_create_graphics_pipeline,

2341

'StorePipeline': self._gen_replay_store_pipeline,

2342

'CmdBindAttachments': self._gen_replay_cmd_bind_attachments,

2343

'GetMultiGpuCompatibility': self._gen_replay_get_multi_gpu_compatibility,

2344

'DestroyObject': self._gen_replay_destroy_object,

2345

'WaitForFences': self._gen_replay_wait_for_fences,

2346

'WsiX11AssociateConnection': self._gen_replay_wsi_associate_connection,

2347

'WsiX11GetMSC': self._gen_replay_wsi_get_msc,

2348

'WsiX11CreatePresentableImage': self._gen_replay_wsi_create_presentable_image,

2349

'WsiX11QueuePresent': self._gen_replay_wsi_queue_present,

2350

'FreeMemory': self._gen_replay_free_memory,

2351

'MapMemory': self._gen_replay_map_memory,

2352

'UnmapMemory': self._gen_replay_unmap_memory,

2353

'CmdBindDynamicMemoryView': self._gen_replay_bind_dynamic_memory_view}

2354

# Despite returning a value, don't check these funcs b/c custom code includes check already

2355

custom_check_ret_val = ['InitAndEnumerateGpus', 'GetGpuInfo', 'CreateDevice', 'GetExtensionSupport']

2356

# multi-gpu Open funcs w/ list of local params to create

2357

custom_open_params = {'OpenSharedMemory': (-1,),

2358

'OpenSharedQueueSemaphore': (-1,),

2359

'OpenPeerMemory': (-1,),

2360

'OpenPeerImage': (-1, -2,)}

2361

# Functions that create views are unique from other create functions

2362

create_view_list = ['CreateImageView', 'CreateColorAttachmentView', 'CreateDepthStencilView', 'CreateComputePipeline']

2363

# Functions to treat as "Create' that don't have 'Create' in the name

2364

special_create_list = ['LoadPipeline', 'AllocMemory', 'GetDeviceQueue', 'PinSystemMemory']

2365

# A couple funcs use do while loops

2366

do_while_dict = {'GetFenceStatus': 'replayResult != pPacket->result && pPacket->result == XGL_SUCCESS', 'GetEventStatus': '(pPacket->result == XGL_EVENT_SET || pPacket->result == XGL_EVENT_RESET) && replayResult != pPacket->result'}

2367

rbody = []

2368

rbody.append('#define CHECK_RETURN_VALUE(entrypoint) returnValue = handle_replay_errors(#entrypoint, replayResult, pPacket->result, returnValue);\n')

2369

rbody.append('glv_replay::GLV_REPLAY_RESULT xglReplay::replay(glv_trace_packet_header *packet)')

2370

rbody.append('{')

2371

rbody.append(' glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;')

2372

rbody.append(' XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;')

2373

rbody.append(' switch (packet->packet_id)')

2374

rbody.append(' {')

2375

for proto in self.protos:

ret_value = False

create_view = False

create_func = False

transitions = False

ds_attach = False

# TODO : How to handle VOID* return of GetProcAddr?

2382

if ('VOID' not in proto.ret) and (proto.name not in custom_check_ret_val):

2383

ret_value = True

2384

if proto.name in create_view_list:

2385

create_view = True

2386

elif 'Create' in proto.name or proto.name in special_create_list:

2387

create_func = True

2388

elif 'pStateTransitions' in [p.name for p in proto.params]:

2389

transitions = True

2390

elif proto.name.startswith('Attach'):

2391

ds_attach = True

2392

rbody.append(' case GLV_TPI_XGL_xgl%s:' % proto.name)

2393

rbody.append(' {')

2394

rbody.append(' struct_xgl%s* pPacket = (struct_xgl%s*)(packet->pBody);' % (proto.name, proto.name))

2395

if proto.name in custom_body_dict:

2396

rbody.append(custom_body_dict[proto.name]())

2397

else:

2398

if proto.name in custom_open_params:

2399

rbody.append(' XGL_DEVICE handle;')

2400

for pidx in custom_open_params[proto.name]:

2401

rbody.append(' %s local_%s;' % (proto.params[pidx].ty.strip('const ').strip('*'), proto.params[pidx].name))

2402

rbody.append(' handle = remap(pPacket->device);')

2403

elif create_view:

2404

rbody.append(' %s createInfo;' % (proto.params[1].ty.strip('*').strip('const ')))

2405

rbody.append(' memcpy(&createInfo, pPacket->pCreateInfo, sizeof(%s));' % (proto.params[1].ty.strip('*').strip('const ')))

2406

if 'CreateComputePipeline' == proto.name:

2407

rbody.append(' createInfo.cs.shader = remap(pPacket->pCreateInfo->cs.shader);')

2408

else:

2409

rbody.append(' createInfo.image = remap(pPacket->pCreateInfo->image);')

2410

rbody.append(' %s local_%s;' % (proto.params[-1].ty.strip('*').strip('const '), proto.params[-1].name))

2411

elif create_func: # Declare local var to store created handle into

2412

rbody.append(' %s local_%s;' % (proto.params[-1].ty.strip('*').strip('const '), proto.params[-1].name))

2413

elif transitions:

2414

rbody.append(' %s pStateTransitions = (%s)pPacket->pStateTransitions;' % (proto.params[-1].ty.strip('const '), proto.params[-1].ty.strip('const ')))

2415

rbody.append(' bool allocatedMem = false;')

2416

rbody.append(' if (pStateTransitions != NULL)')

2417

rbody.append(' {')

2418

rbody.append(' allocatedMem = true;')

2419

rbody.append(' pStateTransitions = GLV_NEW_ARRAY(%s, pPacket->transitionCount);' % (proto.params[-1].ty.strip('*').strip('const ')))

2420

rbody.append(' memcpy(pStateTransitions, pPacket->pStateTransitions, sizeof(%s) * pPacket->transitionCount);' % (proto.params[-1].ty.strip('*').strip('const ')))

2421

rbody.append(' for (XGL_UINT i = 0; i < pPacket->transitionCount; i++)')

2422

rbody.append(' {')

2423

if 'Memory' in proto.name:

2424

rbody.append(' pStateTransitions[i].mem = remap(pPacket->pStateTransitions[i].mem);')

2425

else:

2426

rbody.append(' pStateTransitions[i].image = remap(pPacket->pStateTransitions[i].image);')

rbody.append(' }')

rbody.append(' }')

elif ds_attach:

rbody.append(' %s %s = GLV_NEW_ARRAY(%s, pPacket->slotCount);' % (proto.params[-1].ty.strip('const '), proto.params[-1].name, proto.params[-1].ty.strip('const ').strip('*')))

2431

rbody.append(' memcpy(%s, pPacket->%s, pPacket->slotCount * sizeof(%s));' % (proto.params[-1].name, proto.params[-1].name, proto.params[-1].ty.strip('const ').strip('*')))

2432

rbody.append(' for (XGL_UINT i = 0; i < pPacket->slotCount; i++)')

2433

rbody.append(' {')

2434

if 'Sampler' in proto.name:

2435

rbody.append(' %s[i] = remap(pPacket->%s[i]);' % (proto.params[-1].name, proto.params[-1].name))

2436

elif 'Image' in proto.name:

2437

rbody.append(' %s[i].view = remap(pPacket->%s[i].view);' % (proto.params[-1].name, proto.params[-1].name))

2438

elif 'Memory' in proto.name:

2439

rbody.append(' %s[i].mem = remap(pPacket->%s[i].mem);' % (proto.params[-1].name, proto.params[-1].name))

2440

else:

2441

rbody.append(' %s[i].descriptorSet = remap(pPacket->%s[i].descriptorSet);' % (proto.params[-1].name, proto.params[-1].name))

2442

rbody.append(' }')

2443

elif proto.name in do_while_dict:

2444

rbody.append(' do {')

2445

rr_string = ' '

2446

if ret_value:

2447

rr_string = ' replayResult = '

2448

rr_string += 'm_xglFuncs.real_xgl%s(' % proto.name

2449

for p in proto.params:

2450

# For last param of Create funcs, pass address of param

2451

if create_func and p.name == proto.params[-1].name:

2452

rr_string += '&local_%s, ' % p.name

2453

else:

2454

rr_string += '%s, ' % self._get_packet_param(p.ty, p.name)

2455

rr_string = '%s);' % rr_string[:-2]

2456

if transitions:

2457

rr_string = rr_string.replace('pPacket->pState', 'pState')

2458

elif ds_attach:

2459

rr_list = rr_string.split(', ')

2460

rr_list[-1] = '%s);' % proto.params[-1].name

2461

rr_string = ', '.join(rr_list)

2462

elif proto.name in custom_open_params:

2463

rr_list = rr_string.split(', ')

2464

rr_list[0] = rr_list[0].replace('remap(pPacket->device)', 'handle')

2465

for pidx in custom_open_params[proto.name]:

2466

rr_list[pidx] = '&local_%s' % proto.params[pidx].name

2467

rr_string = ', '.join(rr_list)

2468

rr_string += ');'

2469

elif create_view:

2470

rr_list = rr_string.split(', ')

2471

rr_list[-2] = '&createInfo'

2472

rr_list[-1] = '&local_%s);' % proto.params[-1].name

2473

rr_string = ', '.join(rr_list)

2474

# this is a sneaky shortcut to use generic create code below to add_to_map

2475

create_func = True

2476

rbody.append(rr_string)

2477

if 'DestroyDevice' in proto.name:

2478

rbody.append(' if (replayResult == XGL_SUCCESS)')

2479

rbody.append(' {')

2480

rbody.append(' rm_from_map(pPacket->device);')

2481

rbody.append(' m_display->m_initedXGL = false;')

2482

rbody.append(' }')

2483

elif create_func: # save handle mapping if create successful

2484

rbody.append(' if (replayResult == XGL_SUCCESS)')

2485

rbody.append(' {')

2486

rbody.append(' add_to_map(pPacket->%s, &local_%s);' % (proto.params[-1].name, proto.params[-1].name))

2487

if 'AllocMemory' == proto.name:

2488

rbody.append(' add_entry_to_mapData(local_%s, pPacket->pAllocInfo->allocationSize);' % (proto.params[-1].name))

2489

rbody.append(' }')

2490

elif transitions:

2491

rbody.append(' if (allocatedMem)')

2492

rbody.append(' {')

2493

rbody.append(' GLV_DELETE((void*)pStateTransitions);')

2494

rbody.append(' }')

2495

elif ds_attach:

2496

rbody.append(' GLV_DELETE(%s);' % proto.params[-1].name)

2497

elif proto.name in do_while_dict:

2498

rbody[-1] = ' %s' % rbody[-1]

2499

rbody.append(' } while (%s);' % do_while_dict[proto.name])

2500

if ret_value:

2501

rbody.append(' CHECK_RETURN_VALUE(xgl%s);' % proto.name)

2502

if 'MsgCallback' in proto.name:

rbody.pop()

rbody.pop()

rbody.pop()

rbody.append(' // Just eating these calls as no way to restore dbg func ptr.')

2507

rbody.append(' break;')

2508

rbody.append(' }')

2509

rbody.append(' default:')

2510

rbody.append(' glv_LogWarn("Unrecognized packet_id %u, skipping\\n", packet->packet_id);')

2511

rbody.append(' returnValue = glv_replay::GLV_REPLAY_INVALID_ID;')

2512

rbody.append(' break;')

2513

rbody.append(' }')

2514

rbody.append(' return returnValue;')

2515

rbody.append('}')

2516

return "\n".join(rbody)

2517

2518

class GlaveTraceHeader(Subcommand):

2519

def generate_header(self):

2520

header_txt = []

2521

header_txt.append('#include "glvtrace_xgl_xgl_structs.h"')

2522

header_txt.append('#include "glvtrace_xgl_packet_id.h"\n')

2523

header_txt.append('void AttachHooks();')

2524

header_txt.append('void DetachHooks();')

2525

header_txt.append('void InitTracer();\n')

2526

return "\n".join(header_txt)

2527

2528

def generate_body(self):

2529

body = [self._generate_trace_func_ptrs(),

2530

self._generate_trace_func_protos()]

2531

2532

return "\n".join(body)

2533

2534

class GlaveTraceC(Subcommand):

2535

def generate_header(self):

2536

header_txt = []

2537

header_txt.append('#include "glv_platform.h"')

2538

header_txt.append('#include "glv_common.h"')

2539

header_txt.append('#include "glvtrace_xgl_xgl.h"')

2540

header_txt.append('#include "glvtrace_xgl_xgldbg.h"')

2541

header_txt.append('#include "glvtrace_xgl_xglwsix11ext.h"')

2542

header_txt.append('#include "glv_interconnect.h"')

2543

header_txt.append('#include "glv_filelike.h"')

2544

header_txt.append('#ifdef WIN32')

2545

header_txt.append('#include "mhook/mhook-lib/mhook.h"')

2546

header_txt.append('#endif')

2547

header_txt.append('#include "glv_trace_packet_utils.h"')

2548

header_txt.append('#include <stdio.h>\n')

2549

return "\n".join(header_txt)

2550

2551

def generate_body(self):

2552

body = [self._generate_func_ptr_assignments(),

2553

self._generate_attach_hooks(),

2554

self._generate_detach_hooks(),

2555

self._generate_init_tracer(),

2556

self._generate_helper_funcs(),

2557

self._generate_trace_funcs()]

2558

2559

return "\n".join(body)

2560

2561

class GlavePacketID(Subcommand):

2562

def generate_header(self):

2563

header_txt = []

2564

header_txt.append('#pragma once\n')

2565

header_txt.append('#include "glv_trace_packet_utils.h"')

2566

header_txt.append('#include "glv_trace_packet_identifiers.h"')

2567

header_txt.append('#include "glv_interconnect.h"')

2568

header_txt.append('#include "glvtrace_xgl_xgl_structs.h"')

2569

header_txt.append('#include "glvtrace_xgl_xgldbg_structs.h"')

2570

header_txt.append('#include "glvtrace_xgl_xglwsix11ext_structs.h"')

2571

header_txt.append('#include "xgl_enum_string_helper.h"')

2572

header_txt.append('#define SEND_ENTRYPOINT_ID(entrypoint) ;')

2573

header_txt.append('//#define SEND_ENTRYPOINT_ID(entrypoint) glv_TraceInfo(#entrypoint "\\n");\n')

2574

header_txt.append('#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) ;')

2575

header_txt.append('//#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) glv_TraceInfo(entrypoint, __VA_ARGS__);\n')

2576

header_txt.append('#define CREATE_TRACE_PACKET(entrypoint, buffer_bytes_needed) \\')

2577

header_txt.append(' pHeader = glv_create_trace_packet(GLV_TID_XGL, GLV_TPI_XGL_##entrypoint, sizeof(struct_##entrypoint), buffer_bytes_needed);\n')

2578

header_txt.append('#define FINISH_TRACE_PACKET() \\')

2579

header_txt.append(' glv_finalize_trace_packet(pHeader); \\')

2580

header_txt.append(' glv_write_trace_packet(pHeader, glv_trace_get_trace_file()); \\')

2581

header_txt.append(' glv_delete_trace_packet(&pHeader);')

2582

return "\n".join(header_txt)

2583

2584

def generate_body(self):

2585

body = [self._generate_packet_id_enum(),

2586

self._generate_stringify_func(),

2587

self._generate_interp_func()]

2588

2589

return "\n".join(body)

2590

2591

class GlaveCoreStructs(Subcommand):

2592

def generate_header(self):

2593

header_txt = []

2594

header_txt.append('#pragma once\n')

2595

header_txt.append('#include "xgl.h"')

2596

header_txt.append('#include "glv_trace_packet_utils.h"\n')

2597

return "\n".join(header_txt)

2598

2599

def generate_body(self):

2600

body = [self._generate_struct_util_funcs(),

2601

self._generate_interp_funcs()]

2602

2603

return "\n".join(body)

2604

2605

class GlaveWsiHeader(Subcommand):

2606

def generate_header(self):

2607

header_txt = []

2608

header_txt.append('#pragma once\n')

2609

header_txt.append('#include "xgl.h"')

2610

header_txt.append('#include "xglWsiX11Ext.h"\n')

2611

header_txt.append('void AttachHooks_xglwsix11ext();')

2612

header_txt.append('void DetachHooks_xglwsix11ext();')

2613

return "\n".join(header_txt)

2614

2615

def generate_body(self):

2616

body = [self._generate_trace_func_ptrs_ext(),

2617

self._generate_trace_func_protos_ext()]

2618

2619

return "\n".join(body)

2620

2621

class GlaveWsiC(Subcommand):

2622

def generate_header(self):

2623

header_txt = []

2624

header_txt.append('#include "glv_platform.h"')

2625

header_txt.append('#include "glv_common.h"')

2626

header_txt.append('#include "glvtrace_xgl_xglwsix11ext.h"')

2627

header_txt.append('#include "glvtrace_xgl_xglwsix11ext_structs.h"')

2628

header_txt.append('#include "glvtrace_xgl_packet_id.h"')

2629

header_txt.append('#ifdef WIN32')

2630

header_txt.append('#include "mhook/mhook-lib/mhook.h"')

2631

header_txt.append('#endif')

2632

return "\n".join(header_txt)

2633

2634

def generate_body(self):

2635

body = [self._generate_func_ptr_assignments_ext(),

2636

self._generate_attach_hooks_ext(),

2637

self._generate_detach_hooks_ext(),

2638

self._generate_trace_funcs_ext()]

2639

2640

return "\n".join(body)

2641

2642

class GlaveWsiStructs(Subcommand):

2643

def generate_header(self):

2644

header_txt = []

2645

header_txt.append('#pragma once\n')

2646

header_txt.append('#include "xglWsiX11Ext.h"')

2647

header_txt.append('#include "glv_trace_packet_utils.h"\n')

2648

return "\n".join(header_txt)

2649

2650

def generate_body(self):

2651

body = [self._generate_interp_funcs_ext()]

2652

2653

return "\n".join(body)

2654

2655

class GlaveDbgHeader(Subcommand):

2656

def generate_header(self):

2657

header_txt = []

2658

header_txt.append('#pragma once\n')

2659

header_txt.append('#include "xgl.h"')

2660

header_txt.append('#include "xglDbg.h"\n')

2661

header_txt.append('void AttachHooks_xgldbg();')

2662

header_txt.append('void DetachHooks_xgldbg();')

2663

return "\n".join(header_txt)

2664

2665

def generate_body(self):

2666

body = [self._generate_trace_func_ptrs_ext('Dbg'),

2667

self._generate_trace_func_protos_ext('Dbg')]

2668

2669

return "\n".join(body)

2670

2671

class GlaveDbgC(Subcommand):

2672

def generate_header(self):

2673

header_txt = []

2674

header_txt.append('#include "glv_platform.h"')

2675

header_txt.append('#include "glv_common.h"')

2676

header_txt.append('#include "glvtrace_xgl_xgl.h"')

2677

header_txt.append('#include "glvtrace_xgl_xgldbg.h"')

2678

header_txt.append('#include "glvtrace_xgl_xgldbg_structs.h"')

2679

header_txt.append('#include "glvtrace_xgl_packet_id.h"')

2680

header_txt.append('#ifdef WIN32')

2681

header_txt.append('#include "mhook/mhook-lib/mhook.h"')

2682

header_txt.append('#endif')

2683

return "\n".join(header_txt)

2684

2685

def generate_body(self):

2686

body = [self._generate_func_ptr_assignments_ext('Dbg'),

2687

self._generate_attach_hooks_ext('Dbg'),

2688

self._generate_detach_hooks_ext('Dbg'),

2689

self._generate_trace_funcs_ext('Dbg')]

2690

2691

return "\n".join(body)

2692

2693

class GlaveDbgStructs(Subcommand):

2694

def generate_header(self):

2695

header_txt = []

2696

header_txt.append('#pragma once\n')

2697

header_txt.append('#include "xglDbg.h"')

2698

header_txt.append('#include "glv_trace_packet_utils.h"\n')

2699

return "\n".join(header_txt)

2700

2701

def generate_body(self):

2702

body = [self._generate_interp_funcs_ext('Dbg')]

2703

2704

return "\n".join(body)

2705

2706

class GlaveReplayHeader(Subcommand):

2707

def generate_header(self):

2708

header_txt = []

2709

header_txt.append('#pragma once\n')

2710

header_txt.append('#include <set>')

2711

header_txt.append('#include <map>')

2712

header_txt.append('#include <vector>')

2713

header_txt.append('#include <xcb/xcb.h>\n')

2714

header_txt.append('#include "glvreplay_window.h"')

2715

header_txt.append('#include "glvreplay_factory.h"')

2716

header_txt.append('#include "glv_trace_packet_identifiers.h"\n')

2717

header_txt.append('#include "xgl.h"')

2718

header_txt.append('#include "xglDbg.h"')

2719

header_txt.append('#include "xglWsiX11Ext.h"')

2720

return "\n".join(header_txt)

2721

2722

def generate_body(self):

2723

body = [self._generate_replay_class_decls(),

2724

self._generate_replay_func_ptrs(),

2725

self._generate_replay_class()]

2726

2727

return "\n".join(body)

2728

2729

class GlaveReplayC(Subcommand):

2730

def generate_header(self):

2731

header_txt = []

2732

header_txt.append('#include "glvreplay_xgl_replay.h"\n')

2733

header_txt.append('extern "C" {')

2734

header_txt.append('#include "glvtrace_xgl_xgl_structs.h"')

2735

header_txt.append('#include "glvtrace_xgl_xgldbg_structs.h"')

2736

header_txt.append('#include "glvtrace_xgl_xglwsix11ext_structs.h"')

2737

header_txt.append('#include "glvtrace_xgl_packet_id.h"')

2738

header_txt.append('#include "xgl_enum_string_helper.h"\n}\n')

2739

header_txt.append('#define APP_NAME "glvreplay_xgl"')

2740

header_txt.append('#define IDI_ICON 101\n')

2741

header_txt.append('static const char* g_extensions[] =')

2742

header_txt.append('{')

2743

header_txt.append(' "XGL_WSI_WINDOWS",')

2744

header_txt.append(' "XGL_TIMER_QUEUE",')

2745

header_txt.append(' "XGL_GPU_TIMESTAMP_CALIBRATION",')

2746

header_txt.append(' "XGL_DMA_QUEUE",')

2747

header_txt.append(' "XGL_COMMAND_BUFFER_CONTROL_FLOW",')

2748

header_txt.append(' "XGL_COPY_OCCLUSION_QUERY_DATA",')

2749

header_txt.append(' "XGL_ADVANCED_MULTISAMPLING",')

2750

header_txt.append(' "XGL_BORDER_COLOR_PALETTE"')

2751

header_txt.append('};')

2752

return "\n".join(header_txt)

2753

2754

def generate_body(self):

2755

body = [self._generate_replay_display_init_xgl(),

2756

self._generate_replay_display_init(),

2757

self._generate_replay_display_structors(),

2758

self._generate_replay_display_window(),

2759

self._generate_replay_structors(),

2760

self._generate_replay_init(),

2761

self._generate_replay_remap(),

2762

self._generate_replay_errors(),

2763

self._generate_replay_init_funcs(),

2764

self._generate_replay()]

2765

2766

return "\n".join(body)

def main():

subcommands = {

"glave-trace-h" : GlaveTraceHeader,

2771

"glave-trace-c" : GlaveTraceC,

2772

"glave-packet-id" : GlavePacketID,

2773

"glave-core-structs" : GlaveCoreStructs,

2774

"glave-wsi-trace-h" : GlaveWsiHeader,

2775

"glave-wsi-trace-c" : GlaveWsiC,

2776

"glave-wsi-trace-structs" : GlaveWsiStructs,

2777

"glave-dbg-trace-h" : GlaveDbgHeader,

2778

"glave-dbg-trace-c" : GlaveDbgC,

2779

"glave-dbg-trace-structs" : GlaveDbgStructs,

2780

"glave-replay-h" : GlaveReplayHeader,

2781

"glave-replay-c" : GlaveReplayC,

2782

}

2783

2784

if len(sys.argv) < 2 or sys.argv[1] not in subcommands:

2785

print("Usage: %s <subcommand> [options]" % sys.argv[0])

2786

print

2787

print("Available sucommands are: %s" % " ".join(subcommands))

2788

exit(1)

2789

2790

subcmd = subcommands[sys.argv[1]](sys.argv[2:])

2791

subcmd.run()

2792

2793

if __name__ == "__main__":

2794

main()