~mmach/netext73/mesa-haswell

('SVGA_3D_CMD_DRAW_PRIMITIVES', 'SVGA3dCmdDrawPrimitives', (('SVGA3dVertexDecl', 'numVertexDecls'), ('SVGA3dPrimitiveRange', 'numRanges')), 'SVGA3dVertexDivisor'),

199

('SVGA_3D_CMD_SETSCISSORRECT', 'SVGA3dCmdSetScissorRect', (), None),

200

('SVGA_3D_CMD_BEGIN_QUERY', 'SVGA3dCmdBeginQuery', (), None),

201

('SVGA_3D_CMD_END_QUERY', 'SVGA3dCmdEndQuery', (), None),

202

('SVGA_3D_CMD_WAIT_FOR_QUERY', 'SVGA3dCmdWaitForQuery', (), None),

203

#('SVGA_3D_CMD_PRESENT_READBACK', None, (), None),

204

('SVGA_3D_CMD_BLIT_SURFACE_TO_SCREEN', 'SVGA3dCmdBlitSurfaceToScreen', (), 'SVGASignedRect'),

205

]

206

207

def dump_cmds():

208

print r'''

209

void

210

svga_dump_command(uint32_t cmd_id, const void *data, uint32_t size)

211

{

212

const uint8_t *body = (const uint8_t *)data;

213

const uint8_t *next = body + size;

214

'''

215

print ' switch(cmd_id) {'

216

indexes = 'ijklmn'

217

for id, header, body, footer in cmds:

218

print ' case %s:' % id

219

print ' _debug_printf("\\t%s\\n");' % id

220

print ' {'

221

print ' const %s *cmd = (const %s *)body;' % (header, header)

222

if len(body):

223

print ' unsigned ' + ', '.join(indexes[:len(body)]) + ';'

224

print ' dump_%s(cmd);' % header

225

print ' body = (const uint8_t *)&cmd[1];'

226

for i in range(len(body)):

227

struct, count = body[i]

228

idx = indexes[i]

229

print ' for(%s = 0; %s < cmd->%s; ++%s) {' % (idx, idx, count, idx)

230

print ' dump_%s((const %s *)body);' % (struct, struct)

231

print ' body += sizeof(%s);' % struct

232

print ' }'

233

if footer is not None:

234

print ' while(body + sizeof(%s) <= next) {' % footer

235

print ' dump_%s((const %s *)body);' % (footer, footer)

236

print ' body += sizeof(%s);' % footer

237

print ' }'

238

if id == 'SVGA_3D_CMD_SHADER_DEFINE':

239

print ' svga_shader_dump((const uint32_t *)body,'

240

print ' (unsigned)(next - body)/sizeof(uint32_t),'

241

print ' FALSE);'

242

print ' body = next;'

243

print ' }'

244

print ' break;'

245

print ' default:'

246

print ' _debug_printf("\\t0x%08x\\n", cmd_id);'

247

print ' break;'

248

print ' }'

249

print r'''

250

while(body + sizeof(uint32_t) <= next) {

251

_debug_printf("\t\t0x%08x\n", *(const uint32_t *)body);

252

body += sizeof(uint32_t);

253

}

254

while(body + sizeof(uint32_t) <= next)

255

_debug_printf("\t\t0x%02x\n", *body++);

256

}

257

'''

258

print r'''

259

void

260

svga_dump_commands(const void *commands, uint32_t size)

261

{

262

const uint8_t *next = commands;

263

const uint8_t *last = next + size;

264

265

assert(size % sizeof(uint32_t) == 0);

266

267

while(next < last) {

268

const uint32_t cmd_id = *(const uint32_t *)next;

269

270

if(SVGA_3D_CMD_BASE <= cmd_id && cmd_id < SVGA_3D_CMD_MAX) {

271

const SVGA3dCmdHeader *header = (const SVGA3dCmdHeader *)next;

272

const uint8_t *body = (const uint8_t *)&header[1];

273

274

next = body + header->size;

275

if(next > last)

276

break;

277

278

svga_dump_command(cmd_id, body, header->size);

279

}

280

else if(cmd_id == SVGA_CMD_FENCE) {

281

_debug_printf("\tSVGA_CMD_FENCE\n");

282

_debug_printf("\t\t0x%08x\n", ((const uint32_t *)next)[1]);

283

next += 2*sizeof(uint32_t);

284

}

285

else {

286

_debug_printf("\t0x%08x\n", cmd_id);

287

next += sizeof(uint32_t);

288

}

289

}

290

}

291

'''

292

293

def main():

294

print copyright.strip()

295

296

print '/**'

297

print ' * @file'

298

print ' * Dump SVGA commands.'

299

print ' *'

300

print ' * Generated automatically from svga3d_reg.h by svga_dump.py.'

301

print ' */'

302

303

print '#include "svga_types.h"'

304

print '#include "svga_shader_dump.h"'

305

print '#include "svga3d_reg.h"'

306

307

print '#include "util/u_debug.h"'

308

print '#include "svga_dump.h"'

309

310

311

config = parser.config_t(

312

include_paths = ['../../../include', '../include'],

313

compiler = 'gcc',

314

)

315

316

headers = [

317

'svga_types.h',

318

'svga3d_reg.h',

319

]

320

321

decls = parser.parse(headers, config, parser.COMPILATION_MODE.ALL_AT_ONCE)

322

global_ns = declarations.get_global_namespace(decls)

323

324

names = set()

325

for id, header, body, footer in cmds:

326

names.add(header)

327

for struct, count in body:

328

names.add(struct)

329

if footer is not None:

330

names.add(footer)

331

332

for class_ in global_ns.classes(lambda decl: decl.name in names):

333

dump_struct(decls, class_)

334

335

dump_cmds()

336

337

338

if __name__ == '__main__':

339

main()

Older »