/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-20250307-n78xxhhy/packages/diff-html reproducibleA reproducibleB

231

static·inline·void·_nocheck__trace_slavio_timer_get_out(uint64_t·limit,·uint32_t·counthigh,·uint32_t·count)

231

static·inline·void·_nocheck__trace_slavio_timer_get_out(uint64_t·limit,·uint32_t·counthigh,·uint32_t·count)

232

{

232

{

233

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

233

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

234

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

234

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

235

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

235

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

236

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

236

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

238

············qemu_log("%d@%zu.%06zu:slavio_timer_get_out·"·"limit·0x%"PRIx64"·count·0x%x0x%08x"·"\n",

238

············qemu_log("%d@%zu.%06zu:slavio_timer_get_out·"·"limit·0x%"PRIx64"·count·0x%x0x%08x"·"\n",

239

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

239

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

240

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

240

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

241

·····················,·limit,·counthigh,·count);

241

·····················,·limit,·counthigh,·count);

242

#line·244·"trace/trace-hw_timer.h"

242

#line·244·"trace/trace-hw_timer.h"

243

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

243

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

245

············qemu_log("slavio_timer_get_out·"·"limit·0x%"PRIx64"·count·0x%x0x%08x"·"\n",·limit,·counthigh,·count);

245

············qemu_log("slavio_timer_get_out·"·"limit·0x%"PRIx64"·count·0x%x0x%08x"·"\n",·limit,·counthigh,·count);

246

#line·248·"trace/trace-hw_timer.h"

246

#line·248·"trace/trace-hw_timer.h"

247

········}

247

········}

248

····}

248

····}

249

}

249

}

250

static·inline·void·trace_slavio_timer_get_out(uint64_t·limit,·uint32_t·counthigh,·uint32_t·count)

250

static·inline·void·trace_slavio_timer_get_out(uint64_t·limit,·uint32_t·counthigh,·uint32_t·count)

262

static·inline·void·_nocheck__trace_slavio_timer_irq(uint32_t·counthigh,·uint32_t·count)

262

static·inline·void·_nocheck__trace_slavio_timer_irq(uint32_t·counthigh,·uint32_t·count)

263

{

263

{

264

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

264

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

265

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

265

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

266

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

266

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

267

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

267

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

269

············qemu_log("%d@%zu.%06zu:slavio_timer_irq·"·"callback:·count·0x%x0x%08x"·"\n",

269

············qemu_log("%d@%zu.%06zu:slavio_timer_irq·"·"callback:·count·0x%x0x%08x"·"\n",

270

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

270

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

271

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

271

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

272

·····················,·counthigh,·count);

272

·····················,·counthigh,·count);

273

#line·275·"trace/trace-hw_timer.h"

273

#line·275·"trace/trace-hw_timer.h"

274

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

274

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

276

············qemu_log("slavio_timer_irq·"·"callback:·count·0x%x0x%08x"·"\n",·counthigh,·count);

276

············qemu_log("slavio_timer_irq·"·"callback:·count·0x%x0x%08x"·"\n",·counthigh,·count);

277

#line·279·"trace/trace-hw_timer.h"

277

#line·279·"trace/trace-hw_timer.h"

278

········}

278

········}

279

····}

279

····}

280

}

280

}

281

static·inline·void·trace_slavio_timer_irq(uint32_t·counthigh,·uint32_t·count)

281

static·inline·void·trace_slavio_timer_irq(uint32_t·counthigh,·uint32_t·count)

293

static·inline·void·_nocheck__trace_slavio_timer_mem_readl_invalid(uint64_t·addr)

293

static·inline·void·_nocheck__trace_slavio_timer_mem_readl_invalid(uint64_t·addr)

294

{

294

{

295

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

295

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

296

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

296

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

297

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

297

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

298

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

298

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

300

············qemu_log("%d@%zu.%06zu:slavio_timer_mem_readl_invalid·"·"invalid·read·address·0x%"PRIx64·"\n",

300

············qemu_log("%d@%zu.%06zu:slavio_timer_mem_readl_invalid·"·"invalid·read·address·0x%"PRIx64·"\n",

301

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

301

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

302

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

302

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

303

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

303

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

304

#line·306·"trace/trace-hw_timer.h"

304

#line·306·"trace/trace-hw_timer.h"

305

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

305

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

307

············qemu_log("slavio_timer_mem_readl_invalid·"·"invalid·read·address·0x%"PRIx64·"\n",·addr);

307

············qemu_log("slavio_timer_mem_readl_invalid·"·"invalid·read·address·0x%"PRIx64·"\n",·addr);

308

#line·310·"trace/trace-hw_timer.h"

308

#line·310·"trace/trace-hw_timer.h"

309

········}

309

········}

310

····}

310

····}

311

}

311

}

312

static·inline·void·trace_slavio_timer_mem_readl_invalid(uint64_t·addr)

312

static·inline·void·trace_slavio_timer_mem_readl_invalid(uint64_t·addr)

324

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

324

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

325

{

325

{

326

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

326

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

327

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

327

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

328

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

328

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

329

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

329

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

331

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

331

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

332

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

332

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

333

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

333

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

334

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

334

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

335

#line·337·"trace/trace-hw_timer.h"

335

#line·337·"trace/trace-hw_timer.h"

336

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

336

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

338

············qemu_log("slavio_timer_mem_readl·"·"read·0x%"PRIx64"·=·0x%08x"·"\n",·addr,·ret);

338

············qemu_log("slavio_timer_mem_readl·"·"read·0x%"PRIx64"·=·0x%08x"·"\n",·addr,·ret);

339

#line·341·"trace/trace-hw_timer.h"

339

#line·341·"trace/trace-hw_timer.h"

340

········}

340

········}

341

····}

341

····}

342

}

342

}

343

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

343

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

355

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

355

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

356

{

356

{

357

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

357

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

358

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

358

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

359

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

359

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

360

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

360

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

362

············qemu_log("%d@%zu.%06zu:slavio_timer_mem_writel·"·"write·0x%"PRIx64"·=·0x%08x"·"\n",

362

············qemu_log("%d@%zu.%06zu:slavio_timer_mem_writel·"·"write·0x%"PRIx64"·=·0x%08x"·"\n",

363

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

363

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

364

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

364

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

365

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

365

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

366

#line·368·"trace/trace-hw_timer.h"

366

#line·368·"trace/trace-hw_timer.h"

367

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

367

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

369

············qemu_log("slavio_timer_mem_writel·"·"write·0x%"PRIx64"·=·0x%08x"·"\n",·addr,·val);

369

············qemu_log("slavio_timer_mem_writel·"·"write·0x%"PRIx64"·=·0x%08x"·"\n",·addr,·val);

370

#line·372·"trace/trace-hw_timer.h"

370

#line·372·"trace/trace-hw_timer.h"

371

········}

371

········}

372

····}

372

····}

373

}

373

}

374

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

374

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

386

static·inline·void·_nocheck__trace_slavio_timer_mem_writel_limit(unsigned·int·timer_index,·uint64_t·count)

386

static·inline·void·_nocheck__trace_slavio_timer_mem_writel_limit(unsigned·int·timer_index,·uint64_t·count)

387

{

387

{

388

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

388

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

389

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

389

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

390

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

390

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

391

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

391

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

393

············qemu_log("%d@%zu.%06zu:slavio_timer_mem_writel_limit·"·"processor·%d·user·timer·set·to·0x%016"PRIx64·"\n",

393

············qemu_log("%d@%zu.%06zu:slavio_timer_mem_writel_limit·"·"processor·%d·user·timer·set·to·0x%016"PRIx64·"\n",

394

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

394

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

395

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

395

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

396

·····················,·timer_index,·count);

396

·····················,·timer_index,·count);

397

#line·399·"trace/trace-hw_timer.h"

397

#line·399·"trace/trace-hw_timer.h"

398

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

398

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

400

············qemu_log("slavio_timer_mem_writel_limit·"·"processor·%d·user·timer·set·to·0x%016"PRIx64·"\n",·timer_index,·count);

400

············qemu_log("slavio_timer_mem_writel_limit·"·"processor·%d·user·timer·set·to·0x%016"PRIx64·"\n",·timer_index,·count);

401

#line·403·"trace/trace-hw_timer.h"

401

#line·403·"trace/trace-hw_timer.h"

402

········}

402

········}

403

····}

403

····}

404

}

404

}

405

static·inline·void·trace_slavio_timer_mem_writel_limit(unsigned·int·timer_index,·uint64_t·count)

405

static·inline·void·trace_slavio_timer_mem_writel_limit(unsigned·int·timer_index,·uint64_t·count)

417

static·inline·void·_nocheck__trace_slavio_timer_mem_writel_counter_invalid(void)

417

static·inline·void·_nocheck__trace_slavio_timer_mem_writel_counter_invalid(void)

418

{

418

{

419

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

419

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

420

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

420

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

421

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

421

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

422

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

422

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

424

············qemu_log("%d@%zu.%06zu:slavio_timer_mem_writel_counter_invalid·"·"not·user·timer"·"\n",

424

············qemu_log("%d@%zu.%06zu:slavio_timer_mem_writel_counter_invalid·"·"not·user·timer"·"\n",

425

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

425

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

426

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

426

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

427

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

427

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

428

#line·430·"trace/trace-hw_timer.h"

428

#line·430·"trace/trace-hw_timer.h"

429

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

429

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

431

············qemu_log("slavio_timer_mem_writel_counter_invalid·"·"not·user·timer"·"\n");

431

············qemu_log("slavio_timer_mem_writel_counter_invalid·"·"not·user·timer"·"\n");

432

#line·434·"trace/trace-hw_timer.h"

432

#line·434·"trace/trace-hw_timer.h"

433

········}

433

········}

434

····}

434

····}

435

}

435

}

436

static·inline·void·trace_slavio_timer_mem_writel_counter_invalid(void)

436

static·inline·void·trace_slavio_timer_mem_writel_counter_invalid(void)

448

static·inline·void·_nocheck__trace_slavio_timer_mem_writel_status_start(unsigned·int·timer_index)

448

static·inline·void·_nocheck__trace_slavio_timer_mem_writel_status_start(unsigned·int·timer_index)

449

{

449

{

450

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

450

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

451

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

451

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

452

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

452

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

453

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

453

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

455

············qemu_log("%d@%zu.%06zu:slavio_timer_mem_writel_status_start·"·"processor·%d·user·timer·started"·"\n",

455

············qemu_log("%d@%zu.%06zu:slavio_timer_mem_writel_status_start·"·"processor·%d·user·timer·started"·"\n",

456

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

456

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

457

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

457

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

458

·····················,·timer_index);

458

·····················,·timer_index);

459

#line·461·"trace/trace-hw_timer.h"

459

#line·461·"trace/trace-hw_timer.h"

460

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

460

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

462

············qemu_log("slavio_timer_mem_writel_status_start·"·"processor·%d·user·timer·started"·"\n",·timer_index);

462

············qemu_log("slavio_timer_mem_writel_status_start·"·"processor·%d·user·timer·started"·"\n",·timer_index);

463

#line·465·"trace/trace-hw_timer.h"

463

#line·465·"trace/trace-hw_timer.h"

464

········}

464

········}

465

····}

465

····}

466

}

466

}

467

static·inline·void·trace_slavio_timer_mem_writel_status_start(unsigned·int·timer_index)

467

static·inline·void·trace_slavio_timer_mem_writel_status_start(unsigned·int·timer_index)

479

static·inline·void·_nocheck__trace_slavio_timer_mem_writel_status_stop(unsigned·int·timer_index)

479

static·inline·void·_nocheck__trace_slavio_timer_mem_writel_status_stop(unsigned·int·timer_index)

480

{

480

{

481

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

481

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

482

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

482

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

483

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

483

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

484

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

484

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

486

············qemu_log("%d@%zu.%06zu:slavio_timer_mem_writel_status_stop·"·"processor·%d·user·timer·stopped"·"\n",

486

············qemu_log("%d@%zu.%06zu:slavio_timer_mem_writel_status_stop·"·"processor·%d·user·timer·stopped"·"\n",

487

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

487

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

488

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

488

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

489

·····················,·timer_index);

489

·····················,·timer_index);

490

#line·492·"trace/trace-hw_timer.h"

490

#line·492·"trace/trace-hw_timer.h"

491

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

491

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

493

············qemu_log("slavio_timer_mem_writel_status_stop·"·"processor·%d·user·timer·stopped"·"\n",·timer_index);

493

············qemu_log("slavio_timer_mem_writel_status_stop·"·"processor·%d·user·timer·stopped"·"\n",·timer_index);

494

#line·496·"trace/trace-hw_timer.h"

494

#line·496·"trace/trace-hw_timer.h"

495

········}

495

········}

496

····}

496

····}

497

}

497

}

498

static·inline·void·trace_slavio_timer_mem_writel_status_stop(unsigned·int·timer_index)

498

static·inline·void·trace_slavio_timer_mem_writel_status_stop(unsigned·int·timer_index)

510

static·inline·void·_nocheck__trace_slavio_timer_mem_writel_mode_user(unsigned·int·timer_index)

510

static·inline·void·_nocheck__trace_slavio_timer_mem_writel_mode_user(unsigned·int·timer_index)

511

{

511

{

512

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

512

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

513

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

513

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

514

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

514

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

515

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

515

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

517

············qemu_log("%d@%zu.%06zu:slavio_timer_mem_writel_mode_user·"·"processor·%d·changed·from·counter·to·user·timer"·"\n",

517

············qemu_log("%d@%zu.%06zu:slavio_timer_mem_writel_mode_user·"·"processor·%d·changed·from·counter·to·user·timer"·"\n",

518

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

518

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

519

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

519

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

520

·····················,·timer_index);

520

·····················,·timer_index);

521

#line·523·"trace/trace-hw_timer.h"

521

#line·523·"trace/trace-hw_timer.h"

522

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

522

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

524

············qemu_log("slavio_timer_mem_writel_mode_user·"·"processor·%d·changed·from·counter·to·user·timer"·"\n",·timer_index);

524

············qemu_log("slavio_timer_mem_writel_mode_user·"·"processor·%d·changed·from·counter·to·user·timer"·"\n",·timer_index);

525

#line·527·"trace/trace-hw_timer.h"

525

#line·527·"trace/trace-hw_timer.h"

526

········}

526

········}

527

····}

527

····}

528

}

528

}

529

static·inline·void·trace_slavio_timer_mem_writel_mode_user(unsigned·int·timer_index)

529

static·inline·void·trace_slavio_timer_mem_writel_mode_user(unsigned·int·timer_index)

541

static·inline·void·_nocheck__trace_slavio_timer_mem_writel_mode_counter(unsigned·int·timer_index)

541

static·inline·void·_nocheck__trace_slavio_timer_mem_writel_mode_counter(unsigned·int·timer_index)

542

