~jderose/ubuntu/raring/qemu/vde-again

« back to all changes in this revision

Viewing changes to gdbstub.c

• browse files at revision 1.1.7
• compare with another revision
• download diff
• download tarball
• view history from revision 1.1.7

Show diffs side-by-side

added

removed

gdbstub.c

307

307

    registers[98] = tswapl(tmp);

308

308

    registers[99] = tswapl(env->lr);

309

309

    registers[100] = tswapl(env->ctr);

310

 

    registers[101] = tswapl(do_load_xer(env));

 

310

    registers[101] = tswapl(ppc_load_xer(env));

311

311

    registers[102] = 0;

312

312

 

313

313

    return 103 * 4;

335

335

        env->crf[i] = (registers[98] >> (32 - ((i + 1) * 4))) & 0xF;

336

336

    env->lr = tswapl(registers[99]);

337

337

    env->ctr = tswapl(registers[100]);

338

 

    do_store_xer(env, tswapl(registers[101]));

 

338

    ppc_store_xer(env, tswapl(registers[101]));

339

339

}

340

340

#elif defined (TARGET_SPARC)

341

341

static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)

377

377

    for (i = 0; i < 64; i += 2) {

378

378

        uint64_t tmp;

379

379

 

380

 

        tmp = (uint64_t)tswap32(*((uint32_t *)&env->fpr[i])) << 32;

381

 

        tmp |= tswap32(*((uint32_t *)&env->fpr[i + 1]));

382

 

        registers[i/2 + 32] = tmp;

 

380

        tmp = ((uint64_t)*(uint32_t *)&env->fpr[i]) << 32;

 

381

        tmp |= *(uint32_t *)&env->fpr[i + 1];

 

382

        registers[i / 2 + 32] = tswap64(tmp);

383

383

    }

384

384

    registers[64] = tswapl(env->pc);

385

385

    registers[65] = tswapl(env->npc);

386

 

    registers[66] = tswapl(env->tstate[env->tl]);

 

386

    registers[66] = tswapl(((uint64_t)GET_CCR(env) << 32) |

 

387

                           ((env->asi & 0xff) << 24) |

 

388

                           ((env->pstate & 0xfff) << 8) |

 

389

                           GET_CWP64(env));

387

390

    registers[67] = tswapl(env->fsr);

388

391

    registers[68] = tswapl(env->fprs);

389

392

    registers[69] = tswapl(env->y);

419

422

    env->fsr = tswapl(registers[70]);

420

423

#else

421

424

    for (i = 0; i < 64; i += 2) {

422

 

        *((uint32_t *)&env->fpr[i]) = tswap32(registers[i/2 + 32] >> 32);

423

 

        *((uint32_t *)&env->fpr[i + 1]) = tswap32(registers[i/2 + 32] & 0xffffffff);

 

425

        uint64_t tmp;

 

426

 

 

427

        tmp = tswap64(registers[i / 2 + 32]);

 

428

        *((uint32_t *)&env->fpr[i]) = tmp >> 32;

 

429

        *((uint32_t *)&env->fpr[i + 1]) = tmp & 0xffffffff;

424

430

    }

425

431

    env->pc = tswapl(registers[64]);

426

432

    env->npc = tswapl(registers[65]);

427

 

    env->tstate[env->tl] = tswapl(registers[66]);

 

433

    {

 

434

        uint64_t tmp = tswapl(registers[66]);

 

435

 

 

436

        PUT_CCR(env, tmp >> 32);

 

437

        env->asi = (tmp >> 24) & 0xff;

 

438

        env->pstate = (tmp >> 8) & 0xfff;

 

439

        PUT_CWP64(env, tmp & 0xff);

 

440

    }

428

441

    env->fsr = tswapl(registers[67]);

429

442

    env->fprs = tswapl(registers[68]);

430

443

    env->y = tswapl(registers[69]);

546

559

    ptr = mem_buf;

547

560

    for (i = 0; i < 32; i++)

548

561

      {

549

 

        *(uint32_t *)ptr = tswapl(env->gpr[i]);

550

 

        ptr += 4;

 

562

        *(target_ulong *)ptr = tswapl(env->gpr[i]);

 

563

        ptr += sizeof(target_ulong);

551

564

      }

552

565

 

