/srv/pokybuild/yocto-worker/reproducible/build/build-st/tmp/work/x86_64-linux/diffoscope-native/208-r0/recipe-sysroot-native/usr/bin/diffoscope.real --no-default-limits --max-report-size 262144000 --exclude-directory-metadata yes --html-dir /srv/autobuilder/valkyrie.yocto.io/pub/repro-fail/oe-reproducible-20250308-s52sakkc/packages/diff-html reproducibleA reproducibleB

126

static·inline·void·_nocheck__trace_jazzio_read(uint64_t·addr,·uint32_t·ret)

126

static·inline·void·_nocheck__trace_jazzio_read(uint64_t·addr,·uint32_t·ret)

127

{

127

{

128

····if·(trace_event_get_state(TRACE_JAZZIO_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

128

····if·(trace_event_get_state(TRACE_JAZZIO_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

129

········if·(message_with_timestamp)·{

129

········if·(message_with_timestamp)·{

130

············struct·timeval·_now;

130

············struct·timeval·_now;

131

············gettimeofday(&_now,·NULL);

131

············gettimeofday(&_now,·NULL);

133

············qemu_log("%d@%zu.%06zu:jazzio_read·"·"read·reg[0x%"PRIx64"]·=·0x%x"·"\n",

133

············qemu_log("%d@%zu.%06zu:jazzio_read·"·"read·reg[0x%"PRIx64"]·=·0x%x"·"\n",

134

·····················qemu_get_thread_id(),

134

·····················qemu_get_thread_id(),

135

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

135

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

136

·····················,·addr,·ret);

136

·····················,·addr,·ret);

137

#line·139·"trace/trace-hw_dma.h"

137

#line·139·"trace/trace-hw_dma.h"

138

········}·else·{

138

········}·else·{

140

············qemu_log("jazzio_read·"·"read·reg[0x%"PRIx64"]·=·0x%x"·"\n",·addr,·ret);

140

············qemu_log("jazzio_read·"·"read·reg[0x%"PRIx64"]·=·0x%x"·"\n",·addr,·ret);

141

#line·143·"trace/trace-hw_dma.h"

141

#line·143·"trace/trace-hw_dma.h"

142

········}

142

········}

143

····}

143

····}

144

}

144

}

145

static·inline·void·trace_jazzio_read(uint64_t·addr,·uint32_t·ret)

145

static·inline·void·trace_jazzio_read(uint64_t·addr,·uint32_t·ret)

157

static·inline·void·_nocheck__trace_jazzio_write(uint64_t·addr,·uint32_t·val)

157

static·inline·void·_nocheck__trace_jazzio_write(uint64_t·addr,·uint32_t·val)

158

{

158

{

159

····if·(trace_event_get_state(TRACE_JAZZIO_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

159

····if·(trace_event_get_state(TRACE_JAZZIO_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

160

········if·(message_with_timestamp)·{

160

········if·(message_with_timestamp)·{

161

············struct·timeval·_now;

161

············struct·timeval·_now;

162

············gettimeofday(&_now,·NULL);

162

············gettimeofday(&_now,·NULL);

164

············qemu_log("%d@%zu.%06zu:jazzio_write·"·"write·reg[0x%"PRIx64"]·=·0x%x"·"\n",

164

············qemu_log("%d@%zu.%06zu:jazzio_write·"·"write·reg[0x%"PRIx64"]·=·0x%x"·"\n",

165

·····················qemu_get_thread_id(),

165

·····················qemu_get_thread_id(),

166

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

166

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

167

·····················,·addr,·val);

167

·····················,·addr,·val);

168

#line·170·"trace/trace-hw_dma.h"

168

#line·170·"trace/trace-hw_dma.h"

169

········}·else·{

169

········}·else·{

171

············qemu_log("jazzio_write·"·"write·reg[0x%"PRIx64"]·=·0x%x"·"\n",·addr,·val);

171

············qemu_log("jazzio_write·"·"write·reg[0x%"PRIx64"]·=·0x%x"·"\n",·addr,·val);

172

#line·174·"trace/trace-hw_dma.h"

172

#line·174·"trace/trace-hw_dma.h"

173

········}

173

········}

174

····}

174

····}

175

}

175

}

176

static·inline·void·trace_jazzio_write(uint64_t·addr,·uint32_t·val)

176

static·inline·void·trace_jazzio_write(uint64_t·addr,·uint32_t·val)

188

static·inline·void·_nocheck__trace_rc4030_read(uint64_t·addr,·uint32_t·ret)

188

static·inline·void·_nocheck__trace_rc4030_read(uint64_t·addr,·uint32_t·ret)

189

{

189

{

190

····if·(trace_event_get_state(TRACE_RC4030_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

190

····if·(trace_event_get_state(TRACE_RC4030_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

191

········if·(message_with_timestamp)·{

191

········if·(message_with_timestamp)·{

192

············struct·timeval·_now;

192

············struct·timeval·_now;

193

············gettimeofday(&_now,·NULL);

193

············gettimeofday(&_now,·NULL);

195

············qemu_log("%d@%zu.%06zu:rc4030_read·"·"read·reg[0x%"PRIx64"]·=·0x%x"·"\n",

195

············qemu_log("%d@%zu.%06zu:rc4030_read·"·"read·reg[0x%"PRIx64"]·=·0x%x"·"\n",

196

·····················qemu_get_thread_id(),

196

·····················qemu_get_thread_id(),

197

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

197

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

198

·····················,·addr,·ret);

198

·····················,·addr,·ret);

199

#line·201·"trace/trace-hw_dma.h"

199

#line·201·"trace/trace-hw_dma.h"

200

········}·else·{

200

········}·else·{

202

············qemu_log("rc4030_read·"·"read·reg[0x%"PRIx64"]·=·0x%x"·"\n",·addr,·ret);

202

············qemu_log("rc4030_read·"·"read·reg[0x%"PRIx64"]·=·0x%x"·"\n",·addr,·ret);

203

#line·205·"trace/trace-hw_dma.h"

203

#line·205·"trace/trace-hw_dma.h"

204

········}

204

········}

205

····}

205

····}

206

}

206

}

207

static·inline·void·trace_rc4030_read(uint64_t·addr,·uint32_t·ret)

207

static·inline·void·trace_rc4030_read(uint64_t·addr,·uint32_t·ret)

219

static·inline·void·_nocheck__trace_rc4030_write(uint64_t·addr,·uint32_t·val)

219

static·inline·void·_nocheck__trace_rc4030_write(uint64_t·addr,·uint32_t·val)

220

{

220

{

221

····if·(trace_event_get_state(TRACE_RC4030_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

221

····if·(trace_event_get_state(TRACE_RC4030_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

222

········if·(message_with_timestamp)·{

222

········if·(message_with_timestamp)·{

223

············struct·timeval·_now;

223

············struct·timeval·_now;

224

············gettimeofday(&_now,·NULL);

224

············gettimeofday(&_now,·NULL);

226

············qemu_log("%d@%zu.%06zu:rc4030_write·"·"write·reg[0x%"PRIx64"]·=·0x%x"·"\n",

226

············qemu_log("%d@%zu.%06zu:rc4030_write·"·"write·reg[0x%"PRIx64"]·=·0x%x"·"\n",

227

·····················qemu_get_thread_id(),

227

·····················qemu_get_thread_id(),

228

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

228

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

229

·····················,·addr,·val);

229

·····················,·addr,·val);

230

#line·232·"trace/trace-hw_dma.h"

230

#line·232·"trace/trace-hw_dma.h"

231

········}·else·{

231

········}·else·{

233

············qemu_log("rc4030_write·"·"write·reg[0x%"PRIx64"]·=·0x%x"·"\n",·addr,·val);

233

············qemu_log("rc4030_write·"·"write·reg[0x%"PRIx64"]·=·0x%x"·"\n",·addr,·val);

234

#line·236·"trace/trace-hw_dma.h"

234

#line·236·"trace/trace-hw_dma.h"

235

········}

235

········}

236

····}

236

····}

237

}

237

}

238

static·inline·void·trace_rc4030_write(uint64_t·addr,·uint32_t·val)

238

static·inline·void·trace_rc4030_write(uint64_t·addr,·uint32_t·val)

250

static·inline·void·_nocheck__trace_ledma_memory_read(uint64_t·addr,·int·len)

250

static·inline·void·_nocheck__trace_ledma_memory_read(uint64_t·addr,·int·len)

251

{

251

{

252

····if·(trace_event_get_state(TRACE_LEDMA_MEMORY_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

252

····if·(trace_event_get_state(TRACE_LEDMA_MEMORY_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

253

········if·(message_with_timestamp)·{

253

········if·(message_with_timestamp)·{

254

············struct·timeval·_now;

254

············struct·timeval·_now;

255

············gettimeofday(&_now,·NULL);

255

············gettimeofday(&_now,·NULL);

257

············qemu_log("%d@%zu.%06zu:ledma_memory_read·"·"DMA·read·addr·0x%"PRIx64·"·len·%d"·"\n",

257

············qemu_log("%d@%zu.%06zu:ledma_memory_read·"·"DMA·read·addr·0x%"PRIx64·"·len·%d"·"\n",

258

·····················qemu_get_thread_id(),

258

·····················qemu_get_thread_id(),

259

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

259

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

260

·····················,·addr,·len);

260

·····················,·addr,·len);

261

#line·263·"trace/trace-hw_dma.h"

261

#line·263·"trace/trace-hw_dma.h"

262

········}·else·{

262

········}·else·{

264

············qemu_log("ledma_memory_read·"·"DMA·read·addr·0x%"PRIx64·"·len·%d"·"\n",·addr,·len);

264

············qemu_log("ledma_memory_read·"·"DMA·read·addr·0x%"PRIx64·"·len·%d"·"\n",·addr,·len);

265

#line·267·"trace/trace-hw_dma.h"

265

#line·267·"trace/trace-hw_dma.h"

266

········}

266

········}

267

····}

267

····}

268

}

268

}

269

static·inline·void·trace_ledma_memory_read(uint64_t·addr,·int·len)

269

static·inline·void·trace_ledma_memory_read(uint64_t·addr,·int·len)

281

static·inline·void·_nocheck__trace_ledma_memory_write(uint64_t·addr,·int·len)

281

static·inline·void·_nocheck__trace_ledma_memory_write(uint64_t·addr,·int·len)

282

{

282

{

283

····if·(trace_event_get_state(TRACE_LEDMA_MEMORY_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

283

····if·(trace_event_get_state(TRACE_LEDMA_MEMORY_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

284

········if·(message_with_timestamp)·{

284

········if·(message_with_timestamp)·{

285

············struct·timeval·_now;

285

············struct·timeval·_now;

286

············gettimeofday(&_now,·NULL);

286

············gettimeofday(&_now,·NULL);

288

············qemu_log("%d@%zu.%06zu:ledma_memory_write·"·"DMA·write·addr·0x%"PRIx64·"·len·%d"·"\n",

288

············qemu_log("%d@%zu.%06zu:ledma_memory_write·"·"DMA·write·addr·0x%"PRIx64·"·len·%d"·"\n",

289

·····················qemu_get_thread_id(),

289

·····················qemu_get_thread_id(),

290

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

290

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

291

·····················,·addr,·len);

291

·····················,·addr,·len);

292

#line·294·"trace/trace-hw_dma.h"

292

#line·294·"trace/trace-hw_dma.h"

293

········}·else·{

293

········}·else·{

295

············qemu_log("ledma_memory_write·"·"DMA·write·addr·0x%"PRIx64·"·len·%d"·"\n",·addr,·len);

295

············qemu_log("ledma_memory_write·"·"DMA·write·addr·0x%"PRIx64·"·len·%d"·"\n",·addr,·len);

296

#line·298·"trace/trace-hw_dma.h"

296

#line·298·"trace/trace-hw_dma.h"

297

········}

297

········}

298

····}

298

····}

299

}

299

}

300

static·inline·void·trace_ledma_memory_write(uint64_t·addr,·int·len)

300

static·inline·void·trace_ledma_memory_write(uint64_t·addr,·int·len)

312

static·inline·void·_nocheck__trace_sparc32_dma_set_irq_raise(void)

312

static·inline·void·_nocheck__trace_sparc32_dma_set_irq_raise(void)

313

{

313

{

314

····if·(trace_event_get_state(TRACE_SPARC32_DMA_SET_IRQ_RAISE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

314

····if·(trace_event_get_state(TRACE_SPARC32_DMA_SET_IRQ_RAISE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

315

········if·(message_with_timestamp)·{

315

········if·(message_with_timestamp)·{

316

············struct·timeval·_now;

316

············struct·timeval·_now;

317

············gettimeofday(&_now,·NULL);

317

············gettimeofday(&_now,·NULL);

319

············qemu_log("%d@%zu.%06zu:sparc32_dma_set_irq_raise·"·"Raise·IRQ"·"\n",

319

············qemu_log("%d@%zu.%06zu:sparc32_dma_set_irq_raise·"·"Raise·IRQ"·"\n",

320

·····················qemu_get_thread_id(),

320

·····················qemu_get_thread_id(),

321

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

321

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

322

·····················);

322

·····················);

323

#line·325·"trace/trace-hw_dma.h"

323

#line·325·"trace/trace-hw_dma.h"

324

········}·else·{

324

········}·else·{

326

············qemu_log("sparc32_dma_set_irq_raise·"·"Raise·IRQ"·"\n");

326

············qemu_log("sparc32_dma_set_irq_raise·"·"Raise·IRQ"·"\n");

327

#line·329·"trace/trace-hw_dma.h"

327

#line·329·"trace/trace-hw_dma.h"

328

········}

328

········}

329

····}

329

····}

330

}

330

}

331

static·inline·void·trace_sparc32_dma_set_irq_raise(void)

331

static·inline·void·trace_sparc32_dma_set_irq_raise(void)

343

static·inline·void·_nocheck__trace_sparc32_dma_set_irq_lower(void)

343

static·inline·void·_nocheck__trace_sparc32_dma_set_irq_lower(void)

344

{

344

{

345

····if·(trace_event_get_state(TRACE_SPARC32_DMA_SET_IRQ_LOWER)·&&·qemu_loglevel_mask(LOG_TRACE))·{

345

····if·(trace_event_get_state(TRACE_SPARC32_DMA_SET_IRQ_LOWER)·&&·qemu_loglevel_mask(LOG_TRACE))·{

346

········if·(message_with_timestamp)·{

346

········if·(message_with_timestamp)·{

347

············struct·timeval·_now;

347

············struct·timeval·_now;

348

············gettimeofday(&_now,·NULL);

348

············gettimeofday(&_now,·NULL);

350

············qemu_log("%d@%zu.%06zu:sparc32_dma_set_irq_lower·"·"Lower·IRQ"·"\n",

350

············qemu_log("%d@%zu.%06zu:sparc32_dma_set_irq_lower·"·"Lower·IRQ"·"\n",

351

·····················qemu_get_thread_id(),

351

·····················qemu_get_thread_id(),

352

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

352

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

353

·····················);

353

·····················);

354

#line·356·"trace/trace-hw_dma.h"

354

#line·356·"trace/trace-hw_dma.h"

355

········}·else·{

355

········}·else·{

357

············qemu_log("sparc32_dma_set_irq_lower·"·"Lower·IRQ"·"\n");

357

············qemu_log("sparc32_dma_set_irq_lower·"·"Lower·IRQ"·"\n");

358

#line·360·"trace/trace-hw_dma.h"

358

#line·360·"trace/trace-hw_dma.h"

359

········}

359

········}

360

····}

360

····}

361

}

361

}

362

static·inline·void·trace_sparc32_dma_set_irq_lower(void)

362

static·inline·void·trace_sparc32_dma_set_irq_lower(void)

374

static·inline·void·_nocheck__trace_espdma_memory_read(uint32_t·addr,·int·len)

374

static·inline·void·_nocheck__trace_espdma_memory_read(uint32_t·addr,·int·len)

375

{

375

{

376

····if·(trace_event_get_state(TRACE_ESPDMA_MEMORY_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

376

····if·(trace_event_get_state(TRACE_ESPDMA_MEMORY_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

377

········if·(message_with_timestamp)·{

377

········if·(message_with_timestamp)·{

378

············struct·timeval·_now;

378

············struct·timeval·_now;

379

············gettimeofday(&_now,·NULL);

379

············gettimeofday(&_now,·NULL);

381

············qemu_log("%d@%zu.%06zu:espdma_memory_read·"·"DMA·read·addr·0x%08x·len·%d"·"\n",

381

············qemu_log("%d@%zu.%06zu:espdma_memory_read·"·"DMA·read·addr·0x%08x·len·%d"·"\n",

382

·····················qemu_get_thread_id(),

382

·····················qemu_get_thread_id(),

383

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

383

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

384

·····················,·addr,·len);

384

·····················,·addr,·len);

385

#line·387·"trace/trace-hw_dma.h"

385

#line·387·"trace/trace-hw_dma.h"

386

········}·else·{

386

········}·else·{

388

············qemu_log("espdma_memory_read·"·"DMA·read·addr·0x%08x·len·%d"·"\n",·addr,·len);

388

············qemu_log("espdma_memory_read·"·"DMA·read·addr·0x%08x·len·%d"·"\n",·addr,·len);

389

#line·391·"trace/trace-hw_dma.h"

389

#line·391·"trace/trace-hw_dma.h"

390

········}

390

········}

391

····}

391

····}

392

}

392

}

393

static·inline·void·trace_espdma_memory_read(uint32_t·addr,·int·len)

393

static·inline·void·trace_espdma_memory_read(uint32_t·addr,·int·len)

405

static·inline·void·_nocheck__trace_espdma_memory_write(uint32_t·addr,·int·len)

405

static·inline·void·_nocheck__trace_espdma_memory_write(uint32_t·addr,·int·len)

406

{

406

{

407

····if·(trace_event_get_state(TRACE_ESPDMA_MEMORY_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

407

····if·(trace_event_get_state(TRACE_ESPDMA_MEMORY_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

408

········if·(message_with_timestamp)·{

408

········if·(message_with_timestamp)·{

409

············struct·timeval·_now;

409

············struct·timeval·_now;

410

············gettimeofday(&_now,·NULL);

410

············gettimeofday(&_now,·NULL);

412

············qemu_log("%d@%zu.%06zu:espdma_memory_write·"·"DMA·write·addr·0x%08x·len·%d"·"\n",

412

············qemu_log("%d@%zu.%06zu:espdma_memory_write·"·"DMA·write·addr·0x%08x·len·%d"·"\n",

413

·····················qemu_get_thread_id(),

413

·····················qemu_get_thread_id(),

414

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

414

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

415

·····················,·addr,·len);

415

·····················,·addr,·len);

416

#line·418·"trace/trace-hw_dma.h"

416

#line·418·"trace/trace-hw_dma.h"

417

········}·else·{

417

········}·else·{

419

············qemu_log("espdma_memory_write·"·"DMA·write·addr·0x%08x·len·%d"·"\n",·addr,·len);

419

············qemu_log("espdma_memory_write·"·"DMA·write·addr·0x%08x·len·%d"·"\n",·addr,·len);

420

#line·422·"trace/trace-hw_dma.h"

420

#line·422·"trace/trace-hw_dma.h"

421

········}

421

········}

422

····}

422

····}

423

}

423

}

424

static·inline·void·trace_espdma_memory_write(uint32_t·addr,·int·len)

424

static·inline·void·trace_espdma_memory_write(uint32_t·addr,·int·len)

436

static·inline·void·_nocheck__trace_sparc32_dma_mem_readl(uint64_t·addr,·uint32_t·ret)

436

static·inline·void·_nocheck__trace_sparc32_dma_mem_readl(uint64_t·addr,·uint32_t·ret)

437

{

437

{

438

····if·(trace_event_get_state(TRACE_SPARC32_DMA_MEM_READL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

438

····if·(trace_event_get_state(TRACE_SPARC32_DMA_MEM_READL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

439

········if·(message_with_timestamp)·{

439

········if·(message_with_timestamp)·{

440

············struct·timeval·_now;

440

············struct·timeval·_now;

441

············gettimeofday(&_now,·NULL);

441

············gettimeofday(&_now,·NULL);

443

············qemu_log("%d@%zu.%06zu:sparc32_dma_mem_readl·"·"read·dmareg·0x%"PRIx64":·0x%08x"·"\n",

443

············qemu_log("%d@%zu.%06zu:sparc32_dma_mem_readl·"·"read·dmareg·0x%"PRIx64":·0x%08x"·"\n",

444

·····················qemu_get_thread_id(),

444

·····················qemu_get_thread_id(),

445

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

445

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

446

·····················,·addr,·ret);

446

·····················,·addr,·ret);

447

#line·449·"trace/trace-hw_dma.h"

447

#line·449·"trace/trace-hw_dma.h"

448

········}·else·{

448

········}·else·{

450

············qemu_log("sparc32_dma_mem_readl·"·"read·dmareg·0x%"PRIx64":·0x%08x"·"\n",·addr,·ret);

450

············qemu_log("sparc32_dma_mem_readl·"·"read·dmareg·0x%"PRIx64":·0x%08x"·"\n",·addr,·ret);

451

#line·453·"trace/trace-hw_dma.h"

451

#line·453·"trace/trace-hw_dma.h"

452

········}

452

········}

453

····}

453

····}

454

}

454

}

455

static·inline·void·trace_sparc32_dma_mem_readl(uint64_t·addr,·uint32_t·ret)

455

static·inline·void·trace_sparc32_dma_mem_readl(uint64_t·addr,·uint32_t·ret)

467

static·inline·void·_nocheck__trace_sparc32_dma_mem_writel(uint64_t·addr,·uint32_t·old,·uint32_t·val)

467

static·inline·void·_nocheck__trace_sparc32_dma_mem_writel(uint64_t·addr,·uint32_t·old,·uint32_t·val)

468

{

468

{

469

····if·(trace_event_get_state(TRACE_SPARC32_DMA_MEM_WRITEL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

469

····if·(trace_event_get_state(TRACE_SPARC32_DMA_MEM_WRITEL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

470

········if·(message_with_timestamp)·{

470

········if·(message_with_timestamp)·{

471

············struct·timeval·_now;

471

············struct·timeval·_now;

472

············gettimeofday(&_now,·NULL);

472

············gettimeofday(&_now,·NULL);

474

············qemu_log("%d@%zu.%06zu:sparc32_dma_mem_writel·"·"write·dmareg·0x%"PRIx64":·0x%08x·->·0x%08x"·"\n",

474

············qemu_log("%d@%zu.%06zu:sparc32_dma_mem_writel·"·"write·dmareg·0x%"PRIx64":·0x%08x·->·0x%08x"·"\n",

475

·····················qemu_get_thread_id(),

475

·····················qemu_get_thread_id(),

476

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

476

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

477

·····················,·addr,·old,·val);

477

·····················,·addr,·old,·val);

478

#line·480·"trace/trace-hw_dma.h"

478

#line·480·"trace/trace-hw_dma.h"

479

········}·else·{

479

········}·else·{

481

············qemu_log("sparc32_dma_mem_writel·"·"write·dmareg·0x%"PRIx64":·0x%08x·->·0x%08x"·"\n",·addr,·old,·val);

481

············qemu_log("sparc32_dma_mem_writel·"·"write·dmareg·0x%"PRIx64":·0x%08x·->·0x%08x"·"\n",·addr,·old,·val);

482

#line·484·"trace/trace-hw_dma.h"

482

#line·484·"trace/trace-hw_dma.h"

483

········}

483

········}

484

····}

484

····}

485

}

485

}

486

static·inline·void·trace_sparc32_dma_mem_writel(uint64_t·addr,·uint32_t·old,·uint32_t·val)

486

static·inline·void·trace_sparc32_dma_mem_writel(uint64_t·addr,·uint32_t·old,·uint32_t·val)

498

static·inline·void·_nocheck__trace_sparc32_dma_enable_raise(void)

498

static·inline·void·_nocheck__trace_sparc32_dma_enable_raise(void)

499

{

499

{

500

····if·(trace_event_get_state(TRACE_SPARC32_DMA_ENABLE_RAISE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

500

····if·(trace_event_get_state(TRACE_SPARC32_DMA_ENABLE_RAISE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

501

········if·(message_with_timestamp)·{

501

········if·(message_with_timestamp)·{

502

············struct·timeval·_now;

502

············struct·timeval·_now;

503

············gettimeofday(&_now,·NULL);

503

············gettimeofday(&_now,·NULL);

505

············qemu_log("%d@%zu.%06zu:sparc32_dma_enable_raise·"·"Raise·DMA·enable"·"\n",

505

············qemu_log("%d@%zu.%06zu:sparc32_dma_enable_raise·"·"Raise·DMA·enable"·"\n",

506

·····················qemu_get_thread_id(),

506

·····················qemu_get_thread_id(),

507

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

507

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

508

·····················);

508

·····················);

509

#line·511·"trace/trace-hw_dma.h"

509

#line·511·"trace/trace-hw_dma.h"

510

········}·else·{

510

········}·else·{

512

············qemu_log("sparc32_dma_enable_raise·"·"Raise·DMA·enable"·"\n");

512

············qemu_log("sparc32_dma_enable_raise·"·"Raise·DMA·enable"·"\n");

513

#line·515·"trace/trace-hw_dma.h"

513

#line·515·"trace/trace-hw_dma.h"

514

········}

514

········}

515

····}

515

····}

516

}

516

}

517

static·inline·void·trace_sparc32_dma_enable_raise(void)

517

static·inline·void·trace_sparc32_dma_enable_raise(void)

529

static·inline·void·_nocheck__trace_sparc32_dma_enable_lower(void)

529

static·inline·void·_nocheck__trace_sparc32_dma_enable_lower(void)

530

{

530

{

531

····if·(trace_event_get_state(TRACE_SPARC32_DMA_ENABLE_LOWER)·&&·qemu_loglevel_mask(LOG_TRACE))·{

531

····if·(trace_event_get_state(TRACE_SPARC32_DMA_ENABLE_LOWER)·&&·qemu_loglevel_mask(LOG_TRACE))·{

532

········if·(message_with_timestamp)·{

532

········if·(message_with_timestamp)·{

533

············struct·timeval·_now;

533

············struct·timeval·_now;

534

············gettimeofday(&_now,·NULL);

534

············gettimeofday(&_now,·NULL);

536

············qemu_log("%d@%zu.%06zu:sparc32_dma_enable_lower·"·"Lower·DMA·enable"·"\n",

536

············qemu_log("%d@%zu.%06zu:sparc32_dma_enable_lower·"·"Lower·DMA·enable"·"\n",

537

·····················qemu_get_thread_id(),

537

·····················qemu_get_thread_id(),

538

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

538

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

539

·····················);

539

·····················);

540

#line·542·"trace/trace-hw_dma.h"

540

#line·542·"trace/trace-hw_dma.h"

541

········}·else·{

541

········}·else·{

543

············qemu_log("sparc32_dma_enable_lower·"·"Lower·DMA·enable"·"\n");

543

············qemu_log("sparc32_dma_enable_lower·"·"Lower·DMA·enable"·"\n");

544

#line·546·"trace/trace-hw_dma.h"

544

#line·546·"trace/trace-hw_dma.h"

545

········}

545

········}

546

····}

546

····}

547

}

547

}

548

static·inline·void·trace_sparc32_dma_enable_lower(void)

548

static·inline·void·trace_sparc32_dma_enable_lower(void)

560

static·inline·void·_nocheck__trace_i8257_unregistered_dma(int·nchan,·int·dma_pos,·int·dma_len)

560

static·inline·void·_nocheck__trace_i8257_unregistered_dma(int·nchan,·int·dma_pos,·int·dma_len)

561

{

561

{

562

····if·(trace_event_get_state(TRACE_I8257_UNREGISTERED_DMA)·&&·qemu_loglevel_mask(LOG_TRACE))·{

562

····if·(trace_event_get_state(TRACE_I8257_UNREGISTERED_DMA)·&&·qemu_loglevel_mask(LOG_TRACE))·{

563

········if·(message_with_timestamp)·{

563

········if·(message_with_timestamp)·{

564

············struct·timeval·_now;

564

············struct·timeval·_now;

565

············gettimeofday(&_now,·NULL);

565

············gettimeofday(&_now,·NULL);

567

············qemu_log("%d@%zu.%06zu:i8257_unregistered_dma·"·"unregistered·DMA·channel·used·nchan=%d·dma_pos=%d·dma_len=%d"·"\n",

567

············qemu_log("%d@%zu.%06zu:i8257_unregistered_dma·"·"unregistered·DMA·channel·used·nchan=%d·dma_pos=%d·dma_len=%d"·"\n",

568

·····················qemu_get_thread_id(),

568

·····················qemu_get_thread_id(),

569

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

569

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

570

·····················,·nchan,·dma_pos,·dma_len);

570

·····················,·nchan,·dma_pos,·dma_len);

571

#line·573·"trace/trace-hw_dma.h"

571

#line·573·"trace/trace-hw_dma.h"

572

········}·else·{

572

········}·else·{

574

············qemu_log("i8257_unregistered_dma·"·"unregistered·DMA·channel·used·nchan=%d·dma_pos=%d·dma_len=%d"·"\n",·nchan,·dma_pos,·dma_len);

574

············qemu_log("i8257_unregistered_dma·"·"unregistered·DMA·channel·used·nchan=%d·dma_pos=%d·dma_len=%d"·"\n",·nchan,·dma_pos,·dma_len);

575

#line·577·"trace/trace-hw_dma.h"

575

#line·577·"trace/trace-hw_dma.h"

576

········}

576

········}

577

····}

577

····}

578

}

578

}

579

static·inline·void·trace_i8257_unregistered_dma(int·nchan,·int·dma_pos,·int·dma_len)

579

static·inline·void·trace_i8257_unregistered_dma(int·nchan,·int·dma_pos,·int·dma_len)

591

static·inline·void·_nocheck__trace_pl330_fault(void·*·ptr,·uint32_t·flags)

591

static·inline·void·_nocheck__trace_pl330_fault(void·*·ptr,·uint32_t·flags)

592

{

592

{

593

····if·(trace_event_get_state(TRACE_PL330_FAULT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

593

····if·(trace_event_get_state(TRACE_PL330_FAULT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

594

········if·(message_with_timestamp)·{

594

········if·(message_with_timestamp)·{

595

············struct·timeval·_now;

595

············struct·timeval·_now;

596

············gettimeofday(&_now,·NULL);

596

············gettimeofday(&_now,·NULL);

598

············qemu_log("%d@%zu.%06zu:pl330_fault·"·"ch:·%p,·flags:·0x%"PRIx32·"\n",

598

············qemu_log("%d@%zu.%06zu:pl330_fault·"·"ch:·%p,·flags:·0x%"PRIx32·"\n",

599

·····················qemu_get_thread_id(),

599

·····················qemu_get_thread_id(),

600

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

600

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

601

·····················,·ptr,·flags);

601

·····················,·ptr,·flags);

602

#line·604·"trace/trace-hw_dma.h"

602

#line·604·"trace/trace-hw_dma.h"

603

········}·else·{

603

········}·else·{

605

············qemu_log("pl330_fault·"·"ch:·%p,·flags:·0x%"PRIx32·"\n",·ptr,·flags);

605

············qemu_log("pl330_fault·"·"ch:·%p,·flags:·0x%"PRIx32·"\n",·ptr,·flags);

606

#line·608·"trace/trace-hw_dma.h"

606

#line·608·"trace/trace-hw_dma.h"

607

········}

607

········}

608

····}

608

····}

609

}

609

}

610

static·inline·void·trace_pl330_fault(void·*·ptr,·uint32_t·flags)

610

static·inline·void·trace_pl330_fault(void·*·ptr,·uint32_t·flags)

622

static·inline·void·_nocheck__trace_pl330_fault_abort(void)

622

static·inline·void·_nocheck__trace_pl330_fault_abort(void)

623

{

623

{

624

····if·(trace_event_get_state(TRACE_PL330_FAULT_ABORT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

624

····if·(trace_event_get_state(TRACE_PL330_FAULT_ABORT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

625

········if·(message_with_timestamp)·{

625

········if·(message_with_timestamp)·{

626

············struct·timeval·_now;

626

············struct·timeval·_now;

627

············gettimeofday(&_now,·NULL);

627

············gettimeofday(&_now,·NULL);

629

············qemu_log("%d@%zu.%06zu:pl330_fault_abort·"·"abort·interrupt·raised"·"\n",

629

············qemu_log("%d@%zu.%06zu:pl330_fault_abort·"·"abort·interrupt·raised"·"\n",

630

·····················qemu_get_thread_id(),

630

·····················qemu_get_thread_id(),

631

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

631

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

632

·····················);

632

·····················);

633

#line·635·"trace/trace-hw_dma.h"

633

#line·635·"trace/trace-hw_dma.h"

634

········}·else·{

634

········}·else·{

636

············qemu_log("pl330_fault_abort·"·"abort·interrupt·raised"·"\n");

636

············qemu_log("pl330_fault_abort·"·"abort·interrupt·raised"·"\n");

637

#line·639·"trace/trace-hw_dma.h"

637

#line·639·"trace/trace-hw_dma.h"

638

········}

638

········}

639

····}

639

····}

640

}

640

}

641

static·inline·void·trace_pl330_fault_abort(void)

641

static·inline·void·trace_pl330_fault_abort(void)

653

static·inline·void·_nocheck__trace_pl330_dmaend(void)

653

static·inline·void·_nocheck__trace_pl330_dmaend(void)

654

{

654

{

655

····if·(trace_event_get_state(TRACE_PL330_DMAEND)·&&·qemu_loglevel_mask(LOG_TRACE))·{

655

····if·(trace_event_get_state(TRACE_PL330_DMAEND)·&&·qemu_loglevel_mask(LOG_TRACE))·{

656

········if·(message_with_timestamp)·{

656

········if·(message_with_timestamp)·{

657

············struct·timeval·_now;

657

············struct·timeval·_now;

658

············gettimeofday(&_now,·NULL);

658

············gettimeofday(&_now,·NULL);

660

············qemu_log("%d@%zu.%06zu:pl330_dmaend·"·"DMA·ending"·"\n",

660

············qemu_log("%d@%zu.%06zu:pl330_dmaend·"·"DMA·ending"·"\n",

661

·····················qemu_get_thread_id(),

661

·····················qemu_get_thread_id(),

662

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

662

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

663

·····················);

663

·····················);

664

#line·666·"trace/trace-hw_dma.h"

664

#line·666·"trace/trace-hw_dma.h"

665

········}·else·{

665

········}·else·{

667

············qemu_log("pl330_dmaend·"·"DMA·ending"·"\n");

667

············qemu_log("pl330_dmaend·"·"DMA·ending"·"\n");

668

#line·670·"trace/trace-hw_dma.h"

668

#line·670·"trace/trace-hw_dma.h"

669

········}

669

········}

670

····}

670

····}

671

}

671

}

672

static·inline·void·trace_pl330_dmaend(void)

672

static·inline·void·trace_pl330_dmaend(void)

684

static·inline·void·_nocheck__trace_pl330_dmago(void)

684

static·inline·void·_nocheck__trace_pl330_dmago(void)

685

{

685

{

686

····if·(trace_event_get_state(TRACE_PL330_DMAGO)·&&·qemu_loglevel_mask(LOG_TRACE))·{

686

····if·(trace_event_get_state(TRACE_PL330_DMAGO)·&&·qemu_loglevel_mask(LOG_TRACE))·{

687

········if·(message_with_timestamp)·{

687

········if·(message_with_timestamp)·{

688

············struct·timeval·_now;

688

············struct·timeval·_now;

689

············gettimeofday(&_now,·NULL);

689

············gettimeofday(&_now,·NULL);

691

············qemu_log("%d@%zu.%06zu:pl330_dmago·"·"DMA·run"·"\n",

691

············qemu_log("%d@%zu.%06zu:pl330_dmago·"·"DMA·run"·"\n",

692

·····················qemu_get_thread_id(),

692

·····················qemu_get_thread_id(),

693

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

693

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

694

·····················);

694

·····················);

695

#line·697·"trace/trace-hw_dma.h"

695

#line·697·"trace/trace-hw_dma.h"

696

········}·else·{

696

········}·else·{

698

············qemu_log("pl330_dmago·"·"DMA·run"·"\n");

698

············qemu_log("pl330_dmago·"·"DMA·run"·"\n");

699

#line·701·"trace/trace-hw_dma.h"

699

#line·701·"trace/trace-hw_dma.h"

700

········}

700

········}

701

····}

701

····}

702

}

702

}

703

static·inline·void·trace_pl330_dmago(void)

703

static·inline·void·trace_pl330_dmago(void)

715

static·inline·void·_nocheck__trace_pl330_dmald(uint8_t·chan,·uint32_t·addr,·uint32_t·size,·uint32_t·num,·char·ch)

715

static·inline·void·_nocheck__trace_pl330_dmald(uint8_t·chan,·uint32_t·addr,·uint32_t·size,·uint32_t·num,·char·ch)

716

{

716

{

717

····if·(trace_event_get_state(TRACE_PL330_DMALD)·&&·qemu_loglevel_mask(LOG_TRACE))·{

717

····if·(trace_event_get_state(TRACE_PL330_DMALD)·&&·qemu_loglevel_mask(LOG_TRACE))·{

718

········if·(message_with_timestamp)·{

718

········if·(message_with_timestamp)·{

719

············struct·timeval·_now;

719

············struct·timeval·_now;

720

············gettimeofday(&_now,·NULL);

720

············gettimeofday(&_now,·NULL);

722

············qemu_log("%d@%zu.%06zu:pl330_dmald·"·"channel:%"PRId8"·address:0x%08"PRIx32"·size:0x%"PRIx32"·num:%"PRId32"%c"·"\n",

722

············qemu_log("%d@%zu.%06zu:pl330_dmald·"·"channel:%"PRId8"·address:0x%08"PRIx32"·size:0x%"PRIx32"·num:%"PRId32"%c"·"\n",

723

·····················qemu_get_thread_id(),

723

·····················qemu_get_thread_id(),

724

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

724

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

725

·····················,·chan,·addr,·size,·num,·ch);

725

·····················,·chan,·addr,·size,·num,·ch);

726

#line·728·"trace/trace-hw_dma.h"

726

#line·728·"trace/trace-hw_dma.h"

727

········}·else·{

727

········}·else·{

729

············qemu_log("pl330_dmald·"·"channel:%"PRId8"·address:0x%08"PRIx32"·size:0x%"PRIx32"·num:%"PRId32"%c"·"\n",·chan,·addr,·size,·num,·ch);

729

············qemu_log("pl330_dmald·"·"channel:%"PRId8"·address:0x%08"PRIx32"·size:0x%"PRIx32"·num:%"PRId32"%c"·"\n",·chan,·addr,·size,·num,·ch);

730

#line·732·"trace/trace-hw_dma.h"

730

#line·732·"trace/trace-hw_dma.h"

731

········}

731

········}

732

····}

732

····}

733

}

733

}

734

static·inline·void·trace_pl330_dmald(uint8_t·chan,·uint32_t·addr,·uint32_t·size,·uint32_t·num,·char·ch)

734

static·inline·void·trace_pl330_dmald(uint8_t·chan,·uint32_t·addr,·uint32_t·size,·uint32_t·num,·char·ch)

746

static·inline·void·_nocheck__trace_pl330_dmakill(void)

746

static·inline·void·_nocheck__trace_pl330_dmakill(void)

747

{

747

{

748

····if·(trace_event_get_state(TRACE_PL330_DMAKILL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

748

····if·(trace_event_get_state(TRACE_PL330_DMAKILL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

749

········if·(message_with_timestamp)·{

749

········if·(message_with_timestamp)·{

750

············struct·timeval·_now;

750

············struct·timeval·_now;

751

············gettimeofday(&_now,·NULL);

751

············gettimeofday(&_now,·NULL);

753

············qemu_log("%d@%zu.%06zu:pl330_dmakill·"·"abort·interrupt·lowered"·"\n",

753

············qemu_log("%d@%zu.%06zu:pl330_dmakill·"·"abort·interrupt·lowered"·"\n",

754

·····················qemu_get_thread_id(),

754

·····················qemu_get_thread_id(),

755

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

755

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

756

·····················);

756

·····················);

757

#line·759·"trace/trace-hw_dma.h"

757

#line·759·"trace/trace-hw_dma.h"

758

········}·else·{

758

········}·else·{

760

············qemu_log("pl330_dmakill·"·"abort·interrupt·lowered"·"\n");

760

············qemu_log("pl330_dmakill·"·"abort·interrupt·lowered"·"\n");

761

#line·763·"trace/trace-hw_dma.h"

761

#line·763·"trace/trace-hw_dma.h"

762

········}

762

········}

763

····}

763

····}

764

}

764

}

765

static·inline·void·trace_pl330_dmakill(void)

765

static·inline·void·trace_pl330_dmakill(void)

777

static·inline·void·_nocheck__trace_pl330_dmalpend(uint8_t·nf,·uint8_t·bs,·uint8_t·lc,·uint8_t·ch,·uint8_t·flag)

777

static·inline·void·_nocheck__trace_pl330_dmalpend(uint8_t·nf,·uint8_t·bs,·uint8_t·lc,·uint8_t·ch,·uint8_t·flag)

778

{

778

{

779

····if·(trace_event_get_state(TRACE_PL330_DMALPEND)·&&·qemu_loglevel_mask(LOG_TRACE))·{

779

····if·(trace_event_get_state(TRACE_PL330_DMALPEND)·&&·qemu_loglevel_mask(LOG_TRACE))·{

780

········if·(message_with_timestamp)·{

780

········if·(message_with_timestamp)·{

781

············struct·timeval·_now;

781

············struct·timeval·_now;

782

············gettimeofday(&_now,·NULL);

782

············gettimeofday(&_now,·NULL);

784

············qemu_log("%d@%zu.%06zu:pl330_dmalpend·"·"nf=0x%02x·bs=0x%02x·lc=0x%02x·ch=0x%02x·flag=0x%02x"·"\n",

784

············qemu_log("%d@%zu.%06zu:pl330_dmalpend·"·"nf=0x%02x·bs=0x%02x·lc=0x%02x·ch=0x%02x·flag=0x%02x"·"\n",

785

·····················qemu_get_thread_id(),

785

·····················qemu_get_thread_id(),

786

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

786

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

787

·····················,·nf,·bs,·lc,·ch,·flag);

787

·····················,·nf,·bs,·lc,·ch,·flag);

788

#line·790·"trace/trace-hw_dma.h"

788

#line·790·"trace/trace-hw_dma.h"

789

········}·else·{

789

········}·else·{

791

············qemu_log("pl330_dmalpend·"·"nf=0x%02x·bs=0x%02x·lc=0x%02x·ch=0x%02x·flag=0x%02x"·"\n",·nf,·bs,·lc,·ch,·flag);

791

············qemu_log("pl330_dmalpend·"·"nf=0x%02x·bs=0x%02x·lc=0x%02x·ch=0x%02x·flag=0x%02x"·"\n",·nf,·bs,·lc,·ch,·flag);

792

#line·794·"trace/trace-hw_dma.h"

792

#line·794·"trace/trace-hw_dma.h"

793

········}

793

········}

794

····}

794

····}

795

}

795

}

796

static·inline·void·trace_pl330_dmalpend(uint8_t·nf,·uint8_t·bs,·uint8_t·lc,·uint8_t·ch,·uint8_t·flag)

796

static·inline·void·trace_pl330_dmalpend(uint8_t·nf,·uint8_t·bs,·uint8_t·lc,·uint8_t·ch,·uint8_t·flag)

808

static·inline·void·_nocheck__trace_pl330_dmalpiter(void)

808

static·inline·void·_nocheck__trace_pl330_dmalpiter(void)

809

{

809

{

810

····if·(trace_event_get_state(TRACE_PL330_DMALPITER)·&&·qemu_loglevel_mask(LOG_TRACE))·{

810

····if·(trace_event_get_state(TRACE_PL330_DMALPITER)·&&·qemu_loglevel_mask(LOG_TRACE))·{

811

········if·(message_with_timestamp)·{

811

········if·(message_with_timestamp)·{

812

············struct·timeval·_now;

812

············struct·timeval·_now;

813

············gettimeofday(&_now,·NULL);

813

············gettimeofday(&_now,·NULL);

815

············qemu_log("%d@%zu.%06zu:pl330_dmalpiter·"·"loop·reiteration"·"\n",

815

············qemu_log("%d@%zu.%06zu:pl330_dmalpiter·"·"loop·reiteration"·"\n",

816

·····················qemu_get_thread_id(),

816

·····················qemu_get_thread_id(),

817

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

817

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

818

·····················);

818

·····················);

819

#line·821·"trace/trace-hw_dma.h"

819

#line·821·"trace/trace-hw_dma.h"

820

········}·else·{

820

········}·else·{

822

············qemu_log("pl330_dmalpiter·"·"loop·reiteration"·"\n");

822

············qemu_log("pl330_dmalpiter·"·"loop·reiteration"·"\n");

823

#line·825·"trace/trace-hw_dma.h"

823

#line·825·"trace/trace-hw_dma.h"

824

········}

824

········}

825

····}

825

····}

826

}

826

}

827

static·inline·void·trace_pl330_dmalpiter(void)

827

static·inline·void·trace_pl330_dmalpiter(void)

839

static·inline·void·_nocheck__trace_pl330_dmalpfallthrough(void)

839

static·inline·void·_nocheck__trace_pl330_dmalpfallthrough(void)

840

{

840

{

841

····if·(trace_event_get_state(TRACE_PL330_DMALPFALLTHROUGH)·&&·qemu_loglevel_mask(LOG_TRACE))·{

841

····if·(trace_event_get_state(TRACE_PL330_DMALPFALLTHROUGH)·&&·qemu_loglevel_mask(LOG_TRACE))·{

842

········if·(message_with_timestamp)·{

842

········if·(message_with_timestamp)·{

843

············struct·timeval·_now;

843

············struct·timeval·_now;

844

············gettimeofday(&_now,·NULL);

844

············gettimeofday(&_now,·NULL);

846

············qemu_log("%d@%zu.%06zu:pl330_dmalpfallthrough·"·"loop·fallthrough"·"\n",

846

············qemu_log("%d@%zu.%06zu:pl330_dmalpfallthrough·"·"loop·fallthrough"·"\n",

847

·····················qemu_get_thread_id(),

847

·····················qemu_get_thread_id(),

848

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

848

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

849

·····················);

849

·····················);

850

#line·852·"trace/trace-hw_dma.h"

850

#line·852·"trace/trace-hw_dma.h"

851

········}·else·{

851

········}·else·{

853

············qemu_log("pl330_dmalpfallthrough·"·"loop·fallthrough"·"\n");

853

············qemu_log("pl330_dmalpfallthrough·"·"loop·fallthrough"·"\n");

854

#line·856·"trace/trace-hw_dma.h"

854

#line·856·"trace/trace-hw_dma.h"

855

········}

855

········}

856

····}

856

····}

857

}

857

}

858

static·inline·void·trace_pl330_dmalpfallthrough(void)

858

static·inline·void·trace_pl330_dmalpfallthrough(void)

870

static·inline·void·_nocheck__trace_pl330_dmasev_evirq(uint8_t·ev_id)

870

static·inline·void·_nocheck__trace_pl330_dmasev_evirq(uint8_t·ev_id)

871

{

871

{

872

····if·(trace_event_get_state(TRACE_PL330_DMASEV_EVIRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

872

····if·(trace_event_get_state(TRACE_PL330_DMASEV_EVIRQ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

873

········if·(message_with_timestamp)·{

873

········if·(message_with_timestamp)·{

874

············struct·timeval·_now;

874

············struct·timeval·_now;

875

············gettimeofday(&_now,·NULL);

875

············gettimeofday(&_now,·NULL);

877

············qemu_log("%d@%zu.%06zu:pl330_dmasev_evirq·"·"event·interrupt·raised·%"PRId8·"\n",

877

············qemu_log("%d@%zu.%06zu:pl330_dmasev_evirq·"·"event·interrupt·raised·%"PRId8·"\n",

878

·····················qemu_get_thread_id(),

878

·····················qemu_get_thread_id(),

879

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

879

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

880

·····················,·ev_id);

880

·····················,·ev_id);

881

#line·883·"trace/trace-hw_dma.h"

881

#line·883·"trace/trace-hw_dma.h"

882

········}·else·{

882

········}·else·{

884

············qemu_log("pl330_dmasev_evirq·"·"event·interrupt·raised·%"PRId8·"\n",·ev_id);

884

············qemu_log("pl330_dmasev_evirq·"·"event·interrupt·raised·%"PRId8·"\n",·ev_id);

885

#line·887·"trace/trace-hw_dma.h"

885

#line·887·"trace/trace-hw_dma.h"

886

········}

886

········}

887

····}

887

····}

888

}

888

}

889

static·inline·void·trace_pl330_dmasev_evirq(uint8_t·ev_id)

889

static·inline·void·trace_pl330_dmasev_evirq(uint8_t·ev_id)

901

static·inline·void·_nocheck__trace_pl330_dmasev_event(uint8_t·ev_id)

901

static·inline·void·_nocheck__trace_pl330_dmasev_event(uint8_t·ev_id)

902

{

902

{

903

····if·(trace_event_get_state(TRACE_PL330_DMASEV_EVENT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

903

····if·(trace_event_get_state(TRACE_PL330_DMASEV_EVENT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

904

········if·(message_with_timestamp)·{

904

········if·(message_with_timestamp)·{

905

············struct·timeval·_now;

905

············struct·timeval·_now;

906

············gettimeofday(&_now,·NULL);

906

············gettimeofday(&_now,·NULL);

908

············qemu_log("%d@%zu.%06zu:pl330_dmasev_event·"·"event·raised·%"PRId8·"\n",

908

············qemu_log("%d@%zu.%06zu:pl330_dmasev_event·"·"event·raised·%"PRId8·"\n",

909

·····················qemu_get_thread_id(),

909

·····················qemu_get_thread_id(),

910

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

910

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

911

·····················,·ev_id);

911

·····················,·ev_id);

912

#line·914·"trace/trace-hw_dma.h"

912

#line·914·"trace/trace-hw_dma.h"

913

········}·else·{

913

········}·else·{

915

············qemu_log("pl330_dmasev_event·"·"event·raised·%"PRId8·"\n",·ev_id);

915

············qemu_log("pl330_dmasev_event·"·"event·raised·%"PRId8·"\n",·ev_id);

916

#line·918·"trace/trace-hw_dma.h"

916

#line·918·"trace/trace-hw_dma.h"

917

········}

917

········}

918

····}

918

····}

919

}

919

}

920

static·inline·void·trace_pl330_dmasev_event(uint8_t·ev_id)

920

static·inline·void·trace_pl330_dmasev_event(uint8_t·ev_id)

932

static·inline·void·_nocheck__trace_pl330_dmast(uint8_t·chan,·uint32_t·addr,·uint32_t·sz,·uint32_t·num,·char·ch)

932

static·inline·void·_nocheck__trace_pl330_dmast(uint8_t·chan,·uint32_t·addr,·uint32_t·sz,·uint32_t·num,·char·ch)

933

{

933

{

934

····if·(trace_event_get_state(TRACE_PL330_DMAST)·&&·qemu_loglevel_mask(LOG_TRACE))·{

934

····if·(trace_event_get_state(TRACE_PL330_DMAST)·&&·qemu_loglevel_mask(LOG_TRACE))·{

935

········if·(message_with_timestamp)·{

935

········if·(message_with_timestamp)·{

936

············struct·timeval·_now;

936

············struct·timeval·_now;

937

············gettimeofday(&_now,·NULL);

937

············gettimeofday(&_now,·NULL);

939

············qemu_log("%d@%zu.%06zu:pl330_dmast·"·"channel:%"PRId8"·address:0x%08"PRIx32"·size:0x%"PRIx32"·num:%"PRId32"·%c"·"\n",

939

············qemu_log("%d@%zu.%06zu:pl330_dmast·"·"channel:%"PRId8"·address:0x%08"PRIx32"·size:0x%"PRIx32"·num:%"PRId32"·%c"·"\n",

940

·····················qemu_get_thread_id(),

940

·····················qemu_get_thread_id(),

941

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

941

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

942

·····················,·chan,·addr,·sz,·num,·ch);

942

·····················,·chan,·addr,·sz,·num,·ch);

943

#line·945·"trace/trace-hw_dma.h"

943

#line·945·"trace/trace-hw_dma.h"

944

········}·else·{

944

········}·else·{

946

············qemu_log("pl330_dmast·"·"channel:%"PRId8"·address:0x%08"PRIx32"·size:0x%"PRIx32"·num:%"PRId32"·%c"·"\n",·chan,·addr,·sz,·num,·ch);

946

············qemu_log("pl330_dmast·"·"channel:%"PRId8"·address:0x%08"PRIx32"·size:0x%"PRIx32"·num:%"PRId32"·%c"·"\n",·chan,·addr,·sz,·num,·ch);

947

#line·949·"trace/trace-hw_dma.h"

947

#line·949·"trace/trace-hw_dma.h"

948

········}

948

········}

949

····}

949

····}

950

}

950

}

951

static·inline·void·trace_pl330_dmast(uint8_t·chan,·uint32_t·addr,·uint32_t·sz,·uint32_t·num,·char·ch)

951

static·inline·void·trace_pl330_dmast(uint8_t·chan,·uint32_t·addr,·uint32_t·sz,·uint32_t·num,·char·ch)

963

static·inline·void·_nocheck__trace_pl330_dmawfe(uint8_t·ev_id)

963

static·inline·void·_nocheck__trace_pl330_dmawfe(uint8_t·ev_id)

964

{

964

{

965

····if·(trace_event_get_state(TRACE_PL330_DMAWFE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

965

····if·(trace_event_get_state(TRACE_PL330_DMAWFE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

966

········if·(message_with_timestamp)·{

966

········if·(message_with_timestamp)·{

967

············struct·timeval·_now;

967

············struct·timeval·_now;

968

············gettimeofday(&_now,·NULL);

968

············gettimeofday(&_now,·NULL);

970

············qemu_log("%d@%zu.%06zu:pl330_dmawfe·"·"event·lowered·0x%"PRIx8·"\n",

970

············qemu_log("%d@%zu.%06zu:pl330_dmawfe·"·"event·lowered·0x%"PRIx8·"\n",

971

·····················qemu_get_thread_id(),

971

·····················qemu_get_thread_id(),

972

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

972

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

973

·····················,·ev_id);

973

·····················,·ev_id);

974

#line·976·"trace/trace-hw_dma.h"

974

#line·976·"trace/trace-hw_dma.h"

975

········}·else·{

975

········}·else·{

977

············qemu_log("pl330_dmawfe·"·"event·lowered·0x%"PRIx8·"\n",·ev_id);

977

············qemu_log("pl330_dmawfe·"·"event·lowered·0x%"PRIx8·"\n",·ev_id);

978

#line·980·"trace/trace-hw_dma.h"

978

#line·980·"trace/trace-hw_dma.h"

979

········}

979

········}

980

····}

980

····}

981

}

981

}

982

static·inline·void·trace_pl330_dmawfe(uint8_t·ev_id)

982

static·inline·void·trace_pl330_dmawfe(uint8_t·ev_id)

994

static·inline·void·_nocheck__trace_pl330_chan_exec_undef(void)

994

static·inline·void·_nocheck__trace_pl330_chan_exec_undef(void)

995

{

995

{

996

····if·(trace_event_get_state(TRACE_PL330_CHAN_EXEC_UNDEF)·&&·qemu_loglevel_mask(LOG_TRACE))·{

996

····if·(trace_event_get_state(TRACE_PL330_CHAN_EXEC_UNDEF)·&&·qemu_loglevel_mask(LOG_TRACE))·{

997

········if·(message_with_timestamp)·{

997

········if·(message_with_timestamp)·{

998

············struct·timeval·_now;

998

············struct·timeval·_now;

999

············gettimeofday(&_now,·NULL);

999

············gettimeofday(&_now,·NULL);

1001

············qemu_log("%d@%zu.%06zu:pl330_chan_exec_undef·"·"undefined·instruction"·"\n",

1001

············qemu_log("%d@%zu.%06zu:pl330_chan_exec_undef·"·"undefined·instruction"·"\n",

1002

·····················qemu_get_thread_id(),

1002

·····················qemu_get_thread_id(),

1003

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1003

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1004

·····················);

1004

·····················);

1005

#line·1007·"trace/trace-hw_dma.h"

1005

#line·1007·"trace/trace-hw_dma.h"

1006

········}·else·{

1006

········}·else·{

1008

············qemu_log("pl330_chan_exec_undef·"·"undefined·instruction"·"\n");

1008

············qemu_log("pl330_chan_exec_undef·"·"undefined·instruction"·"\n");

1009

#line·1011·"trace/trace-hw_dma.h"

1009

#line·1011·"trace/trace-hw_dma.h"

1010

········}

1010

········}

1011

····}

1011

····}

1012

}

1012

}

1013

static·inline·void·trace_pl330_chan_exec_undef(void)

1013

static·inline·void·trace_pl330_chan_exec_undef(void)

1025

static·inline·void·_nocheck__trace_pl330_exec_cycle(uint32_t·addr,·uint32_t·size)

1025

static·inline·void·_nocheck__trace_pl330_exec_cycle(uint32_t·addr,·uint32_t·size)

1026

{

1026

{

1027

····if·(trace_event_get_state(TRACE_PL330_EXEC_CYCLE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1027

····if·(trace_event_get_state(TRACE_PL330_EXEC_CYCLE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1028

········if·(message_with_timestamp)·{

1028

········if·(message_with_timestamp)·{

1029

············struct·timeval·_now;

1029

············struct·timeval·_now;

1030

············gettimeofday(&_now,·NULL);

1030

············gettimeofday(&_now,·NULL);

1032

············qemu_log("%d@%zu.%06zu:pl330_exec_cycle·"·"PL330·read·from·memory·@0x%08"PRIx32"·(size·=·0x%08"PRIx32")"·"\n",

1032

············qemu_log("%d@%zu.%06zu:pl330_exec_cycle·"·"PL330·read·from·memory·@0x%08"PRIx32"·(size·=·0x%08"PRIx32")"·"\n",

1033

·····················qemu_get_thread_id(),

1033

·····················qemu_get_thread_id(),

1034

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1034

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1035

·····················,·addr,·size);

1035

·····················,·addr,·size);

1036

#line·1038·"trace/trace-hw_dma.h"

1036

#line·1038·"trace/trace-hw_dma.h"

1037

········}·else·{

1037

········}·else·{

1039

············qemu_log("pl330_exec_cycle·"·"PL330·read·from·memory·@0x%08"PRIx32"·(size·=·0x%08"PRIx32")"·"\n",·addr,·size);

1039

············qemu_log("pl330_exec_cycle·"·"PL330·read·from·memory·@0x%08"PRIx32"·(size·=·0x%08"PRIx32")"·"\n",·addr,·size);

1040

#line·1042·"trace/trace-hw_dma.h"

1040

#line·1042·"trace/trace-hw_dma.h"

1041

········}

1041

········}

1042

····}

1042

····}

1043

}

1043

}

1044

static·inline·void·trace_pl330_exec_cycle(uint32_t·addr,·uint32_t·size)

1044

static·inline·void·trace_pl330_exec_cycle(uint32_t·addr,·uint32_t·size)

1056

static·inline·void·_nocheck__trace_pl330_hexdump(uint32_t·offset,·char·*·str)

1056

static·inline·void·_nocheck__trace_pl330_hexdump(uint32_t·offset,·char·*·str)

1057

{

1057

{

1058

····if·(trace_event_get_state(TRACE_PL330_HEXDUMP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1058

····if·(trace_event_get_state(TRACE_PL330_HEXDUMP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1059

········if·(message_with_timestamp)·{

1059

········if·(message_with_timestamp)·{

1060

············struct·timeval·_now;

1060

············struct·timeval·_now;

1061

············gettimeofday(&_now,·NULL);

1061

············gettimeofday(&_now,·NULL);

1063

············qemu_log("%d@%zu.%06zu:pl330_hexdump·"·"·0x%04"PRIx32":%s"·"\n",

1063

············qemu_log("%d@%zu.%06zu:pl330_hexdump·"·"·0x%04"PRIx32":%s"·"\n",

1064

·····················qemu_get_thread_id(),

1064

·····················qemu_get_thread_id(),

1065

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1065

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1066

·····················,·offset,·str);

1066

·····················,·offset,·str);

1067

#line·1069·"trace/trace-hw_dma.h"

1067

#line·1069·"trace/trace-hw_dma.h"

1068

········}·else·{

1068

········}·else·{

1070

············qemu_log("pl330_hexdump·"·"·0x%04"PRIx32":%s"·"\n",·offset,·str);

1070

············qemu_log("pl330_hexdump·"·"·0x%04"PRIx32":%s"·"\n",·offset,·str);

1071

#line·1073·"trace/trace-hw_dma.h"

1071

#line·1073·"trace/trace-hw_dma.h"

1072

········}

1072

········}

1073

····}

1073

····}

1074

}

1074

}

1075

static·inline·void·trace_pl330_hexdump(uint32_t·offset,·char·*·str)

1075

static·inline·void·trace_pl330_hexdump(uint32_t·offset,·char·*·str)

1087

static·inline·void·_nocheck__trace_pl330_exec(void)

1087

static·inline·void·_nocheck__trace_pl330_exec(void)

1088

{

1088

{

1089

····if·(trace_event_get_state(TRACE_PL330_EXEC)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1089

····if·(trace_event_get_state(TRACE_PL330_EXEC)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1090

········if·(message_with_timestamp)·{

1090

········if·(message_with_timestamp)·{

1091

············struct·timeval·_now;

1091

············struct·timeval·_now;

1092

············gettimeofday(&_now,·NULL);

1092

············gettimeofday(&_now,·NULL);

1094

············qemu_log("%d@%zu.%06zu:pl330_exec·"·"pl330_exec"·"\n",

1094

············qemu_log("%d@%zu.%06zu:pl330_exec·"·"pl330_exec"·"\n",

1095

·····················qemu_get_thread_id(),

1095

·····················qemu_get_thread_id(),

1096

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1096

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1097

·····················);

1097

·····················);

1098

#line·1100·"trace/trace-hw_dma.h"

1098

#line·1100·"trace/trace-hw_dma.h"

1099

········}·else·{

1099

········}·else·{

1101

············qemu_log("pl330_exec·"·"pl330_exec"·"\n");

1101

············qemu_log("pl330_exec·"·"pl330_exec"·"\n");

1102

#line·1104·"trace/trace-hw_dma.h"

1102

#line·1104·"trace/trace-hw_dma.h"

1103

········}

1103

········}

1104

····}

1104

····}

1105

}

1105

}

1106

static·inline·void·trace_pl330_exec(void)

1106

static·inline·void·trace_pl330_exec(void)

1118

static·inline·void·_nocheck__trace_pl330_debug_exec(uint8_t·ch)

1118

static·inline·void·_nocheck__trace_pl330_debug_exec(uint8_t·ch)

1119

{

1119

{

1120

····if·(trace_event_get_state(TRACE_PL330_DEBUG_EXEC)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1120

····if·(trace_event_get_state(TRACE_PL330_DEBUG_EXEC)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1121

········if·(message_with_timestamp)·{

1121

········if·(message_with_timestamp)·{

1122

············struct·timeval·_now;

1122

············struct·timeval·_now;

1123

············gettimeofday(&_now,·NULL);

1123

············gettimeofday(&_now,·NULL);

1125

············qemu_log("%d@%zu.%06zu:pl330_debug_exec·"·"chan·id:·0x%"PRIx8·"\n",

1125

············qemu_log("%d@%zu.%06zu:pl330_debug_exec·"·"chan·id:·0x%"PRIx8·"\n",

1126

·····················qemu_get_thread_id(),

1126

·····················qemu_get_thread_id(),

1127

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1127

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1128

·····················,·ch);

1128

·····················,·ch);

1129

#line·1131·"trace/trace-hw_dma.h"

1129

#line·1131·"trace/trace-hw_dma.h"

1130

········}·else·{

1130

········}·else·{

1132

············qemu_log("pl330_debug_exec·"·"chan·id:·0x%"PRIx8·"\n",·ch);

1132

············qemu_log("pl330_debug_exec·"·"chan·id:·0x%"PRIx8·"\n",·ch);

1133

#line·1135·"trace/trace-hw_dma.h"

1133

#line·1135·"trace/trace-hw_dma.h"

1134

········}

1134

········}

1135

····}

1135

····}

1136

}

1136

}

1137

static·inline·void·trace_pl330_debug_exec(uint8_t·ch)

1137

static·inline·void·trace_pl330_debug_exec(uint8_t·ch)

1149

static·inline·void·_nocheck__trace_pl330_debug_exec_stall(void)

1149

static·inline·void·_nocheck__trace_pl330_debug_exec_stall(void)

1150

{

1150

{

1151

····if·(trace_event_get_state(TRACE_PL330_DEBUG_EXEC_STALL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1151

····if·(trace_event_get_state(TRACE_PL330_DEBUG_EXEC_STALL)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1152

········if·(message_with_timestamp)·{

1152

········if·(message_with_timestamp)·{

1153

············struct·timeval·_now;

1153

············struct·timeval·_now;

1154

············gettimeofday(&_now,·NULL);

1154

············gettimeofday(&_now,·NULL);

1156

············qemu_log("%d@%zu.%06zu:pl330_debug_exec_stall·"·"stall·of·debug·instruction·not·implemented"·"\n",

1156

············qemu_log("%d@%zu.%06zu:pl330_debug_exec_stall·"·"stall·of·debug·instruction·not·implemented"·"\n",

1157

·····················qemu_get_thread_id(),

1157

·····················qemu_get_thread_id(),

1158

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1158

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1159

·····················);

1159

·····················);

1160

#line·1162·"trace/trace-hw_dma.h"

1160

#line·1162·"trace/trace-hw_dma.h"

1161

········}·else·{

1161

········}·else·{

1163

············qemu_log("pl330_debug_exec_stall·"·"stall·of·debug·instruction·not·implemented"·"\n");

1163

············qemu_log("pl330_debug_exec_stall·"·"stall·of·debug·instruction·not·implemented"·"\n");

1164

#line·1166·"trace/trace-hw_dma.h"

1164

#line·1166·"trace/trace-hw_dma.h"

1165

········}

1165

········}

1166

····}

1166

····}

1167

}

1167

}

1168

static·inline·void·trace_pl330_debug_exec_stall(void)

1168

static·inline·void·trace_pl330_debug_exec_stall(void)

1180

static·inline·void·_nocheck__trace_pl330_iomem_write(uint32_t·offset,·uint32_t·value)

1180

static·inline·void·_nocheck__trace_pl330_iomem_write(uint32_t·offset,·uint32_t·value)

1181

{

1181

{

1182

····if·(trace_event_get_state(TRACE_PL330_IOMEM_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1182

····if·(trace_event_get_state(TRACE_PL330_IOMEM_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1183

········if·(message_with_timestamp)·{

1183

········if·(message_with_timestamp)·{

1184

············struct·timeval·_now;

1184

············struct·timeval·_now;

1185

············gettimeofday(&_now,·NULL);

1185

············gettimeofday(&_now,·NULL);

1187

············qemu_log("%d@%zu.%06zu:pl330_iomem_write·"·"addr:·0x%08"PRIx32"·data:·0x%08"PRIx32·"\n",

1187

············qemu_log("%d@%zu.%06zu:pl330_iomem_write·"·"addr:·0x%08"PRIx32"·data:·0x%08"PRIx32·"\n",

1188

·····················qemu_get_thread_id(),

1188

·····················qemu_get_thread_id(),

1189

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1189

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1190

·····················,·offset,·value);

1190

·····················,·offset,·value);

1191

#line·1193·"trace/trace-hw_dma.h"

1191

#line·1193·"trace/trace-hw_dma.h"

1192

········}·else·{

1192

········}·else·{

1194

············qemu_log("pl330_iomem_write·"·"addr:·0x%08"PRIx32"·data:·0x%08"PRIx32·"\n",·offset,·value);

1194

············qemu_log("pl330_iomem_write·"·"addr:·0x%08"PRIx32"·data:·0x%08"PRIx32·"\n",·offset,·value);

1195

#line·1197·"trace/trace-hw_dma.h"

1195

#line·1197·"trace/trace-hw_dma.h"

1196

········}

1196

········}

1197

····}

1197

····}

1198

}

1198

}

1199

static·inline·void·trace_pl330_iomem_write(uint32_t·offset,·uint32_t·value)

1199

static·inline·void·trace_pl330_iomem_write(uint32_t·offset,·uint32_t·value)

1211

static·inline·void·_nocheck__trace_pl330_iomem_write_clr(int·i)

1211

static·inline·void·_nocheck__trace_pl330_iomem_write_clr(int·i)

1212

{

1212

{

1213

····if·(trace_event_get_state(TRACE_PL330_IOMEM_WRITE_CLR)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1213

····if·(trace_event_get_state(TRACE_PL330_IOMEM_WRITE_CLR)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1214

········if·(message_with_timestamp)·{

1214

········if·(message_with_timestamp)·{

1215

············struct·timeval·_now;

1215

············struct·timeval·_now;

1216

············gettimeofday(&_now,·NULL);

1216

············gettimeofday(&_now,·NULL);

1218

············qemu_log("%d@%zu.%06zu:pl330_iomem_write_clr·"·"event·interrupt·lowered·%d"·"\n",

1218

············qemu_log("%d@%zu.%06zu:pl330_iomem_write_clr·"·"event·interrupt·lowered·%d"·"\n",

1219

·····················qemu_get_thread_id(),

1219

·····················qemu_get_thread_id(),

1220

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1220

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1221

·····················,·i);

1221

·····················,·i);

1222

#line·1224·"trace/trace-hw_dma.h"

1222

#line·1224·"trace/trace-hw_dma.h"

1223

········}·else·{

1223

········}·else·{

1225

············qemu_log("pl330_iomem_write_clr·"·"event·interrupt·lowered·%d"·"\n",·i);

1225

············qemu_log("pl330_iomem_write_clr·"·"event·interrupt·lowered·%d"·"\n",·i);

1226

#line·1228·"trace/trace-hw_dma.h"

1226

#line·1228·"trace/trace-hw_dma.h"

1227

········}

1227

········}

1228

····}

1228

····}

1229

}

1229

}

1230

static·inline·void·trace_pl330_iomem_write_clr(int·i)

1230

static·inline·void·trace_pl330_iomem_write_clr(int·i)

1242

static·inline·void·_nocheck__trace_pl330_iomem_read(uint32_t·addr,·uint32_t·data)

1242

static·inline·void·_nocheck__trace_pl330_iomem_read(uint32_t·addr,·uint32_t·data)

1243

{

1243

{

1244

····if·(trace_event_get_state(TRACE_PL330_IOMEM_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1244

····if·(trace_event_get_state(TRACE_PL330_IOMEM_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1245

········if·(message_with_timestamp)·{

1245

········if·(message_with_timestamp)·{

1246

············struct·timeval·_now;

1246

············struct·timeval·_now;

1247

············gettimeofday(&_now,·NULL);

1247

············gettimeofday(&_now,·NULL);

1249

············qemu_log("%d@%zu.%06zu:pl330_iomem_read·"·"addr:·0x%08"PRIx32"·data:·0x%08"PRIx32·"\n",

1249

············qemu_log("%d@%zu.%06zu:pl330_iomem_read·"·"addr:·0x%08"PRIx32"·data:·0x%08"PRIx32·"\n",

1250

·····················qemu_get_thread_id(),

1250

·····················qemu_get_thread_id(),

1251

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1251

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1252

·····················,·addr,·data);

1252

·····················,·addr,·data);

1253

#line·1255·"trace/trace-hw_dma.h"

1253

#line·1255·"trace/trace-hw_dma.h"

1254

········}·else·{

1254

········}·else·{

1256

············qemu_log("pl330_iomem_read·"·"addr:·0x%08"PRIx32"·data:·0x%08"PRIx32·"\n",·addr,·data);

1256

············qemu_log("pl330_iomem_read·"·"addr:·0x%08"PRIx32"·data:·0x%08"PRIx32·"\n",·addr,·data);

1257

#line·1259·"trace/trace-hw_dma.h"

1257

#line·1259·"trace/trace-hw_dma.h"

1258

········}

1258

········}

1259

····}

1259

····}

1260

}

1260

}

1261

static·inline·void·trace_pl330_iomem_read(uint32_t·addr,·uint32_t·data)

1261

static·inline·void·trace_pl330_iomem_read(uint32_t·addr,·uint32_t·data)