{

542

{

543

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

543

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

544

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

544

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

545

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

545

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

546

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

546

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

548

············qemu_log("%d@%zu.%06zu:slavio_timer_mem_writel_mode_counter·"·"processor·%d·changed·from·user·timer·to·counter"·"\n",

548

············qemu_log("%d@%zu.%06zu:slavio_timer_mem_writel_mode_counter·"·"processor·%d·changed·from·user·timer·to·counter"·"\n",

549

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

549

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

550

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

550

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

551

·····················,·timer_index);

551

·····················,·timer_index);

552

#line·554·"trace/trace-hw_timer.h"

552

#line·554·"trace/trace-hw_timer.h"

553

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

553

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

555

············qemu_log("slavio_timer_mem_writel_mode_counter·"·"processor·%d·changed·from·user·timer·to·counter"·"\n",·timer_index);

555

············qemu_log("slavio_timer_mem_writel_mode_counter·"·"processor·%d·changed·from·user·timer·to·counter"·"\n",·timer_index);

556

#line·558·"trace/trace-hw_timer.h"

556

#line·558·"trace/trace-hw_timer.h"

557

········}

557

········}

558

····}

558

····}

559

}

559

}

560

static·inline·void·trace_slavio_timer_mem_writel_mode_counter(unsigned·int·timer_index)

560

static·inline·void·trace_slavio_timer_mem_writel_mode_counter(unsigned·int·timer_index)

572

static·inline·void·_nocheck__trace_slavio_timer_mem_writel_mode_invalid(void)

572

static·inline·void·_nocheck__trace_slavio_timer_mem_writel_mode_invalid(void)

573

{

573

{

574

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

574

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

575

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

575

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

576

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

576

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

577

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

577

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

579

············qemu_log("%d@%zu.%06zu:slavio_timer_mem_writel_mode_invalid·"·"not·system·timer"·"\n",

579

············qemu_log("%d@%zu.%06zu:slavio_timer_mem_writel_mode_invalid·"·"not·system·timer"·"\n",

580

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

580

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

581

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

581

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

582

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

582

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

583

#line·585·"trace/trace-hw_timer.h"

583

#line·585·"trace/trace-hw_timer.h"

584

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

584

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

586

············qemu_log("slavio_timer_mem_writel_mode_invalid·"·"not·system·timer"·"\n");

586

············qemu_log("slavio_timer_mem_writel_mode_invalid·"·"not·system·timer"·"\n");

587

#line·589·"trace/trace-hw_timer.h"

587

#line·589·"trace/trace-hw_timer.h"

588

········}

588

········}

589

····}

589

····}

590

}

590

}

591

static·inline·void·trace_slavio_timer_mem_writel_mode_invalid(void)

591

static·inline·void·trace_slavio_timer_mem_writel_mode_invalid(void)

603

static·inline·void·_nocheck__trace_slavio_timer_mem_writel_invalid(uint64_t·addr)

603

static·inline·void·_nocheck__trace_slavio_timer_mem_writel_invalid(uint64_t·addr)

604

{

604

{

605

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

605

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

606

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

606

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

607

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

607

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

608

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

608

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

610

············qemu_log("%d@%zu.%06zu:slavio_timer_mem_writel_invalid·"·"invalid·write·address·0x%"PRIx64·"\n",

610

············qemu_log("%d@%zu.%06zu:slavio_timer_mem_writel_invalid·"·"invalid·write·address·0x%"PRIx64·"\n",

611

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

611

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

612

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

612

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

613

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

613

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

614

#line·616·"trace/trace-hw_timer.h"

614

#line·616·"trace/trace-hw_timer.h"

615

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

615

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

617

············qemu_log("slavio_timer_mem_writel_invalid·"·"invalid·write·address·0x%"PRIx64·"\n",·addr);

617

············qemu_log("slavio_timer_mem_writel_invalid·"·"invalid·write·address·0x%"PRIx64·"\n",·addr);

618

#line·620·"trace/trace-hw_timer.h"

618

#line·620·"trace/trace-hw_timer.h"

619

········}

619

········}

620

····}

620

····}

621

}

621

}

622

static·inline·void·trace_slavio_timer_mem_writel_invalid(uint64_t·addr)

622

static·inline·void·trace_slavio_timer_mem_writel_invalid(uint64_t·addr)

634

static·inline·void·_nocheck__trace_grlib_gptimer_enable(int·id,·uint32_t·count)

634

static·inline·void·_nocheck__trace_grlib_gptimer_enable(int·id,·uint32_t·count)

635

{

635

{

636

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

636

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

637

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

637

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

638

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

638

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

639

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

639

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

641

············qemu_log("%d@%zu.%06zu:grlib_gptimer_enable·"·"timer:%d·set·count·0x%x·and·run"·"\n",

641

············qemu_log("%d@%zu.%06zu:grlib_gptimer_enable·"·"timer:%d·set·count·0x%x·and·run"·"\n",

642

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

642

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

643

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

643

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

644

·····················,·id,·count);

644

·····················,·id,·count);

645

#line·647·"trace/trace-hw_timer.h"

645

#line·647·"trace/trace-hw_timer.h"

646

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

646

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

648

············qemu_log("grlib_gptimer_enable·"·"timer:%d·set·count·0x%x·and·run"·"\n",·id,·count);

648

············qemu_log("grlib_gptimer_enable·"·"timer:%d·set·count·0x%x·and·run"·"\n",·id,·count);

649

#line·651·"trace/trace-hw_timer.h"

649

#line·651·"trace/trace-hw_timer.h"

650

········}

650

········}

651

····}

651

····}

652

}

652

}

653

static·inline·void·trace_grlib_gptimer_enable(int·id,·uint32_t·count)

653

static·inline·void·trace_grlib_gptimer_enable(int·id,·uint32_t·count)

665

static·inline·void·_nocheck__trace_grlib_gptimer_disabled(int·id,·uint32_t·config)

665

static·inline·void·_nocheck__trace_grlib_gptimer_disabled(int·id,·uint32_t·config)

666

{

666

{

667

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

667

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

668

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

668

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

669

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

669

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

670

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

670

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

672

············qemu_log("%d@%zu.%06zu:grlib_gptimer_disabled·"·"timer:%d·Timer·disable·config·0x%x"·"\n",

672

············qemu_log("%d@%zu.%06zu:grlib_gptimer_disabled·"·"timer:%d·Timer·disable·config·0x%x"·"\n",

673

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

673

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

674

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

674

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

675

·····················,·id,·config);

675

·····················,·id,·config);

676

#line·678·"trace/trace-hw_timer.h"

676

#line·678·"trace/trace-hw_timer.h"

677

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

677

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

679

············qemu_log("grlib_gptimer_disabled·"·"timer:%d·Timer·disable·config·0x%x"·"\n",·id,·config);

679

············qemu_log("grlib_gptimer_disabled·"·"timer:%d·Timer·disable·config·0x%x"·"\n",·id,·config);

680

#line·682·"trace/trace-hw_timer.h"

680

#line·682·"trace/trace-hw_timer.h"

681

········}

681

········}

682

····}

682

····}

683

}

683

}

684

static·inline·void·trace_grlib_gptimer_disabled(int·id,·uint32_t·config)

684

static·inline·void·trace_grlib_gptimer_disabled(int·id,·uint32_t·config)

696

static·inline·void·_nocheck__trace_grlib_gptimer_restart(int·id,·uint32_t·reload)

696

static·inline·void·_nocheck__trace_grlib_gptimer_restart(int·id,·uint32_t·reload)

697

{

697

{

698

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

698

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

699

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

699

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

700

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

700

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

701

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

701

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

703

············qemu_log("%d@%zu.%06zu:grlib_gptimer_restart·"·"timer:%d·reload·val:·0x%x"·"\n",

703

············qemu_log("%d@%zu.%06zu:grlib_gptimer_restart·"·"timer:%d·reload·val:·0x%x"·"\n",

704

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

704

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

705

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

705

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

706

·····················,·id,·reload);

706

·····················,·id,·reload);

707

#line·709·"trace/trace-hw_timer.h"

707

#line·709·"trace/trace-hw_timer.h"

708

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

708

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

710

············qemu_log("grlib_gptimer_restart·"·"timer:%d·reload·val:·0x%x"·"\n",·id,·reload);

710

············qemu_log("grlib_gptimer_restart·"·"timer:%d·reload·val:·0x%x"·"\n",·id,·reload);

711

#line·713·"trace/trace-hw_timer.h"

711

#line·713·"trace/trace-hw_timer.h"

712

········}

712

········}

713

····}

713

····}

714

}

714

}

715

static·inline·void·trace_grlib_gptimer_restart(int·id,·uint32_t·reload)

715

static·inline·void·trace_grlib_gptimer_restart(int·id,·uint32_t·reload)

727

static·inline·void·_nocheck__trace_grlib_gptimer_set_scaler(uint32_t·scaler,·uint32_t·freq)

727

static·inline·void·_nocheck__trace_grlib_gptimer_set_scaler(uint32_t·scaler,·uint32_t·freq)

728

{

728

{

729

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

729

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

730

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

730

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

731

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

731

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

732

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

732

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

734

············qemu_log("%d@%zu.%06zu:grlib_gptimer_set_scaler·"·"scaler:0x%x·freq:%uHz"·"\n",

734

············qemu_log("%d@%zu.%06zu:grlib_gptimer_set_scaler·"·"scaler:0x%x·freq:%uHz"·"\n",

735

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

735

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

736

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

736

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

737

·····················,·scaler,·freq);

737

·····················,·scaler,·freq);

738

#line·740·"trace/trace-hw_timer.h"

738

#line·740·"trace/trace-hw_timer.h"

739

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

739

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

741

············qemu_log("grlib_gptimer_set_scaler·"·"scaler:0x%x·freq:%uHz"·"\n",·scaler,·freq);

741

············qemu_log("grlib_gptimer_set_scaler·"·"scaler:0x%x·freq:%uHz"·"\n",·scaler,·freq);

742

#line·744·"trace/trace-hw_timer.h"

742

#line·744·"trace/trace-hw_timer.h"

743

········}

743

········}

744

····}

744

····}

745

}

745

}

746

static·inline·void·trace_grlib_gptimer_set_scaler(uint32_t·scaler,·uint32_t·freq)

746

static·inline·void·trace_grlib_gptimer_set_scaler(uint32_t·scaler,·uint32_t·freq)

758

static·inline·void·_nocheck__trace_grlib_gptimer_hit(int·id)

758

static·inline·void·_nocheck__trace_grlib_gptimer_hit(int·id)

759

{

759

{

760

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

760

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

761

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

761

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

762

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

762

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

763

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

763

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

765

············qemu_log("%d@%zu.%06zu:grlib_gptimer_hit·"·"timer:%d·HIT"·"\n",

765

············qemu_log("%d@%zu.%06zu:grlib_gptimer_hit·"·"timer:%d·HIT"·"\n",

766

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

766

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

767

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

767

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

768

·····················,·id);

768

·····················,·id);

769

#line·771·"trace/trace-hw_timer.h"

769

#line·771·"trace/trace-hw_timer.h"

770

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

770

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

772

············qemu_log("grlib_gptimer_hit·"·"timer:%d·HIT"·"\n",·id);

772

············qemu_log("grlib_gptimer_hit·"·"timer:%d·HIT"·"\n",·id);

773

#line·775·"trace/trace-hw_timer.h"

773

#line·775·"trace/trace-hw_timer.h"

774

········}

774

········}

775

····}

775

····}

776

}

776

}

777

static·inline·void·trace_grlib_gptimer_hit(int·id)

777

static·inline·void·trace_grlib_gptimer_hit(int·id)

789

static·inline·void·_nocheck__trace_grlib_gptimer_readl(int·id,·uint64_t·addr,·uint32_t·val)

789

static·inline·void·_nocheck__trace_grlib_gptimer_readl(int·id,·uint64_t·addr,·uint32_t·val)

790

{

790

{

791

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

791

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

792

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

792

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

793

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

793

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

794

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

794

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

796

············qemu_log("%d@%zu.%06zu:grlib_gptimer_readl·"·"timer:%d·addr·0x%"PRIx64"·0x%x"·"\n",

796

············qemu_log("%d@%zu.%06zu:grlib_gptimer_readl·"·"timer:%d·addr·0x%"PRIx64"·0x%x"·"\n",

797

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

797

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

798

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

798

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

799

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

799

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

800

#line·802·"trace/trace-hw_timer.h"

800

#line·802·"trace/trace-hw_timer.h"

801

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

801

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

803

············qemu_log("grlib_gptimer_readl·"·"timer:%d·addr·0x%"PRIx64"·0x%x"·"\n",·id,·addr,·val);

803

············qemu_log("grlib_gptimer_readl·"·"timer:%d·addr·0x%"PRIx64"·0x%x"·"\n",·id,·addr,·val);

804

#line·806·"trace/trace-hw_timer.h"

804

#line·806·"trace/trace-hw_timer.h"

805

········}

805

········}

806

····}

806

····}

807

}

807

}

808

static·inline·void·trace_grlib_gptimer_readl(int·id,·uint64_t·addr,·uint32_t·val)

808

static·inline·void·trace_grlib_gptimer_readl(int·id,·uint64_t·addr,·uint32_t·val)

820

static·inline·void·_nocheck__trace_grlib_gptimer_writel(int·id,·uint64_t·addr,·uint32_t·val)

820

static·inline·void·_nocheck__trace_grlib_gptimer_writel(int·id,·uint64_t·addr,·uint32_t·val)

821

{

821

{

822

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

822

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

823

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

823

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

824

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

824

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

825

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

825

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

827

············qemu_log("%d@%zu.%06zu:grlib_gptimer_writel·"·"timer:%d·addr·0x%"PRIx64"·0x%x"·"\n",

827

············qemu_log("%d@%zu.%06zu:grlib_gptimer_writel·"·"timer:%d·addr·0x%"PRIx64"·0x%x"·"\n",

828

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

828

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

829

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

829

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

830

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

830

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

831

#line·833·"trace/trace-hw_timer.h"

831

#line·833·"trace/trace-hw_timer.h"

832

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

832

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

834

············qemu_log("grlib_gptimer_writel·"·"timer:%d·addr·0x%"PRIx64"·0x%x"·"\n",·id,·addr,·val);

834

············qemu_log("grlib_gptimer_writel·"·"timer:%d·addr·0x%"PRIx64"·0x%x"·"\n",·id,·addr,·val);

835

#line·837·"trace/trace-hw_timer.h"

835

#line·837·"trace/trace-hw_timer.h"

836

········}

836

········}

837

····}

837

····}

838

}

838

}

839

static·inline·void·trace_grlib_gptimer_writel(int·id,·uint64_t·addr,·uint32_t·val)

839

static·inline·void·trace_grlib_gptimer_writel(int·id,·uint64_t·addr,·uint32_t·val)

851

static·inline·void·_nocheck__trace_aspeed_timer_ctrl_enable(uint8_t·i,·bool·enable)

851

static·inline·void·_nocheck__trace_aspeed_timer_ctrl_enable(uint8_t·i,·bool·enable)

852