553

 

    *(uint32_t *)ptr = tswapl(env->CP0_Status);

554

 

    ptr += 4;

555

 

 

556

 

    *(uint32_t *)ptr = tswapl(env->LO);

557

 

    ptr += 4;

558

 

 

559

 

    *(uint32_t *)ptr = tswapl(env->HI);

560

 

    ptr += 4;

561

 

 

562

 

    *(uint32_t *)ptr = tswapl(env->CP0_BadVAddr);

563

 

    ptr += 4;

564

 

 

565

 

    *(uint32_t *)ptr = tswapl(env->CP0_Cause);

566

 

    ptr += 4;

567

 

 

568

 

    *(uint32_t *)ptr = tswapl(env->PC);

569

 

    ptr += 4;

570

 

 

571

 

#ifdef MIPS_USES_FPU

572

 

    for (i = 0; i < 32; i++)

 

566

    *(target_ulong *)ptr = tswapl(env->CP0_Status);

 

567

    ptr += sizeof(target_ulong);

 

568

 

 

569

    *(target_ulong *)ptr = tswapl(env->LO);

 

570

    ptr += sizeof(target_ulong);

 

571

 

 

572

    *(target_ulong *)ptr = tswapl(env->HI);

 

573

    ptr += sizeof(target_ulong);

 

574

 

 

575

    *(target_ulong *)ptr = tswapl(env->CP0_BadVAddr);

 

576

    ptr += sizeof(target_ulong);

 

577

 

 

578

    *(target_ulong *)ptr = tswapl(env->CP0_Cause);

 

579

    ptr += sizeof(target_ulong);

 

580

 

 

581

    *(target_ulong *)ptr = tswapl(env->PC);

 

582

    ptr += sizeof(target_ulong);

 

583

 

 

584

    if (env->CP0_Config1 & (1 << CP0C1_FP))

573

585

      {

574

 

        *(uint32_t *)ptr = tswapl(FPR_W (env, i));

575

 

        ptr += 4;

 

586

        for (i = 0; i < 32; i++)

 

587

          {

 

588

            *(target_ulong *)ptr = tswapl(env->fpr[i].fs[FP_ENDIAN_IDX]);

 

589

            ptr += sizeof(target_ulong);

 

590

          }

 

591

 

 

592

        *(target_ulong *)ptr = tswapl(env->fcr31);

 

593

        ptr += sizeof(target_ulong);

 

594

 

 

595

        *(target_ulong *)ptr = tswapl(env->fcr0);

 

596

        ptr += sizeof(target_ulong);

576

597

      }

577

598

 

578

 

    *(uint32_t *)ptr = tswapl(env->fcr31);

579

 

    ptr += 4;

580

 

 

581

 

    *(uint32_t *)ptr = tswapl(env->fcr0);

582

 

    ptr += 4;

583

 

#endif

584

 

 

585

599

    /* 32 FP registers, fsr, fir, fp.  Not yet implemented.  */

586

600

    /* what's 'fp' mean here?  */

587

601

 

607

621

    ptr = mem_buf;

608

622

    for (i = 0; i < 32; i++)

609

623

      {

610

 

        env->gpr[i] = tswapl(*(uint32_t *)ptr);

611

 

        ptr += 4;

 

624

        env->gpr[i] = tswapl(*(target_ulong *)ptr);

 

625

        ptr += sizeof(target_ulong);

612

626

      }

613

627

 

614

 

    env->CP0_Status = tswapl(*(uint32_t *)ptr);

615

 

    ptr += 4;

616

 

 

617

 

    env->LO = tswapl(*(uint32_t *)ptr);

618

 

    ptr += 4;

619

 

 

620

 

    env->HI = tswapl(*(uint32_t *)ptr);

621

 

    ptr += 4;

622

 

 

623

 

    env->CP0_BadVAddr = tswapl(*(uint32_t *)ptr);

624

 

    ptr += 4;

625

 

 

626

 

    env->CP0_Cause = tswapl(*(uint32_t *)ptr);

627

 

    ptr += 4;

628

 

 

629

 

    env->PC = tswapl(*(uint32_t *)ptr);

630

 

    ptr += 4;

631

 

 

632

 

#ifdef MIPS_USES_FPU

633

 

    for (i = 0; i < 32; i++)

 