{

852

{

853

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

853

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

854

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

854

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

855

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

855

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

856

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

856

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

858

············qemu_log("%d@%zu.%06zu:aspeed_timer_ctrl_enable·"·"Timer·%"·PRIu8·":·%d"·"\n",

858

············qemu_log("%d@%zu.%06zu:aspeed_timer_ctrl_enable·"·"Timer·%"·PRIu8·":·%d"·"\n",

859

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

859

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

860

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

860

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

861

·····················,·i,·enable);

861

·····················,·i,·enable);

862

#line·864·"trace/trace-hw_timer.h"

862

#line·864·"trace/trace-hw_timer.h"

863

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

863

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

865

············qemu_log("aspeed_timer_ctrl_enable·"·"Timer·%"·PRIu8·":·%d"·"\n",·i,·enable);

865

············qemu_log("aspeed_timer_ctrl_enable·"·"Timer·%"·PRIu8·":·%d"·"\n",·i,·enable);

866

#line·868·"trace/trace-hw_timer.h"

866

#line·868·"trace/trace-hw_timer.h"

867

········}

867

········}

868

····}

868

····}

869

}

869

}

870

static·inline·void·trace_aspeed_timer_ctrl_enable(uint8_t·i,·bool·enable)

870

static·inline·void·trace_aspeed_timer_ctrl_enable(uint8_t·i,·bool·enable)

882

static·inline·void·_nocheck__trace_aspeed_timer_ctrl_external_clock(uint8_t·i,·bool·enable)

882

static·inline·void·_nocheck__trace_aspeed_timer_ctrl_external_clock(uint8_t·i,·bool·enable)

883

{

883

{

884

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

884

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

885

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

885

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

886

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

886

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

887

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

887

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

889

············qemu_log("%d@%zu.%06zu:aspeed_timer_ctrl_external_clock·"·"Timer·%"·PRIu8·":·%d"·"\n",

889

············qemu_log("%d@%zu.%06zu:aspeed_timer_ctrl_external_clock·"·"Timer·%"·PRIu8·":·%d"·"\n",

890

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

890

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

891

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

891

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

892

·····················,·i,·enable);

892

·····················,·i,·enable);

893

#line·895·"trace/trace-hw_timer.h"

893

#line·895·"trace/trace-hw_timer.h"

894

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

894

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

896

············qemu_log("aspeed_timer_ctrl_external_clock·"·"Timer·%"·PRIu8·":·%d"·"\n",·i,·enable);

896

············qemu_log("aspeed_timer_ctrl_external_clock·"·"Timer·%"·PRIu8·":·%d"·"\n",·i,·enable);

897

#line·899·"trace/trace-hw_timer.h"

897

#line·899·"trace/trace-hw_timer.h"

898

········}

898

········}

899

····}

899

····}

900

}

900

}

901

static·inline·void·trace_aspeed_timer_ctrl_external_clock(uint8_t·i,·bool·enable)

901

static·inline·void·trace_aspeed_timer_ctrl_external_clock(uint8_t·i,·bool·enable)

913

static·inline·void·_nocheck__trace_aspeed_timer_ctrl_overflow_interrupt(uint8_t·i,·bool·enable)

913

static·inline·void·_nocheck__trace_aspeed_timer_ctrl_overflow_interrupt(uint8_t·i,·bool·enable)

914

{

914

{

915

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

915

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

916

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

916

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

917

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

917

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

918

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

918

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

920

············qemu_log("%d@%zu.%06zu:aspeed_timer_ctrl_overflow_interrupt·"·"Timer·%"·PRIu8·":·%d"·"\n",

920

············qemu_log("%d@%zu.%06zu:aspeed_timer_ctrl_overflow_interrupt·"·"Timer·%"·PRIu8·":·%d"·"\n",

921

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

921

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

922

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

922

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

923

·····················,·i,·enable);

923

·····················,·i,·enable);

924

#line·926·"trace/trace-hw_timer.h"

924

#line·926·"trace/trace-hw_timer.h"

925

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

925

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

927

············qemu_log("aspeed_timer_ctrl_overflow_interrupt·"·"Timer·%"·PRIu8·":·%d"·"\n",·i,·enable);

927

············qemu_log("aspeed_timer_ctrl_overflow_interrupt·"·"Timer·%"·PRIu8·":·%d"·"\n",·i,·enable);

928

#line·930·"trace/trace-hw_timer.h"

928

#line·930·"trace/trace-hw_timer.h"

929

········}

929

········}

930

····}

930

····}

931

}

931

}

932

static·inline·void·trace_aspeed_timer_ctrl_overflow_interrupt(uint8_t·i,·bool·enable)

932

static·inline·void·trace_aspeed_timer_ctrl_overflow_interrupt(uint8_t·i,·bool·enable)

944

static·inline·void·_nocheck__trace_aspeed_timer_ctrl_pulse_enable(uint8_t·i,·bool·enable)

944

static·inline·void·_nocheck__trace_aspeed_timer_ctrl_pulse_enable(uint8_t·i,·bool·enable)

945

{

945

{

946

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

946

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

947

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

947

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

948

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

948

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

949

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

949

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

951

············qemu_log("%d@%zu.%06zu:aspeed_timer_ctrl_pulse_enable·"·"Timer·%"·PRIu8·":·%d"·"\n",

951

············qemu_log("%d@%zu.%06zu:aspeed_timer_ctrl_pulse_enable·"·"Timer·%"·PRIu8·":·%d"·"\n",

952

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

952

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

953

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

953

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

954

·····················,·i,·enable);

954

·····················,·i,·enable);

955

#line·957·"trace/trace-hw_timer.h"

955

#line·957·"trace/trace-hw_timer.h"

956

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

956

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

958

············qemu_log("aspeed_timer_ctrl_pulse_enable·"·"Timer·%"·PRIu8·":·%d"·"\n",·i,·enable);

958

············qemu_log("aspeed_timer_ctrl_pulse_enable·"·"Timer·%"·PRIu8·":·%d"·"\n",·i,·enable);

959

#line·961·"trace/trace-hw_timer.h"

959

#line·961·"trace/trace-hw_timer.h"

960

········}

960

········}

961

····}

961

····}

962

}

962

}

963

static·inline·void·trace_aspeed_timer_ctrl_pulse_enable(uint8_t·i,·bool·enable)

963

static·inline·void·trace_aspeed_timer_ctrl_pulse_enable(uint8_t·i,·bool·enable)

975

static·inline·void·_nocheck__trace_aspeed_timer_set_ctrl2(uint32_t·value)

975

static·inline·void·_nocheck__trace_aspeed_timer_set_ctrl2(uint32_t·value)

976

{

976

{

977

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

977

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

978

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

978

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

979

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

979

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

980

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

980

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

982

············qemu_log("%d@%zu.%06zu:aspeed_timer_set_ctrl2·"·"Value:·0x%"·PRIx32·"\n",

982

············qemu_log("%d@%zu.%06zu:aspeed_timer_set_ctrl2·"·"Value:·0x%"·PRIx32·"\n",

983

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

983

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

984

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

984

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

985

·····················,·value);

985

·····················,·value);

986

#line·988·"trace/trace-hw_timer.h"

986

#line·988·"trace/trace-hw_timer.h"

987

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

987

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

989

············qemu_log("aspeed_timer_set_ctrl2·"·"Value:·0x%"·PRIx32·"\n",·value);

989

············qemu_log("aspeed_timer_set_ctrl2·"·"Value:·0x%"·PRIx32·"\n",·value);

990

#line·992·"trace/trace-hw_timer.h"

990

#line·992·"trace/trace-hw_timer.h"

991

········}

991

········}

992

····}

992

····}

993

}

993

}

994

static·inline·void·trace_aspeed_timer_set_ctrl2(uint32_t·value)

994

static·inline·void·trace_aspeed_timer_set_ctrl2(uint32_t·value)

1006

static·inline·void·_nocheck__trace_aspeed_timer_set_value(int·timer,·int·reg,·uint32_t·value)

1006

static·inline·void·_nocheck__trace_aspeed_timer_set_value(int·timer,·int·reg,·uint32_t·value)

1007

{

1007

{

1008

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

1008

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

1009

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

1009

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

1010

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

1010

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

1011

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

1011

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

1013

············qemu_log("%d@%zu.%06zu:aspeed_timer_set_value·"·"Timer·%d·register·%d:·0x%"·PRIx32·"\n",

1013

············qemu_log("%d@%zu.%06zu:aspeed_timer_set_value·"·"Timer·%d·register·%d:·0x%"·PRIx32·"\n",

1014

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

1014

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

1015

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

1015

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

1016

·····················,·timer,·reg,·value);

1016

·····················,·timer,·reg,·value);

1017

#line·1019·"trace/trace-hw_timer.h"

1017

#line·1019·"trace/trace-hw_timer.h"

1018

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

1018

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

1020

············qemu_log("aspeed_timer_set_value·"·"Timer·%d·register·%d:·0x%"·PRIx32·"\n",·timer,·reg,·value);

1020

············qemu_log("aspeed_timer_set_value·"·"Timer·%d·register·%d:·0x%"·PRIx32·"\n",·timer,·reg,·value);

1021

#line·1023·"trace/trace-hw_timer.h"

1021

#line·1023·"trace/trace-hw_timer.h"

1022

········}

1022

········}

1023

····}

1023

····}

1024

}

1024

}

1025

static·inline·void·trace_aspeed_timer_set_value(int·timer,·int·reg,·uint32_t·value)

1025

static·inline·void·trace_aspeed_timer_set_value(int·timer,·int·reg,·uint32_t·value)

1037

static·inline·void·_nocheck__trace_aspeed_timer_read(uint64_t·offset,·unsigned·size,·uint64_t·value)

1037

static·inline·void·_nocheck__trace_aspeed_timer_read(uint64_t·offset,·unsigned·size,·uint64_t·value)

1038

{

1038

{

1039

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

1039

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

1040

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

1040

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

1041

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

1041

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

1042

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

1042

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

1044

············qemu_log("%d@%zu.%06zu:aspeed_timer_read·"·"From·0x%"·PRIx64·":·of·size·%u:·0x%"·PRIx64·"\n",

1044

············qemu_log("%d@%zu.%06zu:aspeed_timer_read·"·"From·0x%"·PRIx64·":·of·size·%u:·0x%"·PRIx64·"\n",

1045

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

1045

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

1046

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

1046

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

1047

·····················,·offset,·size,·value);

1047

·····················,·offset,·size,·value);

1048

#line·1050·"trace/trace-hw_timer.h"

1048

#line·1050·"trace/trace-hw_timer.h"

1049

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

1049

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

1051

············qemu_log("aspeed_timer_read·"·"From·0x%"·PRIx64·":·of·size·%u:·0x%"·PRIx64·"\n",·offset,·size,·value);

1051

············qemu_log("aspeed_timer_read·"·"From·0x%"·PRIx64·":·of·size·%u:·0x%"·PRIx64·"\n",·offset,·size,·value);

1052

#line·1054·"trace/trace-hw_timer.h"

1052

#line·1054·"trace/trace-hw_timer.h"

1053

········}

1053

········}

1054

····}

1054

····}

1055

}

1055

}

1056

static·inline·void·trace_aspeed_timer_read(uint64_t·offset,·unsigned·size,·uint64_t·value)

1056

static·inline·void·trace_aspeed_timer_read(uint64_t·offset,·unsigned·size,·uint64_t·value)

1068

static·inline·void·_nocheck__trace_systick_reload(void)

1068

static·inline·void·_nocheck__trace_systick_reload(void)

1069

{

1069

{

1070

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

1070

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

1071

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

1071

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

1072

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

1072

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

1073

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

1073

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

1075

············qemu_log("%d@%zu.%06zu:systick_reload·"·"systick·reload"·"\n",

1075

············qemu_log("%d@%zu.%06zu:systick_reload·"·"systick·reload"·"\n",

1076

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

1076

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

1077

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

1077

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

1078

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

1078

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

1079

#line·1081·"trace/trace-hw_timer.h"

1079

#line·1081·"trace/trace-hw_timer.h"

1080

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

1080

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

1082

············qemu_log("systick_reload·"·"systick·reload"·"\n");

1082

············qemu_log("systick_reload·"·"systick·reload"·"\n");

1083

#line·1085·"trace/trace-hw_timer.h"

1083

#line·1085·"trace/trace-hw_timer.h"

1084

········}

1084

········}

1085

····}

1085

····}

1086

}

1086

}

1087

static·inline·void·trace_systick_reload(void)

1087

static·inline·void·trace_systick_reload(void)

1099

static·inline·void·_nocheck__trace_systick_timer_tick(void)

1099

static·inline·void·_nocheck__trace_systick_timer_tick(void)

1100

{

1100

{

1101

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

1101

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

1102

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

1102

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

1103

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

1103

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

1104

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

1104

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

1106

············qemu_log("%d@%zu.%06zu:systick_timer_tick·"·"systick·reload"·"\n",

1106

············qemu_log("%d@%zu.%06zu:systick_timer_tick·"·"systick·reload"·"\n",

1107

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

1107

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

1108

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

1108

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

1109

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

1109

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

1110

#line·1112·"trace/trace-hw_timer.h"

1110

#line·1112·"trace/trace-hw_timer.h"

1111

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

1111

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

1113

············qemu_log("systick_timer_tick·"·"systick·reload"·"\n");

1113

············qemu_log("systick_timer_tick·"·"systick·reload"·"\n");

1114

#line·1116·"trace/trace-hw_timer.h"

1114

#line·1116·"trace/trace-hw_timer.h"

1115

········}

1115

········}

1116

····}

1116

····}

1117

}

1117

}

1118

static·inline·void·trace_systick_timer_tick(void)

1118

static·inline·void·trace_systick_timer_tick(void)

1130

static·inline·void·_nocheck__trace_systick_read(uint64_t·addr,·uint32_t·value,·unsigned·size)

1130

static·inline·void·_nocheck__trace_systick_read(uint64_t·addr,·uint32_t·value,·unsigned·size)

1131

{

1131

{

1132

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

1132

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

1133

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

1133

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

1134

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

1134

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

1135

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

1135

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

1137

············qemu_log("%d@%zu.%06zu:systick_read·"·"systick·read·addr·0x%"·PRIx64·"·data·0x%"·PRIx32·"·size·%u"·"\n",

1137

············qemu_log("%d@%zu.%06zu:systick_read·"·"systick·read·addr·0x%"·PRIx64·"·data·0x%"·PRIx32·"·size·%u"·"\n",

1138

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

1138

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

1139

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

1139

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

1140

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

1140

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

1141

#line·1143·"trace/trace-hw_timer.h"

1141

#line·1143·"trace/trace-hw_timer.h"

1142

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

1142

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

1144

············qemu_log("systick_read·"·"systick·read·addr·0x%"·PRIx64·"·data·0x%"·PRIx32·"·size·%u"·"\n",·addr,·value,·size);

1144

············qemu_log("systick_read·"·"systick·read·addr·0x%"·PRIx64·"·data·0x%"·PRIx32·"·size·%u"·"\n",·addr,·value,·size);

1145

#line·1147·"trace/trace-hw_timer.h"

1145

#line·1147·"trace/trace-hw_timer.h"

1146

········}

1146

········}

1147

····}

1147

····}