628

    env->CP0_Status = tswapl(*(target_ulong *)ptr);

 

629

    ptr += sizeof(target_ulong);

 

630

 

 

631

    env->LO = tswapl(*(target_ulong *)ptr);

 

632

    ptr += sizeof(target_ulong);

 

633

 

 

634

    env->HI = tswapl(*(target_ulong *)ptr);

 

635

    ptr += sizeof(target_ulong);

 

636

 

 

637

    env->CP0_BadVAddr = tswapl(*(target_ulong *)ptr);

 

638

    ptr += sizeof(target_ulong);

 

639

 

 

640

    env->CP0_Cause = tswapl(*(target_ulong *)ptr);

 

641

    ptr += sizeof(target_ulong);

 

642

 

 

643

    env->PC = tswapl(*(target_ulong *)ptr);

 

644

    ptr += sizeof(target_ulong);

 

645

 

 

646

    if (env->CP0_Config1 & (1 << CP0C1_FP))

634

647

      {

635

 

        FPR_W (env, i) = tswapl(*(uint32_t *)ptr);

636

 

        ptr += 4;

637

 

      }

638

 

 

639

 

    env->fcr31 = tswapl(*(uint32_t *)ptr) & 0x0183FFFF;

640

 

    ptr += 4;

641

 

 

642

 

    env->fcr0 = tswapl(*(uint32_t *)ptr);

643

 

    ptr += 4;

644

 

 

645

 

    /* set rounding mode */

646

 

    RESTORE_ROUNDING_MODE;

 

648

        for (i = 0; i < 32; i++)

 

649

          {

 

650

            env->fpr[i].fs[FP_ENDIAN_IDX] = tswapl(*(target_ulong *)ptr);

 

651

            ptr += sizeof(target_ulong);

 

652

          }

 

653

 

 

654

        env->fcr31 = tswapl(*(target_ulong *)ptr) & 0x0183FFFF;

 

655

        ptr += sizeof(target_ulong);

 

656

 

 

657

        env->fcr0 = tswapl(*(target_ulong *)ptr);

 

658

        ptr += sizeof(target_ulong);

 

659

 

 

660

        /* set rounding mode */

 

661

        RESTORE_ROUNDING_MODE;

647

662

 

648

663

#ifndef CONFIG_SOFTFLOAT

649

 

    /* no floating point exception for native float */

650

 

    SET_FP_ENABLE(env->fcr31, 0);

651

 

#endif

652

 

#endif

 

664

        /* no floating point exception for native float */

 

665

        SET_FP_ENABLE(env->fcr31, 0);

 

666

#endif

 

667

      }

653

668

}

654

669

#elif defined (TARGET_SH4)

 

670

 

 

671

/* Hint: Use "set architecture sh4" in GDB to see fpu registers */

 

672

 

655

673

static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)

656

674

{

657

675

  uint32_t *ptr = (uint32_t *)mem_buf;

671

689

  SAVE (env->mach);

672

690

  SAVE (env->macl);

673

691

  SAVE (env->sr);

674

 

  SAVE (0); /* TICKS */

675

 

  SAVE (0); /* STALLS */

676

 

  SAVE (0); /* CYCLES */

677

 

  SAVE (0); /* INSTS */

678

 

  SAVE (0); /* PLR */

679

 

 

 

692

  SAVE (env->fpul);

 

693

  SAVE (env->fpscr);

 

694

  for (i = 0; i < 16; i++)

 

695

      SAVE(env->fregs[i + ((env->fpscr & FPSCR_FR) ? 16 : 0)]);

 

696

  SAVE (env->ssr);

 

697

  SAVE (env->spc);

 

698

  for (i = 0; i < 8; i++) SAVE(env->gregs[i]);

 

699

  for (i = 0; i < 8; i++) SAVE(env->gregs[i + 16]);

680

700

  return ((uint8_t *)ptr - mem_buf);

681

701

}

682

702

 

699

719

  LOAD (env->mach);

700

720

  LOAD (env->macl);

701

721

  LOAD (env->sr);

 

722

  LOAD (env->fpul);

 

723

  LOAD (env->fpscr);

 

724

  for (i = 0; i < 16; i++)

 

725

      LOAD(env->fregs[i + ((env->fpscr & FPSCR_FR) ? 16 : 0)]);

 