1148

}

1148

}

1149

static·inline·void·trace_systick_read(uint64_t·addr,·uint32_t·value,·unsigned·size)

1149

static·inline·void·trace_systick_read(uint64_t·addr,·uint32_t·value,·unsigned·size)

1161

static·inline·void·_nocheck__trace_systick_write(uint64_t·addr,·uint32_t·value,·unsigned·size)

1161

static·inline·void·_nocheck__trace_systick_write(uint64_t·addr,·uint32_t·value,·unsigned·size)

1162

{

1162

{

1163

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

1163

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

1164

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

1164

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

1165

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

1165

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

1166

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

1166

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

1168

············qemu_log("%d@%zu.%06zu:systick_write·"·"systick·write·addr·0x%"·PRIx64·"·data·0x%"·PRIx32·"·size·%u"·"\n",

1168

············qemu_log("%d@%zu.%06zu:systick_write·"·"systick·write·addr·0x%"·PRIx64·"·data·0x%"·PRIx32·"·size·%u"·"\n",

1169

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

1169

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

1170

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

1170

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

1171

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

1171

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

1172

#line·1174·"trace/trace-hw_timer.h"

1172

#line·1174·"trace/trace-hw_timer.h"

1173

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

1173

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

1175

············qemu_log("systick_write·"·"systick·write·addr·0x%"·PRIx64·"·data·0x%"·PRIx32·"·size·%u"·"\n",·addr,·value,·size);

1175

············qemu_log("systick_write·"·"systick·write·addr·0x%"·PRIx64·"·data·0x%"·PRIx32·"·size·%u"·"\n",·addr,·value,·size);

1176

#line·1178·"trace/trace-hw_timer.h"

1176

#line·1178·"trace/trace-hw_timer.h"

1177

········}

1177

········}

1178

····}

1178

····}

1179

}

1179

}

1180

static·inline·void·trace_systick_write(uint64_t·addr,·uint32_t·value,·unsigned·size)

1180

static·inline·void·trace_systick_write(uint64_t·addr,·uint32_t·value,·unsigned·size)

1192

static·inline·void·_nocheck__trace_cmsdk_apb_timer_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

1192

static·inline·void·_nocheck__trace_cmsdk_apb_timer_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

1193

{

1193

{

1194

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

1194

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

1195

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

1195

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

1196

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

1196

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

1197

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

1197

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

1199

············qemu_log("%d@%zu.%06zu:cmsdk_apb_timer_read·"·"CMSDK·APB·timer·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",

1199

············qemu_log("%d@%zu.%06zu:cmsdk_apb_timer_read·"·"CMSDK·APB·timer·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",

1200

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

1200

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

1201

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

1201

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

1202

·····················,·offset,·data,·size);

1202

·····················,·offset,·data,·size);

1203

#line·1205·"trace/trace-hw_timer.h"

1203

#line·1205·"trace/trace-hw_timer.h"

1204

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

1204

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

1206

············qemu_log("cmsdk_apb_timer_read·"·"CMSDK·APB·timer·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",·offset,·data,·size);

1206

············qemu_log("cmsdk_apb_timer_read·"·"CMSDK·APB·timer·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",·offset,·data,·size);

1207

#line·1209·"trace/trace-hw_timer.h"

1207

#line·1209·"trace/trace-hw_timer.h"

1208

········}

1208

········}

1209

····}

1209

····}

1210

}

1210

}

1211

static·inline·void·trace_cmsdk_apb_timer_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

1211

static·inline·void·trace_cmsdk_apb_timer_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

1223

static·inline·void·_nocheck__trace_cmsdk_apb_timer_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

1223

static·inline·void·_nocheck__trace_cmsdk_apb_timer_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

1224

{

1224

{

1225

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

1225

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

1226

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

1226

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

1227

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

1227

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

1228

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

1228

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

1230

············qemu_log("%d@%zu.%06zu:cmsdk_apb_timer_write·"·"CMSDK·APB·timer·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",

1230

············qemu_log("%d@%zu.%06zu:cmsdk_apb_timer_write·"·"CMSDK·APB·timer·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",

1231

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

1231

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

1232

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

1232

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

1233

·····················,·offset,·data,·size);

1233

·····················,·offset,·data,·size);

1234

#line·1236·"trace/trace-hw_timer.h"

1234

#line·1236·"trace/trace-hw_timer.h"

1235

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

1235

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

1237

············qemu_log("cmsdk_apb_timer_write·"·"CMSDK·APB·timer·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",·offset,·data,·size);

1237

············qemu_log("cmsdk_apb_timer_write·"·"CMSDK·APB·timer·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",·offset,·data,·size);

1238

#line·1240·"trace/trace-hw_timer.h"

1238

#line·1240·"trace/trace-hw_timer.h"

1239

········}

1239

········}

1240

····}

1240

····}

1241

}

1241

}

1242

static·inline·void·trace_cmsdk_apb_timer_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

1242

static·inline·void·trace_cmsdk_apb_timer_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

1254

static·inline·void·_nocheck__trace_cmsdk_apb_timer_reset(void)

1254

static·inline·void·_nocheck__trace_cmsdk_apb_timer_reset(void)

1255

{

1255

{

1256

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

1256

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

1257

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

1257

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

1258

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

1258

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

1259

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

1259

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

1261

············qemu_log("%d@%zu.%06zu:cmsdk_apb_timer_reset·"·"CMSDK·APB·timer:·reset"·"\n",

1261

············qemu_log("%d@%zu.%06zu:cmsdk_apb_timer_reset·"·"CMSDK·APB·timer:·reset"·"\n",

1262

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

1262

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

1263

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

1263

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

1264

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

1264

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

1265

#line·1267·"trace/trace-hw_timer.h"

1265

#line·1267·"trace/trace-hw_timer.h"

1266

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

1266

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

1268

············qemu_log("cmsdk_apb_timer_reset·"·"CMSDK·APB·timer:·reset"·"\n");

1268

············qemu_log("cmsdk_apb_timer_reset·"·"CMSDK·APB·timer:·reset"·"\n");

1269

#line·1271·"trace/trace-hw_timer.h"

1269

#line·1271·"trace/trace-hw_timer.h"

1270

········}

1270

········}

1271

····}

1271

····}

1272

}

1272

}

1273

static·inline·void·trace_cmsdk_apb_timer_reset(void)

1273

static·inline·void·trace_cmsdk_apb_timer_reset(void)

1285

static·inline·void·_nocheck__trace_cmsdk_apb_dualtimer_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

1285

static·inline·void·_nocheck__trace_cmsdk_apb_dualtimer_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

1286

{

1286

{

1287

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

1287

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

1288

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

1288

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

1289

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

1289

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

1290

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

1290

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

1292

············qemu_log("%d@%zu.%06zu:cmsdk_apb_dualtimer_read·"·"CMSDK·APB·dualtimer·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",

1292

············qemu_log("%d@%zu.%06zu:cmsdk_apb_dualtimer_read·"·"CMSDK·APB·dualtimer·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",

1293

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

1293

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

1294

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

1294

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

1295

·····················,·offset,·data,·size);

1295

·····················,·offset,·data,·size);

1296

#line·1298·"trace/trace-hw_timer.h"

1296

#line·1298·"trace/trace-hw_timer.h"

1297

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

1297

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

1299

············qemu_log("cmsdk_apb_dualtimer_read·"·"CMSDK·APB·dualtimer·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",·offset,·data,·size);

1299

············qemu_log("cmsdk_apb_dualtimer_read·"·"CMSDK·APB·dualtimer·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",·offset,·data,·size);

1300

#line·1302·"trace/trace-hw_timer.h"

1300

#line·1302·"trace/trace-hw_timer.h"

1301

········}

1301

········}

1302

····}

1302

····}

1303

}

1303

}

1304

static·inline·void·trace_cmsdk_apb_dualtimer_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

1304

static·inline·void·trace_cmsdk_apb_dualtimer_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

1316

static·inline·void·_nocheck__trace_cmsdk_apb_dualtimer_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

1316

static·inline·void·_nocheck__trace_cmsdk_apb_dualtimer_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

1317

{

1317

{

1318

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

1318

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

1319

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

1319

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

1320

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

1320

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

1321

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

1321

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

1323

············qemu_log("%d@%zu.%06zu:cmsdk_apb_dualtimer_write·"·"CMSDK·APB·dualtimer·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",

1323

············qemu_log("%d@%zu.%06zu:cmsdk_apb_dualtimer_write·"·"CMSDK·APB·dualtimer·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",

1324

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

1324

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

1325

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

1325

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

1326

·····················,·offset,·data,·size);

1326

·····················,·offset,·data,·size);

1327

#line·1329·"trace/trace-hw_timer.h"

1327

#line·1329·"trace/trace-hw_timer.h"

1328

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

1328

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

1330

············qemu_log("cmsdk_apb_dualtimer_write·"·"CMSDK·APB·dualtimer·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",·offset,·data,·size);

1330

············qemu_log("cmsdk_apb_dualtimer_write·"·"CMSDK·APB·dualtimer·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",·offset,·data,·size);

1331

#line·1333·"trace/trace-hw_timer.h"

1331

#line·1333·"trace/trace-hw_timer.h"

1332

········}

1332

········}

1333

····}

1333

····}

1334

}

1334

}

1335

static·inline·void·trace_cmsdk_apb_dualtimer_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

1335

static·inline·void·trace_cmsdk_apb_dualtimer_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

1347

static·inline·void·_nocheck__trace_cmsdk_apb_dualtimer_reset(void)

1347

static·inline·void·_nocheck__trace_cmsdk_apb_dualtimer_reset(void)

1348

{

1348

{

1349

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

1349

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

1350

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

1350

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

1351

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

1351

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

1352

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

1352

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

1354

············qemu_log("%d@%zu.%06zu:cmsdk_apb_dualtimer_reset·"·"CMSDK·APB·dualtimer:·reset"·"\n",

1354

············qemu_log("%d@%zu.%06zu:cmsdk_apb_dualtimer_reset·"·"CMSDK·APB·dualtimer:·reset"·"\n",

1355

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

1355

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

1356

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

1356

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

1357

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

1357

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

1358

#line·1360·"trace/trace-hw_timer.h"

1358

#line·1360·"trace/trace-hw_timer.h"

1359

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

1359

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

1361

············qemu_log("cmsdk_apb_dualtimer_reset·"·"CMSDK·APB·dualtimer:·reset"·"\n");

1361

············qemu_log("cmsdk_apb_dualtimer_reset·"·"CMSDK·APB·dualtimer:·reset"·"\n");

1362

#line·1364·"trace/trace-hw_timer.h"

1362

#line·1364·"trace/trace-hw_timer.h"

1363

········}

1363

········}

1364

····}

1364

····}

1365

}

1365

}

1366

static·inline·void·trace_cmsdk_apb_dualtimer_reset(void)

1366

static·inline·void·trace_cmsdk_apb_dualtimer_reset(void)

1378

static·inline·void·_nocheck__trace_npcm7xx_timer_read(const·char·*·id,·uint64_t·offset,·uint64_t·value)

1378

static·inline·void·_nocheck__trace_npcm7xx_timer_read(const·char·*·id,·uint64_t·offset,·uint64_t·value)

1379

{

1379

{

1380

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

1380

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

1381

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

1381

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

1382

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

1382

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

1383

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

1383

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

1385

············qemu_log("%d@%zu.%06zu:npcm7xx_timer_read·"·"·%s·offset:·0x%04"·PRIx64·"·value·0x%08"·PRIx64·"\n",

1385

············qemu_log("%d@%zu.%06zu:npcm7xx_timer_read·"·"·%s·offset:·0x%04"·PRIx64·"·value·0x%08"·PRIx64·"\n",

1386

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

1386

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

1387

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

1387

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

1388

·····················,·id,·offset,·value);

1388

·····················,·id,·offset,·value);

1389

#line·1391·"trace/trace-hw_timer.h"

1389

#line·1391·"trace/trace-hw_timer.h"

1390

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

1390

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

1392

············qemu_log("npcm7xx_timer_read·"·"·%s·offset:·0x%04"·PRIx64·"·value·0x%08"·PRIx64·"\n",·id,·offset,·value);

1392

············qemu_log("npcm7xx_timer_read·"·"·%s·offset:·0x%04"·PRIx64·"·value·0x%08"·PRIx64·"\n",·id,·offset,·value);

1393

#line·1395·"trace/trace-hw_timer.h"

1393

#line·1395·"trace/trace-hw_timer.h"

1394

········}

1394

········}

1395

····}

1395

····}

1396

}

1396

}

1397

static·inline·void·trace_npcm7xx_timer_read(const·char·*·id,·uint64_t·offset,·uint64_t·value)

1397

static·inline·void·trace_npcm7xx_timer_read(const·char·*·id,·uint64_t·offset,·uint64_t·value)

1409

static·inline·void·_nocheck__trace_npcm7xx_timer_write(const·char·*·id,·uint64_t·offset,·uint64_t·value)

1409

static·inline·void·_nocheck__trace_npcm7xx_timer_write(const·char·*·id,·uint64_t·offset,·uint64_t·value)

1410

{

1410

{

1411

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

1411

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

1412

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

1412

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

1413

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

1413

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

1414

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

1414

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

1416

············qemu_log("%d@%zu.%06zu:npcm7xx_timer_write·"·"%s·offset:·0x%04"·PRIx64·"·value·0x%08"·PRIx64·"\n",

1416

············qemu_log("%d@%zu.%06zu:npcm7xx_timer_write·"·"%s·offset:·0x%04"·PRIx64·"·value·0x%08"·PRIx64·"\n",

1417

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

1417

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

1418

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

1418

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

1419

·····················,·id,·offset,·value);

1419

·····················,·id,·offset,·value);

1420

#line·1422·"trace/trace-hw_timer.h"

1420

#line·1422·"trace/trace-hw_timer.h"

1421

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

1421

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

1423

············qemu_log("npcm7xx_timer_write·"·"%s·offset:·0x%04"·PRIx64·"·value·0x%08"·PRIx64·"\n",·id,·offset,·value);

1423

············qemu_log("npcm7xx_timer_write·"·"%s·offset:·0x%04"·PRIx64·"·value·0x%08"·PRIx64·"\n",·id,·offset,·value);

1424

#line·1426·"trace/trace-hw_timer.h"

1424

#line·1426·"trace/trace-hw_timer.h"

1425

········}

1425

········}

1426

····}

1426

····}

1427

}

1427

}

1428

static·inline·void·trace_npcm7xx_timer_write(const·char·*·id,·uint64_t·offset,·uint64_t·value)

1428

static·inline·void·trace_npcm7xx_timer_write(const·char·*·id,·uint64_t·offset,·uint64_t·value)

1440

static·inline·void·_nocheck__trace_npcm7xx_timer_irq(const·char·*·id,·int·timer,·int·state)

1440

static·inline·void·_nocheck__trace_npcm7xx_timer_irq(const·char·*·id,·int·timer,·int·state)

1441

{

1441

{

1442

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

1442

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

1443

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

1443

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

1444

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

1444

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

1445

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

1445

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

1447

············qemu_log("%d@%zu.%06zu:npcm7xx_timer_irq·"·"%s·timer·%d·state·%d"·"\n",

1447

············qemu_log("%d@%zu.%06zu:npcm7xx_timer_irq·"·"%s·timer·%d·state·%d"·"\n",

1448

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

1448

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

1449

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

1449

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

1450

·····················,·id,·timer,·state);

1450

·····················,·id,·timer,·state);

1451

#line·1453·"trace/trace-hw_timer.h"

1451

#line·1453·"trace/trace-hw_timer.h"

1452

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

1452

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

1454

············qemu_log("npcm7xx_timer_irq·"·"%s·timer·%d·state·%d"·"\n",·id,·timer,·state);

1454

············qemu_log("npcm7xx_timer_irq·"·"%s·timer·%d·state·%d"·"\n",·id,·timer,·state);

1455

#line·1457·"trace/trace-hw_timer.h"

1455

#line·1457·"trace/trace-hw_timer.h"

1456

········}

1456

········}

1457

····}

1457

····}

1458

}

1458

}

1459

static·inline·void·trace_npcm7xx_timer_irq(const·char·*·id,·int·timer,·int·state)

1459

static·inline·void·trace_npcm7xx_timer_irq(const·char·*·id,·int·timer,·int·state)

1471

static·inline·void·_nocheck__trace_nrf51_timer_read(uint8_t·timer_id,·uint64_t·addr,·uint32_t·value,·unsigned·size)

1471

static·inline·void·_nocheck__trace_nrf51_timer_read(uint8_t·timer_id,·uint64_t·addr,·uint32_t·value,·unsigned·size)

1472

{

1472

{

1473

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

1473

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

1474

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

1474

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

1475

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

1475

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

1476

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

1476

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

1478

············qemu_log("%d@%zu.%06zu:nrf51_timer_read·"·"timer·%u·read·addr·0x%"·PRIx64·"·data·0x%"·PRIx32·"·size·%u"·"\n",

1478

············qemu_log("%d@%zu.%06zu:nrf51_timer_read·"·"timer·%u·read·addr·0x%"·PRIx64·"·data·0x%"·PRIx32·"·size·%u"·"\n",

1479

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

1479

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

1480

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

1480

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

1481

·····················,·timer_id,·addr,·value,·size);

1481

·····················,·timer_id,·addr,·value,·size);

1482

#line·1484·"trace/trace-hw_timer.h"

1482

#line·1484·"trace/trace-hw_timer.h"

1483

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

1483

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

1485

············qemu_log("nrf51_timer_read·"·"timer·%u·read·addr·0x%"·PRIx64·"·data·0x%"·PRIx32·"·size·%u"·"\n",·timer_id,·addr,·value,·size);

1485

············qemu_log("nrf51_timer_read·"·"timer·%u·read·addr·0x%"·PRIx64·"·data·0x%"·PRIx32·"·size·%u"·"\n",·timer_id,·addr,·value,·size);

1486

#line·1488·"trace/trace-hw_timer.h"

1486

#line·1488·"trace/trace-hw_timer.h"

1487

········}

1487

········}

1488

····}

1488

····}

1489

}

1489

}

1490

static·inline·void·trace_nrf51_timer_read(uint8_t·timer_id,·uint64_t·addr,·uint32_t·value,·unsigned·size)

1490

static·inline·void·trace_nrf51_timer_read(uint8_t·timer_id,·uint64_t·addr,·uint32_t·value,·unsigned·size)

1502

static·inline·void·_nocheck__trace_nrf51_timer_write(uint8_t·timer_id,·uint64_t·addr,·uint32_t·value,·unsigned·size)

1502

static·inline·void·_nocheck__trace_nrf51_timer_write(uint8_t·timer_id,·uint64_t·addr,·uint32_t·value,·unsigned·size)

1503

{

1503

{

1504

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

1504

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

1505

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

1505

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

1506

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

1506

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

1507

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

1507

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

1509

············qemu_log("%d@%zu.%06zu:nrf51_timer_write·"·"timer·%u·write·addr·0x%"·PRIx64·"·data·0x%"·PRIx32·"·size·%u"·"\n",

1509

············qemu_log("%d@%zu.%06zu:nrf51_timer_write·"·"timer·%u·write·addr·0x%"·PRIx64·"·data·0x%"·PRIx32·"·size·%u"·"\n",

1510

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

1510

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

1511

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

1511

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

1512

·····················,·timer_id,·addr,·value,·size);

1512

·····················,·timer_id,·addr,·value,·size);

1513

#line·1515·"trace/trace-hw_timer.h"

1513

#line·1515·"trace/trace-hw_timer.h"

1514

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

1514

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

1516

············qemu_log("nrf51_timer_write·"·"timer·%u·write·addr·0x%"·PRIx64·"·data·0x%"·PRIx32·"·size·%u"·"\n",·timer_id,·addr,·value,·size);

1516

············qemu_log("nrf51_timer_write·"·"timer·%u·write·addr·0x%"·PRIx64·"·data·0x%"·PRIx32·"·size·%u"·"\n",·timer_id,·addr,·value,·size);

1517

#line·1519·"trace/trace-hw_timer.h"

1517

#line·1519·"trace/trace-hw_timer.h"

1518

········}

1518

········}

1519

····}

1519

····}

1520

}

1520

}

1521

static·inline·void·trace_nrf51_timer_write(uint8_t·timer_id,·uint64_t·addr,·uint32_t·value,·unsigned·size)

1521

static·inline·void·trace_nrf51_timer_write(uint8_t·timer_id,·uint64_t·addr,·uint32_t·value,·unsigned·size)

1533

static·inline·void·_nocheck__trace_nrf51_timer_set_count(uint8_t·timer_id,·uint8_t·counter_id,·uint32_t·value)

1533

static·inline·void·_nocheck__trace_nrf51_timer_set_count(uint8_t·timer_id,·uint8_t·counter_id,·uint32_t·value)

1534

{

1534

{

1535

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

1535

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

1536

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

1536

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

1537

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

1537

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

1538

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

1538

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

1540

············qemu_log("%d@%zu.%06zu:nrf51_timer_set_count·"·"timer·%u·counter·%u·count·0x%"·PRIx32·"\n",

1540

············qemu_log("%d@%zu.%06zu:nrf51_timer_set_count·"·"timer·%u·counter·%u·count·0x%"·PRIx32·"\n",

1541

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

1541

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

1542

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

1542

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

1543

·····················,·timer_id,·counter_id,·value);

1543

·····················,·timer_id,·counter_id,·value);

1544

#line·1546·"trace/trace-hw_timer.h"

1544

#line·1546·"trace/trace-hw_timer.h"

1545

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

1545

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

1547

············qemu_log("nrf51_timer_set_count·"·"timer·%u·counter·%u·count·0x%"·PRIx32·"\n",·timer_id,·counter_id,·value);

1547

············qemu_log("nrf51_timer_set_count·"·"timer·%u·counter·%u·count·0x%"·PRIx32·"\n",·timer_id,·counter_id,·value);

1548

#line·1550·"trace/trace-hw_timer.h"

1548

#line·1550·"trace/trace-hw_timer.h"

1549

········}

1549

········}

1550

····}

1550

····}

1551

}

1551

}

1552

static·inline·void·trace_nrf51_timer_set_count(uint8_t·timer_id,·uint8_t·counter_id,·uint32_t·value)

1552

static·inline·void·trace_nrf51_timer_set_count(uint8_t·timer_id,·uint8_t·counter_id,·uint32_t·value)

1564

static·inline·void·_nocheck__trace_bcm2835_systmr_timer_expired(unsigned·id)

1564

static·inline·void·_nocheck__trace_bcm2835_systmr_timer_expired(unsigned·id)

1565

{

1565

{

1566

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

1566

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

1567

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

1567

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

1568

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

1568

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

1569

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

1569

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

1571

············qemu_log("%d@%zu.%06zu:bcm2835_systmr_timer_expired·"·"timer·#%u·expired"·"\n",

1571

············qemu_log("%d@%zu.%06zu:bcm2835_systmr_timer_expired·"·"timer·#%u·expired"·"\n",

1572

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

1572

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

1573

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

1573

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

1574

·····················,·id);

1574

·····················,·id);

1575

#line·1577·"trace/trace-hw_timer.h"

1575

#line·1577·"trace/trace-hw_timer.h"

1576

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

1576

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

1578

············qemu_log("bcm2835_systmr_timer_expired·"·"timer·#%u·expired"·"\n",·id);

1578

············qemu_log("bcm2835_systmr_timer_expired·"·"timer·#%u·expired"·"\n",·id);

1579

#line·1581·"trace/trace-hw_timer.h"

1579

#line·1581·"trace/trace-hw_timer.h"

1580

········}

1580

········}

1581

····}

1581

····}

1582

}

1582

}

1583

static·inline·void·trace_bcm2835_systmr_timer_expired(unsigned·id)

1583

static·inline·void·trace_bcm2835_systmr_timer_expired(unsigned·id)

1595

static·inline·void·_nocheck__trace_bcm2835_systmr_irq_ack(unsigned·id)

1595

static·inline·void·_nocheck__trace_bcm2835_systmr_irq_ack(unsigned·id)

1596

{

1596

{

1597

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

1597

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

1598

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

1598

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

1599

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

1599

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

1600

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

1600

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

1602

············qemu_log("%d@%zu.%06zu:bcm2835_systmr_irq_ack·"·"timer·#%u·acked"·"\n",

1602

············qemu_log("%d@%zu.%06zu:bcm2835_systmr_irq_ack·"·"timer·#%u·acked"·"\n",

1603

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

1603

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

1604

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

1604

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

1605

·····················,·id);

1605

·····················,·id);

1606

#line·1608·"trace/trace-hw_timer.h"

1606

#line·1608·"trace/trace-hw_timer.h"

1607

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

1607

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

1609

············qemu_log("bcm2835_systmr_irq_ack·"·"timer·#%u·acked"·"\n",·id);

1609

············qemu_log("bcm2835_systmr_irq_ack·"·"timer·#%u·acked"·"\n",·id);

1610

#line·1612·"trace/trace-hw_timer.h"

1610

#line·1612·"trace/trace-hw_timer.h"

1611

········}

1611

········}

1612

····}

1612

····}

1613

}

1613

}

1614

static·inline·void·trace_bcm2835_systmr_irq_ack(unsigned·id)

1614

static·inline·void·trace_bcm2835_systmr_irq_ack(unsigned·id)

1626

static·inline·void·_nocheck__trace_bcm2835_systmr_read(uint64_t·offset,·uint64_t·data)

1626

static·inline·void·_nocheck__trace_bcm2835_systmr_read(uint64_t·offset,·uint64_t·data)

1627

{

1627

{

1628

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

1628

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

1629

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

1629

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

1630

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

1630

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

1631

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

1631

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

1633

············qemu_log("%d@%zu.%06zu:bcm2835_systmr_read·"·"timer·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"\n",

1633

············qemu_log("%d@%zu.%06zu:bcm2835_systmr_read·"·"timer·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"\n",

1634

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

1634

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

1635

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

1635

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

1636

·····················,·offset,·data);

1636

·····················,·offset,·data);

1637

#line·1639·"trace/trace-hw_timer.h"

1637

#line·1639·"trace/trace-hw_timer.h"

1638

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

1638

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

1640

············qemu_log("bcm2835_systmr_read·"·"timer·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"\n",·offset,·data);

1640

············qemu_log("bcm2835_systmr_read·"·"timer·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"\n",·offset,·data);

1641

#line·1643·"trace/trace-hw_timer.h"

1641

#line·1643·"trace/trace-hw_timer.h"

1642

········}

1642

········}

1643

····}

1643

····}

1644

}

1644

}

1645

static·inline·void·trace_bcm2835_systmr_read(uint64_t·offset,·uint64_t·data)

1645

static·inline·void·trace_bcm2835_systmr_read(uint64_t·offset,·uint64_t·data)

1657

static·inline·void·_nocheck__trace_bcm2835_systmr_write(uint64_t·offset,·uint32_t·data)

1657

static·inline·void·_nocheck__trace_bcm2835_systmr_write(uint64_t·offset,·uint32_t·data)

1658

{

1658

{

1659

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

1659

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

1660

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

1660

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

1661

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

1661

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

1662

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

1662

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

1664

············qemu_log("%d@%zu.%06zu:bcm2835_systmr_write·"·"timer·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx32·"\n",

1664

············qemu_log("%d@%zu.%06zu:bcm2835_systmr_write·"·"timer·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx32·"\n",

1665

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

1665

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

1666

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

1666

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

1667

·····················,·offset,·data);

1667

·····················,·offset,·data);

1668

#line·1670·"trace/trace-hw_timer.h"

1668

#line·1670·"trace/trace-hw_timer.h"

1669

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

1669

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

1671

············qemu_log("bcm2835_systmr_write·"·"timer·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx32·"\n",·offset,·data);

1671

············qemu_log("bcm2835_systmr_write·"·"timer·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx32·"\n",·offset,·data);

1672

#line·1674·"trace/trace-hw_timer.h"

1672

#line·1674·"trace/trace-hw_timer.h"

1673

········}

1673

········}

1674

····}

1674

····}

1675

}

1675

}

1676

static·inline·void·trace_bcm2835_systmr_write(uint64_t·offset,·uint32_t·data)

1676

static·inline·void·trace_bcm2835_systmr_write(uint64_t·offset,·uint32_t·data)

1688

static·inline·void·_nocheck__trace_bcm2835_systmr_run(unsigned·id,·uint64_t·delay_us)

1688

static·inline·void·_nocheck__trace_bcm2835_systmr_run(unsigned·id,·uint64_t·delay_us)

1689

{

1689

{

1690

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

1690

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

1691

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

1691

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

1692

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

1692

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

1693

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

1693

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

1695

············qemu_log("%d@%zu.%06zu:bcm2835_systmr_run·"·"timer·#%u·expiring·in·%"PRIu64"·us"·"\n",

1695

············qemu_log("%d@%zu.%06zu:bcm2835_systmr_run·"·"timer·#%u·expiring·in·%"PRIu64"·us"·"\n",

1696

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

1696

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

1697

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

1697

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

1698

·····················,·id,·delay_us);

1698

·····················,·id,·delay_us);

1699

#line·1701·"trace/trace-hw_timer.h"

1699

#line·1701·"trace/trace-hw_timer.h"

1700

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

1700

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

1702

············qemu_log("bcm2835_systmr_run·"·"timer·#%u·expiring·in·%"PRIu64"·us"·"\n",·id,·delay_us);

1702

············qemu_log("bcm2835_systmr_run·"·"timer·#%u·expiring·in·%"PRIu64"·us"·"\n",·id,·delay_us);

1703

#line·1705·"trace/trace-hw_timer.h"

1703

#line·1705·"trace/trace-hw_timer.h"

1704

········}

1704

········}