726

  LOAD (env->ssr);

 

727

  LOAD (env->spc);

 

728

  for (i = 0; i < 8; i++) LOAD(env->gregs[i]);

 

729

  for (i = 0; i < 8; i++) LOAD(env->gregs[i + 16]);

702

730

}

703

731

#else

704

732

static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)

745

773

#elif defined (TARGET_ARM)

746

774

            env->regs[15] = addr;

747

775

#elif defined (TARGET_SH4)

748

 

            env->pc = addr;

 

776

            env->pc = addr;

 

777

#elif defined (TARGET_MIPS)

 

778

            env->PC = addr;

749

779

#endif

750

780

        }

751

781

#ifdef CONFIG_USER_ONLY

756

786

        return RS_IDLE;

757

787

    case 's':

758

788

        if (*p != '\0') {

759

 

            addr = strtoul(p, (char **)&p, 16);

 

789

            addr = strtoull(p, (char **)&p, 16);

760

790

#if defined(TARGET_I386)

761

791

            env->eip = addr;

762

792

#elif defined (TARGET_PPC)

767

797

#elif defined (TARGET_ARM)

768

798

            env->regs[15] = addr;

769

799

#elif defined (TARGET_SH4)

770

 

            env->pc = addr;

 

800

            env->pc = addr;

 

801

#elif defined (TARGET_MIPS)

 

802

            env->PC = addr;

771

803

#endif

772

804

        }

773

805

        cpu_single_step(env, 1);

854

886

            if (cpu_breakpoint_insert(env, addr) < 0)

855

887

                goto breakpoint_error;

856

888

            put_packet(s, "OK");

 

889

#ifndef CONFIG_USER_ONLY

 

890

        } else if (type == 2) {

 

891

            if (cpu_watchpoint_insert(env, addr) < 0)

 

892

                goto breakpoint_error;

 

893

            put_packet(s, "OK");

 

894

#endif

857

895

        } else {

858

896

        breakpoint_error:

859

897

            put_packet(s, "E22");

870

908

        if (type == 0 || type == 1) {

871

909

            cpu_breakpoint_remove(env, addr);

872

910

            put_packet(s, "OK");

 

911

#ifndef CONFIG_USER_ONLY

 

912

        } else if (type == 2) {

 

913

            cpu_watchpoint_remove(env, addr);

 

914

            put_packet(s, "OK");

 

915

#endif

873

916

        } else {

874

917

            goto breakpoint_error;

875

918

        }

879

922

        if (strncmp(p, "Offsets", 7) == 0) {

880

923

            TaskState *ts = env->opaque;

881

924

 

882

 

            sprintf(buf, "Text=%x;Data=%x;Bss=%x", ts->info->code_offset,

883

 

                ts->info->data_offset, ts->info->data_offset);

 

925

            sprintf(buf,

 

926

                    "Text=" TARGET_FMT_lx ";Data=" TARGET_FMT_lx ";Bss=" TARGET_FMT_lx,

 

927

                    ts->info->code_offset,

 

928

                    ts->info->data_offset,

 

929

                    ts->info->data_offset);

884

930

            put_packet(s, buf);

885

931

            break;

886

932

        }

912

958

    cpu_single_step(s->env, 0);

913

959

 

914

960

    if (reason == EXCP_DEBUG) {

 

961

        if (s->env->watchpoint_hit) {

 

962

            snprintf(buf, sizeof(buf), "T%02xwatch:" TARGET_FMT_lx ";",

 

963

                     SIGTRAP,

 

964

                     s->env->watchpoint[s->env->watchpoint_hit - 1].vaddr);

 

965

            put_packet(s, buf);

 

966

            s->env->watchpoint_hit = 0;

 

967

            return;

 

968

        }

915

969

        tb_flush(s->env);

916

970

        ret = SIGTRAP;

917

971

    } else if (reason == EXCP_INTERRUPT) {

926

980

 

927

981

/* Send a gdb syscall request.

928

982

   This accepts limited printf-style format specifiers, specifically:

929

 

    %x - target_ulong argument printed in hex.

930

 

    %s - string pointer (target_ulong) and length (int) pair.  */

 

983

    %x  - target_ulong argument printed in hex.

 

984

    %lx - 64-bit argument printed in hex.

 

985

    %s  - string pointer (target_ulong) and length (int) pair.  */

931

986

void gdb_do_syscall(gdb_syscall_complete_cb cb, char *fmt, ...)

932

987

{

933

988

    va_list va;

934

989

    char buf[256];

935

990

    char *p;

936

991

    target_ulong addr;

 

992

    uint64_t i64;

937

993

    GDBState *s;

938

994

 

939

995

    s = gdb_syscall_state;

956

1012

                addr = va_arg(va, target_ulong);

957

1013

                p += sprintf(p, TARGET_FMT_lx, addr);

958

1014

                break;

 

1015

            case 'l':

 

1016

                if (*(fmt++) != 'x')

 

1017

                    goto bad_format;

 

1018

                i64 = va_arg(va, uint64_t);

 

1019

                p += sprintf(p, "%" PRIx64, i64);

 

1020

                break;

959

1021

            case 's':

960

1022

                addr = va_arg(va, target_ulong);

961

1023

                p += sprintf(p, TARGET_FMT_lx "/%x", addr, va_arg(va, int));

962

1024

                break;

963

1025

            default:

 

1026

            bad_format:

964

1027

                fprintf(stderr, "gdbstub: Bad syscall format string '%s'\n",

965

1028

                        fmt - 1);

966

1029

                break;

969

1032

            *(p++) = *(fmt++);

970

1033

        }

971

1034

    }

 

1035

    *p = 0;

972

1036

    va_end(va);

973

1037

    put_packet(s, buf);

974

1038

#ifdef CONFIG_USER_ONLY

1189

1253

    return 0;

1190

1254

}