1705

····}

1705

····}

1706

}

1706

}

1707

static·inline·void·trace_bcm2835_systmr_run(unsigned·id,·uint64_t·delay_us)

1707

static·inline·void·trace_bcm2835_systmr_run(unsigned·id,·uint64_t·delay_us)

1719

static·inline·void·_nocheck__trace_avr_timer16_read(uint8_t·addr,·uint8_t·value)

1719

static·inline·void·_nocheck__trace_avr_timer16_read(uint8_t·addr,·uint8_t·value)

1720

{

1720

{

1721

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

1721

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

1722

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

1722

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

1723

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

1723

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

1724

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

1724

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

1726

············qemu_log("%d@%zu.%06zu:avr_timer16_read·"·"timer16·read·addr:%u·value:%u"·"\n",

1726

············qemu_log("%d@%zu.%06zu:avr_timer16_read·"·"timer16·read·addr:%u·value:%u"·"\n",

1727

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

1727

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

1728

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

1728

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

1729

·····················,·addr,·value);

1729

·····················,·addr,·value);

1730

#line·1732·"trace/trace-hw_timer.h"

1730

#line·1732·"trace/trace-hw_timer.h"

1731

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

1731

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

1733

············qemu_log("avr_timer16_read·"·"timer16·read·addr:%u·value:%u"·"\n",·addr,·value);

1733

············qemu_log("avr_timer16_read·"·"timer16·read·addr:%u·value:%u"·"\n",·addr,·value);

1734

#line·1736·"trace/trace-hw_timer.h"

1734

#line·1736·"trace/trace-hw_timer.h"

1735

········}

1735

········}

1736

····}

1736

····}

1737

}

1737

}

1738

static·inline·void·trace_avr_timer16_read(uint8_t·addr,·uint8_t·value)

1738

static·inline·void·trace_avr_timer16_read(uint8_t·addr,·uint8_t·value)

1750

static·inline·void·_nocheck__trace_avr_timer16_read_ifr(uint8_t·value)

1750

static·inline·void·_nocheck__trace_avr_timer16_read_ifr(uint8_t·value)

1751

{

1751

{

1752

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

1752

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

1753

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

1753

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

1754

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

1754

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

1755

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

1755

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

1757

············qemu_log("%d@%zu.%06zu:avr_timer16_read_ifr·"·"timer16·read·addr:ifr·value:%u"·"\n",

1757

············qemu_log("%d@%zu.%06zu:avr_timer16_read_ifr·"·"timer16·read·addr:ifr·value:%u"·"\n",

1758

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

1758

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

1759

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

1759

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

1760

·····················,·value);

1760

·····················,·value);

1761

#line·1763·"trace/trace-hw_timer.h"

1761

#line·1763·"trace/trace-hw_timer.h"

1762

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

1762

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

1764

············qemu_log("avr_timer16_read_ifr·"·"timer16·read·addr:ifr·value:%u"·"\n",·value);

1764

············qemu_log("avr_timer16_read_ifr·"·"timer16·read·addr:ifr·value:%u"·"\n",·value);

1765

#line·1767·"trace/trace-hw_timer.h"

1765

#line·1767·"trace/trace-hw_timer.h"

1766

········}

1766

········}

1767

····}

1767

····}

1768

}

1768

}

1769

static·inline·void·trace_avr_timer16_read_ifr(uint8_t·value)

1769

static·inline·void·trace_avr_timer16_read_ifr(uint8_t·value)

1781

static·inline·void·_nocheck__trace_avr_timer16_read_imsk(uint8_t·value)

1781

static·inline·void·_nocheck__trace_avr_timer16_read_imsk(uint8_t·value)

1782

{

1782

{

1783

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

1783

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

1784

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

1784

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

1785

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

1785

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

1786

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

1786

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

1788

············qemu_log("%d@%zu.%06zu:avr_timer16_read_imsk·"·"timer16·read·addr:imsk·value:%u"·"\n",

1788

············qemu_log("%d@%zu.%06zu:avr_timer16_read_imsk·"·"timer16·read·addr:imsk·value:%u"·"\n",

1789

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

1789

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

1790

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

1790

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

1791

·····················,·value);

1791

·····················,·value);

1792

#line·1794·"trace/trace-hw_timer.h"

1792

#line·1794·"trace/trace-hw_timer.h"

1793

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

1793

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

1795

············qemu_log("avr_timer16_read_imsk·"·"timer16·read·addr:imsk·value:%u"·"\n",·value);

1795

············qemu_log("avr_timer16_read_imsk·"·"timer16·read·addr:imsk·value:%u"·"\n",·value);

1796

#line·1798·"trace/trace-hw_timer.h"

1796

#line·1798·"trace/trace-hw_timer.h"

1797

········}

1797

········}

1798

····}

1798

····}

1799

}

1799

}

1800

static·inline·void·trace_avr_timer16_read_imsk(uint8_t·value)

1800

static·inline·void·trace_avr_timer16_read_imsk(uint8_t·value)

1812

static·inline·void·_nocheck__trace_avr_timer16_write(uint8_t·addr,·uint8_t·value)

1812

static·inline·void·_nocheck__trace_avr_timer16_write(uint8_t·addr,·uint8_t·value)

1813

{

1813

{

1814

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

1814

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

1815

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

1815

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

1816

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

1816

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

1817

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

1817

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

1819

············qemu_log("%d@%zu.%06zu:avr_timer16_write·"·"timer16·write·addr:%u·value:%u"·"\n",

1819

············qemu_log("%d@%zu.%06zu:avr_timer16_write·"·"timer16·write·addr:%u·value:%u"·"\n",

1820

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

1820

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

1821

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

1821

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

1822

·····················,·addr,·value);

1822

·····················,·addr,·value);

1823

#line·1825·"trace/trace-hw_timer.h"

1823

#line·1825·"trace/trace-hw_timer.h"

1824

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

1824

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

1826

············qemu_log("avr_timer16_write·"·"timer16·write·addr:%u·value:%u"·"\n",·addr,·value);

1826

············qemu_log("avr_timer16_write·"·"timer16·write·addr:%u·value:%u"·"\n",·addr,·value);

1827

#line·1829·"trace/trace-hw_timer.h"

1827

#line·1829·"trace/trace-hw_timer.h"

1828

········}

1828

········}

1829

····}

1829

····}

1830

}

1830

}

1831

static·inline·void·trace_avr_timer16_write(uint8_t·addr,·uint8_t·value)

1831

static·inline·void·trace_avr_timer16_write(uint8_t·addr,·uint8_t·value)

1843

static·inline·void·_nocheck__trace_avr_timer16_write_imsk(uint8_t·value)

1843

static·inline·void·_nocheck__trace_avr_timer16_write_imsk(uint8_t·value)

1844

{

1844

{

1845

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

1845

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

1846

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

1846

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

1847

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

1847

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

1848

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

1848

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

1850

············qemu_log("%d@%zu.%06zu:avr_timer16_write_imsk·"·"timer16·write·addr:imsk·value:%u"·"\n",

1850

············qemu_log("%d@%zu.%06zu:avr_timer16_write_imsk·"·"timer16·write·addr:imsk·value:%u"·"\n",

1851

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

1851

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

1852

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

1852

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

1853

·····················,·value);

1853

·····················,·value);

1854

#line·1856·"trace/trace-hw_timer.h"

1854

#line·1856·"trace/trace-hw_timer.h"

1855

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

1855

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

1857

············qemu_log("avr_timer16_write_imsk·"·"timer16·write·addr:imsk·value:%u"·"\n",·value);

1857

············qemu_log("avr_timer16_write_imsk·"·"timer16·write·addr:imsk·value:%u"·"\n",·value);

1858

#line·1860·"trace/trace-hw_timer.h"

1858

#line·1860·"trace/trace-hw_timer.h"

1859

········}

1859

········}

1860

····}

1860

····}

1861

}

1861

}

1862

static·inline·void·trace_avr_timer16_write_imsk(uint8_t·value)

1862

static·inline·void·trace_avr_timer16_write_imsk(uint8_t·value)

1874

static·inline·void·_nocheck__trace_avr_timer16_interrupt_count(uint8_t·cnt)

1874

static·inline·void·_nocheck__trace_avr_timer16_interrupt_count(uint8_t·cnt)

1875

{

1875

{

1876

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

1876

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

1877

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

1877

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

1878

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

1878

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

1879

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

1879

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

1881

············qemu_log("%d@%zu.%06zu:avr_timer16_interrupt_count·"·"count:·%u"·"\n",

1881

············qemu_log("%d@%zu.%06zu:avr_timer16_interrupt_count·"·"count:·%u"·"\n",

1882

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

1882

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

1883

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

1883

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

1884

·····················,·cnt);

1884

·····················,·cnt);

1885

#line·1887·"trace/trace-hw_timer.h"

1885

#line·1887·"trace/trace-hw_timer.h"

1886

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

1886

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

1888

············qemu_log("avr_timer16_interrupt_count·"·"count:·%u"·"\n",·cnt);

1888

············qemu_log("avr_timer16_interrupt_count·"·"count:·%u"·"\n",·cnt);

1889

#line·1891·"trace/trace-hw_timer.h"

1889

#line·1891·"trace/trace-hw_timer.h"

1890

········}

1890

········}

1891

····}

1891

····}

1892

}

1892

}

1893

static·inline·void·trace_avr_timer16_interrupt_count(uint8_t·cnt)

1893

static·inline·void·trace_avr_timer16_interrupt_count(uint8_t·cnt)

1905

static·inline·void·_nocheck__trace_avr_timer16_interrupt_overflow(const·char·*·reason)

1905

static·inline·void·_nocheck__trace_avr_timer16_interrupt_overflow(const·char·*·reason)

1906

{

1906

{

1907

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

1907

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

1908

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

1908

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

1909

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

1909

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

1910

············gettimeofday(&_now,·NULL);

1910

············gettimeofday(&_now,·NULL);

1912

············qemu_log("%d@%zu.%06zu:avr_timer16_interrupt_overflow·"·"overflow:·%s"·"\n",

1912

············qemu_log("%d@%zu.%06zu:avr_timer16_interrupt_overflow·"·"overflow:·%s"·"\n",

1913

·····················qemu_get_thread_id(),

1913

·····················qemu_get_thread_id(),

1914

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1914

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1915

·····················,·reason);

1915

·····················,·reason);

1916

#line·1918·"trace/trace-hw_timer.h"

1916

#line·1918·"trace/trace-hw_timer.h"

1917

········}·else·{

1917

········}·else·{

1919

············qemu_log("avr_timer16_interrupt_overflow·"·"overflow:·%s"·"\n",·reason);

1919

············qemu_log("avr_timer16_interrupt_overflow·"·"overflow:·%s"·"\n",·reason);

1920

#line·1922·"trace/trace-hw_timer.h"

1920

#line·1922·"trace/trace-hw_timer.h"

1921

········}

1921

········}

1922

····}

1922

····}

1923

}

1923

}

1924

static·inline·void·trace_avr_timer16_interrupt_overflow(const·char·*·reason)

1924

static·inline·void·trace_avr_timer16_interrupt_overflow(const·char·*·reason)

1936

static·inline·void·_nocheck__trace_avr_timer16_next_alarm(uint64_t·delay_ns)

1936

static·inline·void·_nocheck__trace_avr_timer16_next_alarm(uint64_t·delay_ns)

1937

{

1937

{

1938

····if·(trace_event_get_state(TRACE_AVR_TIMER16_NEXT_ALARM)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1938

····if·(trace_event_get_state(TRACE_AVR_TIMER16_NEXT_ALARM)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1939

········if·(message_with_timestamp)·{

1939

········if·(message_with_timestamp)·{

1940

············struct·timeval·_now;

1940

············struct·timeval·_now;

1941

············gettimeofday(&_now,·NULL);

1941

············gettimeofday(&_now,·NULL);

1943

············qemu_log("%d@%zu.%06zu:avr_timer16_next_alarm·"·"next·alarm:·%"·PRIu64·"·ns·from·now"·"\n",

1943

············qemu_log("%d@%zu.%06zu:avr_timer16_next_alarm·"·"next·alarm:·%"·PRIu64·"·ns·from·now"·"\n",

1944

·····················qemu_get_thread_id(),

1944

·····················qemu_get_thread_id(),

1945

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1945

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1946

·····················,·delay_ns);

1946

·····················,·delay_ns);

1947

#line·1949·"trace/trace-hw_timer.h"

1947

#line·1949·"trace/trace-hw_timer.h"

1948

········}·else·{

1948

········}·else·{

1950

············qemu_log("avr_timer16_next_alarm·"·"next·alarm:·%"·PRIu64·"·ns·from·now"·"\n",·delay_ns);

1950

············qemu_log("avr_timer16_next_alarm·"·"next·alarm:·%"·PRIu64·"·ns·from·now"·"\n",·delay_ns);

1951

#line·1953·"trace/trace-hw_timer.h"

1951

#line·1953·"trace/trace-hw_timer.h"

1952

········}

1952

········}

1953

····}

1953

····}

1954

}

1954

}

1955

static·inline·void·trace_avr_timer16_next_alarm(uint64_t·delay_ns)

1955

static·inline·void·trace_avr_timer16_next_alarm(uint64_t·delay_ns)

1967

static·inline·void·_nocheck__trace_avr_timer16_clksrc_update(uint64_t·freq_hz,·uint64_t·period_ns,·uint64_t·delay_s)

1967

static·inline·void·_nocheck__trace_avr_timer16_clksrc_update(uint64_t·freq_hz,·uint64_t·period_ns,·uint64_t·delay_s)

1968