1191

1255

#else

1192

 

static int gdb_chr_can_recieve(void *opaque)

 

1256

static int gdb_chr_can_receive(void *opaque)

1193

1257

{

1194

1258

  return 1;

1195

1259

}

1196

1260

 

1197

 

static void gdb_chr_recieve(void *opaque, const uint8_t *buf, int size)

 

1261

static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size)

1198

1262

{

1199

1263

    GDBState *s = opaque;

1200

1264

    int i;

1216

1280

    }

1217

1281

}

1218

1282

 

1219

 

int gdbserver_start(CharDriverState *chr)

 

1283

int gdbserver_start(const char *port)

1220

1284

{

1221

1285

    GDBState *s;

1222

 

 

 

1286

    char gdbstub_port_name[128];

 

1287

    int port_num;

 

1288

    char *p;

 

1289

    CharDriverState *chr;

 

1290

 

 

1291

    if (!port || !*port)

 

1292

      return -1;

 

1293

 

 

1294

    port_num = strtol(port, &p, 10);

 

1295

    if (*p == 0) {

 

1296

        /* A numeric value is interpreted as a port number.  */

 

1297

        snprintf(gdbstub_port_name, sizeof(gdbstub_port_name),

 

1298

                 "tcp::%d,nowait,nodelay,server", port_num);

 

1299

        port = gdbstub_port_name;

 

1300

    }

 

1301

 

 

1302

    chr = qemu_chr_open(port);

1223

1303

    if (!chr)

1224

1304

        return -1;

1225

1305

 

1229

1309

    }

1230

1310

    s->env = first_cpu; /* XXX: allow to change CPU */

1231

1311

    s->chr = chr;

1232

 

    qemu_chr_add_handlers(chr, gdb_chr_can_recieve, gdb_chr_recieve,

 

1312

    qemu_chr_add_handlers(chr, gdb_chr_can_receive, gdb_chr_receive,

1233

1313

                          gdb_chr_event, s);

1234

1314

    qemu_add_vm_stop_handler(gdb_vm_stopped, s);

1235

1315

    return 0;

1236

1316

}

1237

 

 

1238

 

int gdbserver_start_port(int port)

1239

 

{

1240

 

    CharDriverState *chr;

1241

 

    char gdbstub_port_name[128];

1242

 

 

1243

 

    snprintf(gdbstub_port_name, sizeof(gdbstub_port_name),

1244

 

             "tcp::%d,nowait,nodelay,server", port);

1245

 

    chr = qemu_chr_open(gdbstub_port_name);

1246

 

    if (!chr) 

1247

 

        return -EIO;

1248

 

    return gdbserver_start(chr);

1249

 

}

1250

 

 

1251

1317

#endif

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1