{

1968

{

1969

····if·(trace_event_get_state(TRACE_AVR_TIMER16_CLKSRC_UPDATE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1969

····if·(trace_event_get_state(TRACE_AVR_TIMER16_CLKSRC_UPDATE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1970

········if·(message_with_timestamp)·{

1970

········if·(message_with_timestamp)·{

1971

············struct·timeval·_now;

1971

············struct·timeval·_now;

1972

············gettimeofday(&_now,·NULL);

1972

············gettimeofday(&_now,·NULL);

1974

············qemu_log("%d@%zu.%06zu:avr_timer16_clksrc_update·"·"timer·frequency:·%"·PRIu64·"·Hz,·period:·%"·PRIu64·"·ns·(%"·PRId64·"·us)"·"\n",

1974

············qemu_log("%d@%zu.%06zu:avr_timer16_clksrc_update·"·"timer·frequency:·%"·PRIu64·"·Hz,·period:·%"·PRIu64·"·ns·(%"·PRId64·"·us)"·"\n",

1975

·····················qemu_get_thread_id(),

1975

·····················qemu_get_thread_id(),

1976

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1976

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1977

·····················,·freq_hz,·period_ns,·delay_s);

1977

·····················,·freq_hz,·period_ns,·delay_s);

1978

#line·1980·"trace/trace-hw_timer.h"

1978

#line·1980·"trace/trace-hw_timer.h"

1979

········}·else·{

1979

········}·else·{

1981

············qemu_log("avr_timer16_clksrc_update·"·"timer·frequency:·%"·PRIu64·"·Hz,·period:·%"·PRIu64·"·ns·(%"·PRId64·"·us)"·"\n",·freq_hz,·period_ns,·delay_s);

1981

············qemu_log("avr_timer16_clksrc_update·"·"timer·frequency:·%"·PRIu64·"·Hz,·period:·%"·PRIu64·"·ns·(%"·PRId64·"·us)"·"\n",·freq_hz,·period_ns,·delay_s);

1982

#line·1984·"trace/trace-hw_timer.h"

1982

#line·1984·"trace/trace-hw_timer.h"

1983

········}

1983

········}

1984

····}

1984

····}

1985

}

1985

}

1986

static·inline·void·trace_avr_timer16_clksrc_update(uint64_t·freq_hz,·uint64_t·period_ns,·uint64_t·delay_s)

1986

static·inline·void·trace_avr_timer16_clksrc_update(uint64_t·freq_hz,·uint64_t·period_ns,·uint64_t·delay_s)

1998

static·inline·void·_nocheck__trace_sse_counter_control_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

1998

static·inline·void·_nocheck__trace_sse_counter_control_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

1999

{

1999

{

2000

····if·(trace_event_get_state(TRACE_SSE_COUNTER_CONTROL_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2000

····if·(trace_event_get_state(TRACE_SSE_COUNTER_CONTROL_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2001

········if·(message_with_timestamp)·{

2001

········if·(message_with_timestamp)·{

2002

············struct·timeval·_now;

2002

············struct·timeval·_now;

2003

············gettimeofday(&_now,·NULL);

2003

············gettimeofday(&_now,·NULL);

2005

············qemu_log("%d@%zu.%06zu:sse_counter_control_read·"·"SSE·system·counter·control·frame·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",

2005

············qemu_log("%d@%zu.%06zu:sse_counter_control_read·"·"SSE·system·counter·control·frame·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",

2006

·····················qemu_get_thread_id(),

2006

·····················qemu_get_thread_id(),

2007

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2007

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2008

·····················,·offset,·data,·size);

2008

·····················,·offset,·data,·size);

2009

#line·2011·"trace/trace-hw_timer.h"

2009

#line·2011·"trace/trace-hw_timer.h"

2010

········}·else·{

2010

········}·else·{

2012

············qemu_log("sse_counter_control_read·"·"SSE·system·counter·control·frame·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",·offset,·data,·size);

2012

············qemu_log("sse_counter_control_read·"·"SSE·system·counter·control·frame·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",·offset,·data,·size);

2013

#line·2015·"trace/trace-hw_timer.h"

2013

#line·2015·"trace/trace-hw_timer.h"

2014

········}

2014

········}

2015

····}

2015

····}

2016

}

2016

}

2017

static·inline·void·trace_sse_counter_control_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

2017

static·inline·void·trace_sse_counter_control_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

2029

static·inline·void·_nocheck__trace_sse_counter_control_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

2029

static·inline·void·_nocheck__trace_sse_counter_control_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

2030

{

2030

{

2031

····if·(trace_event_get_state(TRACE_SSE_COUNTER_CONTROL_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2031

····if·(trace_event_get_state(TRACE_SSE_COUNTER_CONTROL_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2032

········if·(message_with_timestamp)·{

2032

········if·(message_with_timestamp)·{

2033

············struct·timeval·_now;

2033

············struct·timeval·_now;

2034

············gettimeofday(&_now,·NULL);

2034

············gettimeofday(&_now,·NULL);

2036

············qemu_log("%d@%zu.%06zu:sse_counter_control_write·"·"SSE·system·counter·control·framen·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",

2036

············qemu_log("%d@%zu.%06zu:sse_counter_control_write·"·"SSE·system·counter·control·framen·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",

2037

·····················qemu_get_thread_id(),

2037

·····················qemu_get_thread_id(),

2038

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2038

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2039

·····················,·offset,·data,·size);

2039

·····················,·offset,·data,·size);

2040

#line·2042·"trace/trace-hw_timer.h"

2040

#line·2042·"trace/trace-hw_timer.h"

2041

········}·else·{

2041

········}·else·{

2043

············qemu_log("sse_counter_control_write·"·"SSE·system·counter·control·framen·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",·offset,·data,·size);

2043

············qemu_log("sse_counter_control_write·"·"SSE·system·counter·control·framen·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",·offset,·data,·size);

2044

#line·2046·"trace/trace-hw_timer.h"

2044

#line·2046·"trace/trace-hw_timer.h"

2045

········}

2045

········}

2046

····}

2046

····}

2047

}

2047

}

2048

static·inline·void·trace_sse_counter_control_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

2048

static·inline·void·trace_sse_counter_control_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

2060

static·inline·void·_nocheck__trace_sse_counter_status_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

2060

static·inline·void·_nocheck__trace_sse_counter_status_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

2061

{

2061

{

2062

····if·(trace_event_get_state(TRACE_SSE_COUNTER_STATUS_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2062

····if·(trace_event_get_state(TRACE_SSE_COUNTER_STATUS_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2063

········if·(message_with_timestamp)·{

2063

········if·(message_with_timestamp)·{

2064

············struct·timeval·_now;

2064

············struct·timeval·_now;

2065

············gettimeofday(&_now,·NULL);

2065

············gettimeofday(&_now,·NULL);

2067

············qemu_log("%d@%zu.%06zu:sse_counter_status_read·"·"SSE·system·counter·status·frame·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",

2067

············qemu_log("%d@%zu.%06zu:sse_counter_status_read·"·"SSE·system·counter·status·frame·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",

2068

·····················qemu_get_thread_id(),

2068

·····················qemu_get_thread_id(),

2069

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2069

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2070

·····················,·offset,·data,·size);

2070

·····················,·offset,·data,·size);

2071

#line·2073·"trace/trace-hw_timer.h"

2071

#line·2073·"trace/trace-hw_timer.h"

2072

········}·else·{

2072

········}·else·{

2074

············qemu_log("sse_counter_status_read·"·"SSE·system·counter·status·frame·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",·offset,·data,·size);

2074

············qemu_log("sse_counter_status_read·"·"SSE·system·counter·status·frame·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",·offset,·data,·size);

2075

#line·2077·"trace/trace-hw_timer.h"

2075

#line·2077·"trace/trace-hw_timer.h"

2076

········}

2076

········}

2077

····}

2077

····}

2078

}

2078

}

2079

static·inline·void·trace_sse_counter_status_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

2079

static·inline·void·trace_sse_counter_status_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

2091

static·inline·void·_nocheck__trace_sse_counter_status_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

2091

static·inline·void·_nocheck__trace_sse_counter_status_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

2092

{

2092

{

2093

····if·(trace_event_get_state(TRACE_SSE_COUNTER_STATUS_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2093

····if·(trace_event_get_state(TRACE_SSE_COUNTER_STATUS_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2094

········if·(message_with_timestamp)·{

2094

········if·(message_with_timestamp)·{

2095

············struct·timeval·_now;

2095

············struct·timeval·_now;

2096

············gettimeofday(&_now,·NULL);

2096

············gettimeofday(&_now,·NULL);

2098

············qemu_log("%d@%zu.%06zu:sse_counter_status_write·"·"SSE·system·counter·status·frame·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",

2098

············qemu_log("%d@%zu.%06zu:sse_counter_status_write·"·"SSE·system·counter·status·frame·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",

2099

·····················qemu_get_thread_id(),

2099

·····················qemu_get_thread_id(),

2100

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2100

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2101

·····················,·offset,·data,·size);

2101

·····················,·offset,·data,·size);

2102

#line·2104·"trace/trace-hw_timer.h"

2102

#line·2104·"trace/trace-hw_timer.h"

2103

········}·else·{

2103

········}·else·{

2105

············qemu_log("sse_counter_status_write·"·"SSE·system·counter·status·frame·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",·offset,·data,·size);

2105

············qemu_log("sse_counter_status_write·"·"SSE·system·counter·status·frame·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",·offset,·data,·size);

2106

#line·2108·"trace/trace-hw_timer.h"

2106

#line·2108·"trace/trace-hw_timer.h"

2107

········}

2107

········}

2108

····}

2108

····}

2109

}

2109

}

2110

static·inline·void·trace_sse_counter_status_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

2110

static·inline·void·trace_sse_counter_status_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

2122

static·inline·void·_nocheck__trace_sse_counter_reset(void)

2122

static·inline·void·_nocheck__trace_sse_counter_reset(void)

2123

{

2123

{

2124

····if·(trace_event_get_state(TRACE_SSE_COUNTER_RESET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2124

····if·(trace_event_get_state(TRACE_SSE_COUNTER_RESET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2125

········if·(message_with_timestamp)·{

2125

········if·(message_with_timestamp)·{

2126

············struct·timeval·_now;

2126

············struct·timeval·_now;

2127

············gettimeofday(&_now,·NULL);

2127

············gettimeofday(&_now,·NULL);

2129

············qemu_log("%d@%zu.%06zu:sse_counter_reset·"·"SSE·system·counter:·reset"·"\n",

2129

············qemu_log("%d@%zu.%06zu:sse_counter_reset·"·"SSE·system·counter:·reset"·"\n",

2130

·····················qemu_get_thread_id(),

2130

·····················qemu_get_thread_id(),

2131

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2131

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2132

·····················);

2132

·····················);

2133

#line·2135·"trace/trace-hw_timer.h"

2133

#line·2135·"trace/trace-hw_timer.h"

2134

········}·else·{

2134

········}·else·{

2136

············qemu_log("sse_counter_reset·"·"SSE·system·counter:·reset"·"\n");

2136

············qemu_log("sse_counter_reset·"·"SSE·system·counter:·reset"·"\n");

2137

#line·2139·"trace/trace-hw_timer.h"

2137

#line·2139·"trace/trace-hw_timer.h"

2138

········}

2138

········}

2139

····}

2139

····}

2140

}

2140

}

2141

static·inline·void·trace_sse_counter_reset(void)

2141

static·inline·void·trace_sse_counter_reset(void)

2153

static·inline·void·_nocheck__trace_sse_timer_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

2153

static·inline·void·_nocheck__trace_sse_timer_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

2154

{

2154

{

2155

····if·(trace_event_get_state(TRACE_SSE_TIMER_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2155

····if·(trace_event_get_state(TRACE_SSE_TIMER_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2156

········if·(message_with_timestamp)·{

2156

········if·(message_with_timestamp)·{

2157

············struct·timeval·_now;

2157

············struct·timeval·_now;

2158

············gettimeofday(&_now,·NULL);

2158

············gettimeofday(&_now,·NULL);

2160

············qemu_log("%d@%zu.%06zu:sse_timer_read·"·"SSE·system·timer·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",

2160

············qemu_log("%d@%zu.%06zu:sse_timer_read·"·"SSE·system·timer·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",

2161

·····················qemu_get_thread_id(),

2161

·····················qemu_get_thread_id(),

2162

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2162

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2163

·····················,·offset,·data,·size);

2163

·····················,·offset,·data,·size);

2164

#line·2166·"trace/trace-hw_timer.h"

2164

#line·2166·"trace/trace-hw_timer.h"

2165

········}·else·{

2165

········}·else·{

2167

············qemu_log("sse_timer_read·"·"SSE·system·timer·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",·offset,·data,·size);

2167

············qemu_log("sse_timer_read·"·"SSE·system·timer·read:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",·offset,·data,·size);

2168

#line·2170·"trace/trace-hw_timer.h"

2168

#line·2170·"trace/trace-hw_timer.h"

2169

········}

2169

········}

2170

····}

2170

····}

2171

}

2171

}

2172

static·inline·void·trace_sse_timer_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

2172

static·inline·void·trace_sse_timer_read(uint64_t·offset,·uint64_t·data,·unsigned·size)

2184

static·inline·void·_nocheck__trace_sse_timer_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

2184

static·inline·void·_nocheck__trace_sse_timer_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

2185

{

2185

{

2186

····if·(trace_event_get_state(TRACE_SSE_TIMER_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2186

····if·(trace_event_get_state(TRACE_SSE_TIMER_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2187

········if·(message_with_timestamp)·{

2187

········if·(message_with_timestamp)·{

2188

············struct·timeval·_now;

2188

············struct·timeval·_now;

2189

············gettimeofday(&_now,·NULL);

2189

············gettimeofday(&_now,·NULL);

2191

············qemu_log("%d@%zu.%06zu:sse_timer_write·"·"SSE·system·timer·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",

2191

············qemu_log("%d@%zu.%06zu:sse_timer_write·"·"SSE·system·timer·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",

2192

·····················qemu_get_thread_id(),

2192

·····················qemu_get_thread_id(),

2193

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2193

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2194

·····················,·offset,·data,·size);

2194

·····················,·offset,·data,·size);

2195

#line·2197·"trace/trace-hw_timer.h"

2195

#line·2197·"trace/trace-hw_timer.h"

2196

········}·else·{

2196

········}·else·{

2198

············qemu_log("sse_timer_write·"·"SSE·system·timer·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",·offset,·data,·size);

2198

············qemu_log("sse_timer_write·"·"SSE·system·timer·write:·offset·0x%"·PRIx64·"·data·0x%"·PRIx64·"·size·%u"·"\n",·offset,·data,·size);

2199

#line·2201·"trace/trace-hw_timer.h"

2199

#line·2201·"trace/trace-hw_timer.h"

2200

········}

2200

········}

2201

····}

2201

····}

2202

}

2202

}

2203

static·inline·void·trace_sse_timer_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

2203

static·inline·void·trace_sse_timer_write(uint64_t·offset,·uint64_t·data,·unsigned·size)

2215

static·inline·void·_nocheck__trace_sse_timer_reset(void)

2215

static·inline·void·_nocheck__trace_sse_timer_reset(void)

2216

{

2216

{

2217

····if·(trace_event_get_state(TRACE_SSE_TIMER_RESET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2217

····if·(trace_event_get_state(TRACE_SSE_TIMER_RESET)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2218

········if·(message_with_timestamp)·{

2218

········if·(message_with_timestamp)·{

2219

············struct·timeval·_now;

2219

············struct·timeval·_now;

2220

············gettimeofday(&_now,·NULL);

2220

············gettimeofday(&_now,·NULL);

2222

············qemu_log("%d@%zu.%06zu:sse_timer_reset·"·"SSE·system·timer:·reset"·"\n",

2222

············qemu_log("%d@%zu.%06zu:sse_timer_reset·"·"SSE·system·timer:·reset"·"\n",

2223

·····················qemu_get_thread_id(),

2223

·····················qemu_get_thread_id(),

2224

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2224

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2225

·····················);

2225

·····················);

2226

#line·2228·"trace/trace-hw_timer.h"

2226

#line·2228·"trace/trace-hw_timer.h"

2227

········}·else·{

2227

········}·else·{

2229

············qemu_log("sse_timer_reset·"·"SSE·system·timer:·reset"·"\n");

2229

············qemu_log("sse_timer_reset·"·"SSE·system·timer:·reset"·"\n");

2230

#line·2232·"trace/trace-hw_timer.h"

2230

#line·2232·"trace/trace-hw_timer.h"

2231

········}

2231

········}

2232

····}

2232

····}

2233

}

2233

}

2234

static·inline·void·trace_sse_timer_reset(void)

2234

static·inline·void·trace_sse_timer_reset(void)

2246

static·inline·void·_nocheck__trace_sifive_pwm_set_alarm(uint64_t·alarm,·uint64_t·now)

2246

static·inline·void·_nocheck__trace_sifive_pwm_set_alarm(uint64_t·alarm,·uint64_t·now)

2247

{

2247

{

2248

····if·(trace_event_get_state(TRACE_SIFIVE_PWM_SET_ALARM)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2248

····if·(trace_event_get_state(TRACE_SIFIVE_PWM_SET_ALARM)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2249

········if·(message_with_timestamp)·{

2249

········if·(message_with_timestamp)·{

2250

············struct·timeval·_now;

2250

············struct·timeval·_now;

2251

············gettimeofday(&_now,·NULL);

2251

············gettimeofday(&_now,·NULL);

2253

············qemu_log("%d@%zu.%06zu:sifive_pwm_set_alarm·"·"Setting·alarm·to:·0x%"·PRIx64·",·now:·0x%"·PRIx64·"\n",

2253

············qemu_log("%d@%zu.%06zu:sifive_pwm_set_alarm·"·"Setting·alarm·to:·0x%"·PRIx64·",·now:·0x%"·PRIx64·"\n",

2254

·····················qemu_get_thread_id(),

2254

·····················qemu_get_thread_id(),

2255

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2255

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2256

·····················,·alarm,·now);

2256

·····················,·alarm,·now);

2257

#line·2259·"trace/trace-hw_timer.h"

2257

#line·2259·"trace/trace-hw_timer.h"

2258

········}·else·{

2258

········}·else·{

2260

············qemu_log("sifive_pwm_set_alarm·"·"Setting·alarm·to:·0x%"·PRIx64·",·now:·0x%"·PRIx64·"\n",·alarm,·now);

2260

············qemu_log("sifive_pwm_set_alarm·"·"Setting·alarm·to:·0x%"·PRIx64·",·now:·0x%"·PRIx64·"\n",·alarm,·now);

2261

#line·2263·"trace/trace-hw_timer.h"

2261

#line·2263·"trace/trace-hw_timer.h"

2262

········}

2262

········}

2263

····}

2263

····}

2264

}

2264

}

2265

static·inline·void·trace_sifive_pwm_set_alarm(uint64_t·alarm,·uint64_t·now)

2265

static·inline·void·trace_sifive_pwm_set_alarm(uint64_t·alarm,·uint64_t·now)

2277

static·inline·void·_nocheck__trace_sifive_pwm_interrupt(int·num)

2277

static·inline·void·_nocheck__trace_sifive_pwm_interrupt(int·num)

2278

{

2278

{

2279

····if·(trace_event_get_state(TRACE_SIFIVE_PWM_INTERRUPT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2279

····if·(trace_event_get_state(TRACE_SIFIVE_PWM_INTERRUPT)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2280

········if·(message_with_timestamp)·{

2280

········if·(message_with_timestamp)·{

2281

············struct·timeval·_now;

2281

············struct·timeval·_now;

2282

············gettimeofday(&_now,·NULL);

2282

············gettimeofday(&_now,·NULL);

2284

············qemu_log("%d@%zu.%06zu:sifive_pwm_interrupt·"·"Interrupt·%d"·"\n",

2284

············qemu_log("%d@%zu.%06zu:sifive_pwm_interrupt·"·"Interrupt·%d"·"\n",

2285

·····················qemu_get_thread_id(),

2285

·····················qemu_get_thread_id(),

2286

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2286

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2287

·····················,·num);

2287

·····················,·num);

2288

#line·2290·"trace/trace-hw_timer.h"

2288

#line·2290·"trace/trace-hw_timer.h"

2289

········}·else·{

2289

········}·else·{

2291

············qemu_log("sifive_pwm_interrupt·"·"Interrupt·%d"·"\n",·num);

2291

············qemu_log("sifive_pwm_interrupt·"·"Interrupt·%d"·"\n",·num);

2292

#line·2294·"trace/trace-hw_timer.h"

2292

#line·2294·"trace/trace-hw_timer.h"

2293

········}

2293

········}

2294

····}

2294

····}

2295

}

2295

}

2296

static·inline·void·trace_sifive_pwm_interrupt(int·num)

2296

static·inline·void·trace_sifive_pwm_interrupt(int·num)

2308

static·inline·void·_nocheck__trace_sifive_pwm_read(uint64_t·offset)

2308

static·inline·void·_nocheck__trace_sifive_pwm_read(uint64_t·offset)

2309

{

2309

{

2310

····if·(trace_event_get_state(TRACE_SIFIVE_PWM_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2310

····if·(trace_event_get_state(TRACE_SIFIVE_PWM_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2311

········if·(message_with_timestamp)·{

2311

········if·(message_with_timestamp)·{

2312

············struct·timeval·_now;

2312

············struct·timeval·_now;

2313

············gettimeofday(&_now,·NULL);

2313

············gettimeofday(&_now,·NULL);

2315

············qemu_log("%d@%zu.%06zu:sifive_pwm_read·"·"Read·at·address:·0x%"·PRIx64·"\n",

2315

············qemu_log("%d@%zu.%06zu:sifive_pwm_read·"·"Read·at·address:·0x%"·PRIx64·"\n",

2316

·····················qemu_get_thread_id(),

2316

·····················qemu_get_thread_id(),

2317

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2317

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2318

·····················,·offset);

2318

·····················,·offset);

2319

#line·2321·"trace/trace-hw_timer.h"

2319

#line·2321·"trace/trace-hw_timer.h"

2320

········}·else·{

2320

········}·else·{

2322

············qemu_log("sifive_pwm_read·"·"Read·at·address:·0x%"·PRIx64·"\n",·offset);

2322

············qemu_log("sifive_pwm_read·"·"Read·at·address:·0x%"·PRIx64·"\n",·offset);

2323

#line·2325·"trace/trace-hw_timer.h"

2323

#line·2325·"trace/trace-hw_timer.h"

2324

········}

2324

········}

2325

····}

2325

····}

2326

}

2326

}

2327

static·inline·void·trace_sifive_pwm_read(uint64_t·offset)

2327

static·inline·void·trace_sifive_pwm_read(uint64_t·offset)

2339

static·inline·void·_nocheck__trace_sifive_pwm_write(uint64_t·data,·uint64_t·offset)

2339

static·inline·void·_nocheck__trace_sifive_pwm_write(uint64_t·data,·uint64_t·offset)

2340

{

2340

{

2341

····if·(trace_event_get_state(TRACE_SIFIVE_PWM_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2341

····if·(trace_event_get_state(TRACE_SIFIVE_PWM_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2342

········if·(message_with_timestamp)·{

2342

········if·(message_with_timestamp)·{

2343

············struct·timeval·_now;

2343

············struct·timeval·_now;

2344

············gettimeofday(&_now,·NULL);

2344

············gettimeofday(&_now,·NULL);

2346

············qemu_log("%d@%zu.%06zu:sifive_pwm_write·"·"Write·0x%"·PRIx64·"·at·address:·0x%"·PRIx64·"\n",

2346

············qemu_log("%d@%zu.%06zu:sifive_pwm_write·"·"Write·0x%"·PRIx64·"·at·address:·0x%"·PRIx64·"\n",

2347

·····················qemu_get_thread_id(),

2347

·····················qemu_get_thread_id(),

2348

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2348

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2349

·····················,·data,·offset);

2349

·····················,·data,·offset);

2350

#line·2352·"trace/trace-hw_timer.h"

2350

#line·2352·"trace/trace-hw_timer.h"

2351

········}·else·{

2351

········}·else·{

2353

············qemu_log("sifive_pwm_write·"·"Write·0x%"·PRIx64·"·at·address:·0x%"·PRIx64·"\n",·data,·offset);

2353

············qemu_log("sifive_pwm_write·"·"Write·0x%"·PRIx64·"·at·address:·0x%"·PRIx64·"\n",·data,·offset);

2354

#line·2356·"trace/trace-hw_timer.h"

2354

#line·2356·"trace/trace-hw_timer.h"

2355

········}

2355

········}

2356

····}

2356

····}

2357

}

2357

}

2358

static·inline·void·trace_sifive_pwm_write(uint64_t·data,·uint64_t·offset)

2358

static·inline·void·trace_sifive_pwm_write(uint64_t·data,·uint64_t·offset)

2370

static·inline·void·_nocheck__trace_sh_timer_start_stop(int·enable,·int·current)

2370

static·inline·void·_nocheck__trace_sh_timer_start_stop(int·enable,·int·current)

2371

{

2371

{

2372

····if·(trace_event_get_state(TRACE_SH_TIMER_START_STOP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2372

····if·(trace_event_get_state(TRACE_SH_TIMER_START_STOP)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2373

········if·(message_with_timestamp)·{

2373

········if·(message_with_timestamp)·{

2374

············struct·timeval·_now;

2374

············struct·timeval·_now;

2375

············gettimeofday(&_now,·NULL);

2375

············gettimeofday(&_now,·NULL);

2377

············qemu_log("%d@%zu.%06zu:sh_timer_start_stop·"·"%d·(%d)"·"\n",

2377

············qemu_log("%d@%zu.%06zu:sh_timer_start_stop·"·"%d·(%d)"·"\n",

2378

·····················qemu_get_thread_id(),

2378

·····················qemu_get_thread_id(),

2379

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2379

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2380

·····················,·enable,·current);

2380

·····················,·enable,·current);

2381

#line·2383·"trace/trace-hw_timer.h"

2381

#line·2383·"trace/trace-hw_timer.h"

2382

········}·else·{

2382

········}·else·{

2384

············qemu_log("sh_timer_start_stop·"·"%d·(%d)"·"\n",·enable,·current);

2384

············qemu_log("sh_timer_start_stop·"·"%d·(%d)"·"\n",·enable,·current);

2385

#line·2387·"trace/trace-hw_timer.h"

2385

#line·2387·"trace/trace-hw_timer.h"

2386

········}

2386

········}

2387

····}

2387

····}

2388

}

2388

}

2389

static·inline·void·trace_sh_timer_start_stop(int·enable,·int·current)

2389

static·inline·void·trace_sh_timer_start_stop(int·enable,·int·current)

2401

static·inline·void·_nocheck__trace_sh_timer_read(uint64_t·offset)

2401

static·inline·void·_nocheck__trace_sh_timer_read(uint64_t·offset)

2402

{

2402

{

2403

····if·(trace_event_get_state(TRACE_SH_TIMER_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2403

····if·(trace_event_get_state(TRACE_SH_TIMER_READ)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2404

········if·(message_with_timestamp)·{

2404

········if·(message_with_timestamp)·{

2405

············struct·timeval·_now;

2405

············struct·timeval·_now;

2406

············gettimeofday(&_now,·NULL);

2406

············gettimeofday(&_now,·NULL);

2408

············qemu_log("%d@%zu.%06zu:sh_timer_read·"·"tmu012_read·0x%"·PRIx64·"\n",

2408

············qemu_log("%d@%zu.%06zu:sh_timer_read·"·"tmu012_read·0x%"·PRIx64·"\n",

2409

·····················qemu_get_thread_id(),

2409

·····················qemu_get_thread_id(),

2410

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2410

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2411

·····················,·offset);

2411

·····················,·offset);

2412

#line·2414·"trace/trace-hw_timer.h"

2412

#line·2414·"trace/trace-hw_timer.h"

2413

········}·else·{

2413

········}·else·{

2415

············qemu_log("sh_timer_read·"·"tmu012_read·0x%"·PRIx64·"\n",·offset);

2415

············qemu_log("sh_timer_read·"·"tmu012_read·0x%"·PRIx64·"\n",·offset);

2416

#line·2418·"trace/trace-hw_timer.h"

2416

#line·2418·"trace/trace-hw_timer.h"

2417

········}

2417

········}

2418

····}

2418

····}

2419

}

2419

}

2420

static·inline·void·trace_sh_timer_read(uint64_t·offset)

2420

static·inline·void·trace_sh_timer_read(uint64_t·offset)

2432

static·inline·void·_nocheck__trace_sh_timer_write(uint64_t·offset,·uint64_t·value)

2432

static·inline·void·_nocheck__trace_sh_timer_write(uint64_t·offset,·uint64_t·value)

2433

{

2433

{

2434

····if·(trace_event_get_state(TRACE_SH_TIMER_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2434

····if·(trace_event_get_state(TRACE_SH_TIMER_WRITE)·&&·qemu_loglevel_mask(LOG_TRACE))·{

2435

········if·(message_with_timestamp)·{

2435

········if·(message_with_timestamp)·{

2436

············struct·timeval·_now;

2436

············struct·timeval·_now;

2437

············gettimeofday(&_now,·NULL);

2437

············gettimeofday(&_now,·NULL);

2439

············qemu_log("%d@%zu.%06zu:sh_timer_write·"·"tmu012_write·0x%"·PRIx64·"·0x%08"·PRIx64·"\n",

2439

············qemu_log("%d@%zu.%06zu:sh_timer_write·"·"tmu012_write·0x%"·PRIx64·"·0x%08"·PRIx64·"\n",

2440

·····················qemu_get_thread_id(),

2440

·····················qemu_get_thread_id(),

2441

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2441

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2442

·····················,·offset,·value);

2442

·····················,·offset,·value);

2443

#line·2445·"trace/trace-hw_timer.h"

2443

#line·2445·"trace/trace-hw_timer.h"

2444

········}·else·{

2444

········}·else·{

2446

············qemu_log("sh_timer_write·"·"tmu012_write·0x%"·PRIx64·"·0x%08"·PRIx64·"\n",·offset,·value);

2446

············qemu_log("sh_timer_write·"·"tmu012_write·0x%"·PRIx64·"·0x%08"·PRIx64·"\n",·offset,·value);

2447

#line·2449·"trace/trace-hw_timer.h"

2447

#line·2449·"trace/trace-hw_timer.h"

2448

········}

2448

········}

2449

····}

2449

····}

2450

}

2450

}

2451

static·inline·void·trace_sh_timer_write(uint64_t·offset,·uint64_t·value)

2451

static·inline·void·trace_sh_timer_write(uint64_t·offset,·uint64_t·value)