Blame - source/Expression/DWARFExpression.cpp - fp2-dev/platform/external/lldb

2011-07-11 05:12:02 +0000

[diff] [blame]

496

s->PutCString("DW_OP_APPLE_address_of");

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

497

break;

498

case DW_OP_APPLE_value_of: // 0xF3 - pops the value off the stack and pushes the value of that object (top item must be a variable, or expression local)

Greg Clayton

2011-07-11 05:12:02 +0000

[diff] [blame]

499

s->PutCString("DW_OP_APPLE_value_of");

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

500

break;

501

case DW_OP_APPLE_deref_type: // 0xF4 - gets the address of the top stack item (top item must be a variable, or a clang type)

Greg Clayton

2011-07-11 05:12:02 +0000

[diff] [blame]

502

s->PutCString("DW_OP_APPLE_deref_type");

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

503

break;

504

case DW_OP_APPLE_expr_local: // 0xF5 - ULEB128 expression local index

Greg Clayton

2011-07-11 05:12:02 +0000

[diff] [blame]

505

s->Printf("DW_OP_APPLE_expr_local(%u)", m_data.GetULEB128(&offset));

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

506

break;

507

case DW_OP_APPLE_constf: // 0xF6 - 1 byte float size, followed by constant float data

508

{

509

uint8_t float_length = m_data.GetU8(&offset);

Greg Clayton

2011-07-11 05:12:02 +0000

[diff] [blame]

510

s->Printf("DW_OP_APPLE_constf(<%u> ", float_length);

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

511

m_data.Dump(s, offset, eFormatHex, float_length, 1, UINT32_MAX, DW_INVALID_ADDRESS, 0, 0);

512

s->PutChar(')');

513

// Consume the float data

514

m_data.GetData(&offset, float_length);

515

}

516

break;

517

case DW_OP_APPLE_scalar_cast:

Greg Clayton

2011-07-11 05:12:02 +0000

[diff] [blame]

518

s->Printf("DW_OP_APPLE_scalar_cast(%s)", Scalar::GetValueTypeAsCString ((Scalar::Type)m_data.GetU8(&offset)));

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

519

break;

520

case DW_OP_APPLE_clang_cast:

521

{

522

clang::Type *clang_type = (clang::Type *)m_data.GetMaxU64(&offset, sizeof(void*));

Greg Clayton

2011-07-11 05:12:02 +0000

[diff] [blame]

523

s->Printf("DW_OP_APPLE_clang_cast(%p)", clang_type);

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

524

}

525

break;

526

case DW_OP_APPLE_clear:

Greg Clayton

2011-07-11 05:12:02 +0000

[diff] [blame]

527

s->PutCString("DW_OP_APPLE_clear");

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

528

break;

529

case DW_OP_APPLE_error: // 0xFF - Stops expression evaluation and returns an error (no args)

Greg Clayton

2011-07-11 05:12:02 +0000

[diff] [blame]

530

s->PutCString("DW_OP_APPLE_error");

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

break;

}

}

}

void

Greg Clayton

2010-09-14 02:20:48 +0000

[diff] [blame]

537

DWARFExpression::SetLocationListSlide (addr_t slide)

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

538

{

Greg Clayton

2010-09-14 02:20:48 +0000

[diff] [blame]

539

m_loclist_slide = slide;

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

}

int

DWARFExpression::GetRegisterKind ()

{

return m_reg_kind;

}

void

DWARFExpression::SetRegisterKind (int reg_kind)

550

{

551

m_reg_kind = reg_kind;

}

bool

DWARFExpression::IsLocationList() const

556

{

Greg Clayton

2010-09-14 02:20:48 +0000

[diff] [blame]

557

return m_loclist_slide != LLDB_INVALID_ADDRESS;

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

558

}

559

560

void

Greg Clayton

2010-09-14 02:20:48 +0000

[diff] [blame]

561

DWARFExpression::GetDescription (Stream *s, lldb::DescriptionLevel level, addr_t location_list_base_addr) const

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

562

{

563

if (IsLocationList())

564

{

565

// We have a location list

566

uint32_t offset = 0;

567

uint32_t count = 0;

Greg Clayton

2010-09-14 02:20:48 +0000

[diff] [blame]

568

addr_t curr_base_addr = location_list_base_addr;

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

569

while (m_data.ValidOffset(offset))

570

{

571

lldb::addr_t begin_addr_offset = m_data.GetAddress(&offset);

572

lldb::addr_t end_addr_offset = m_data.GetAddress(&offset);

573

if (begin_addr_offset < end_addr_offset)

574

{

575

if (count > 0)

576

s->PutCString(", ");

Greg Clayton

2010-09-14 02:20:48 +0000

[diff] [blame]

577

VMRange addr_range(curr_base_addr + begin_addr_offset, curr_base_addr + end_addr_offset);

578

addr_range.Dump(s, 0, 8);

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

579

s->PutChar('{');

580

uint32_t location_length = m_data.GetU16(&offset);

581

DumpLocation (s, offset, location_length, level);

582

s->PutChar('}');

583

offset += location_length;

584

}

585

else if (begin_addr_offset == 0 && end_addr_offset == 0)

586

{

587

// The end of the location list is marked by both the start and end offset being zero

break;

}

else

{

Greg Clayton

b344843

2011-03-24 21:19:54 +0000

[diff] [blame]

592

if ((m_data.GetAddressByteSize() == 4 && (begin_addr_offset == UINT32_MAX)) ||

593

(m_data.GetAddressByteSize() == 8 && (begin_addr_offset == UINT64_MAX)))

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

594

{

Greg Clayton

2010-09-14 02:20:48 +0000

[diff] [blame]

595

curr_base_addr = end_addr_offset + location_list_base_addr;

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

596

// We have a new base address

597

if (count > 0)

598

s->PutCString(", ");

599

*s << "base_addr = " << end_addr_offset;

}

}

count++;

}

}

else

{

// We have a normal location that contains DW_OP location opcodes

609

DumpLocation (s, 0, m_data.GetByteSize(), level);

}

}

static bool

ReadRegisterValueAsScalar

615

(

Greg Clayton

2011-05-09 20:18:18 +0000

[diff] [blame]

616

RegisterContext *reg_ctx,

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

uint32_t reg_kind,

uint32_t reg_num,

Error *error_ptr,

Value &value

)

{

Greg Clayton

2011-05-09 20:18:18 +0000

[diff] [blame]

623

if (reg_ctx == NULL)

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

624

{

Jason Molenda

2010-11-20 01:28:30 +0000

[diff] [blame]

625

if (error_ptr)

626

error_ptr->SetErrorStringWithFormat("No register context in frame.\n");

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

627

}

628

else

629

{

Greg Clayton

2011-05-09 20:18:18 +0000

[diff] [blame]

630

uint32_t native_reg = reg_ctx->ConvertRegisterKindToRegisterNumber(reg_kind, reg_num);

Jason Molenda

2010-11-20 01:28:30 +0000

[diff] [blame]

631

if (native_reg == LLDB_INVALID_REGNUM)

632

{

633

if (error_ptr)

634

error_ptr->SetErrorStringWithFormat("Unable to convert register kind=%u reg_num=%u to a native register number.\n", reg_kind, reg_num);

635

}

636

else

637

{

Greg Clayton

2011-05-09 20:18:18 +0000

[diff] [blame]

638

const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex(native_reg);

639

RegisterValue reg_value;

640

if (reg_ctx->ReadRegister (reg_info, reg_value))

641

{

642

if (reg_value.GetScalarValue(value.GetScalar()))

643

{

644

value.SetValueType (Value::eValueTypeScalar);

Greg Clayton

2011-05-30 00:49:24 +0000

[diff] [blame]

645

value.SetContext (Value::eContextTypeRegisterInfo,

646

const_cast<RegisterInfo *>(reg_info));

Greg Clayton

2011-05-09 20:18:18 +0000

[diff] [blame]

if (error_ptr)

error_ptr->Clear();

return true;

}

else

{

Greg Clayton

2011-05-30 00:49:24 +0000

[diff] [blame]

653

// If we get this error, then we need to implement a value

654

// buffer in the dwarf expression evaluation function...

Greg Clayton

2011-05-09 20:18:18 +0000

[diff] [blame]

655

if (error_ptr)

Greg Clayton

2011-05-30 00:49:24 +0000

[diff] [blame]

656

error_ptr->SetErrorStringWithFormat ("register %s can't be converted to a scalar value",

657

reg_info->name);

Greg Clayton

2011-05-09 20:18:18 +0000

[diff] [blame]

}

}

else

{

if (error_ptr)

Greg Clayton

2011-05-30 00:49:24 +0000

[diff] [blame]

663

error_ptr->SetErrorStringWithFormat("register %s is not available", reg_info->name);

Greg Clayton

2011-05-09 20:18:18 +0000

[diff] [blame]

664

}

Jason Molenda

2010-11-20 01:28:30 +0000

[diff] [blame]

665

}

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

}

return false;

}

Greg Clayton

2010-09-14 02:20:48 +0000

[diff] [blame]

670

//bool

671

//DWARFExpression::LocationListContainsLoadAddress (Process* process, const Address &addr) const

672

//{

673

// return LocationListContainsLoadAddress(process, addr.GetLoadAddress(process));

//}

//

//bool

//DWARFExpression::LocationListContainsLoadAddress (Process* process, addr_t load_addr) const

678

//{

679

// if (load_addr == LLDB_INVALID_ADDRESS)

680

// return false;

681

//

682

// if (IsLocationList())

683

// {

684

// uint32_t offset = 0;

685

//

686

// addr_t loc_list_base_addr = m_loclist_slide.GetLoadAddress(process);

687

//

688

// if (loc_list_base_addr == LLDB_INVALID_ADDRESS)

689

// return false;

690

//

691

// while (m_data.ValidOffset(offset))

692

// {

693

// // We need to figure out what the value is for the location.

694

// addr_t lo_pc = m_data.GetAddress(&offset);

695

// addr_t hi_pc = m_data.GetAddress(&offset);

696

// if (lo_pc == 0 && hi_pc == 0)

// break;

// else

// {

// lo_pc += loc_list_base_addr;

701

// hi_pc += loc_list_base_addr;

702

//

703

// if (lo_pc <= load_addr && load_addr < hi_pc)

704

// return true;

705

//

706

// offset += m_data.GetU16(&offset);

// }

// }

// }

// return false;

//}

Greg Clayton

2010-08-24 21:05:24 +0000

[diff] [blame]

712

713

bool

Greg Clayton

2010-09-14 02:20:48 +0000

[diff] [blame]

714

DWARFExpression::LocationListContainsAddress (lldb::addr_t loclist_base_addr, lldb::addr_t addr) const

Greg Clayton

2010-08-24 21:05:24 +0000

[diff] [blame]

715

{

Greg Clayton

2010-09-14 02:20:48 +0000

[diff] [blame]

716

if (addr == LLDB_INVALID_ADDRESS)

Greg Clayton

2010-08-24 21:05:24 +0000

[diff] [blame]

717

return false;

718

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

719

if (IsLocationList())

720

{

721

uint32_t offset = 0;

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

722

Greg Clayton

2010-09-14 02:20:48 +0000

[diff] [blame]

723

if (loclist_base_addr == LLDB_INVALID_ADDRESS)

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

724

return false;

725

726

while (m_data.ValidOffset(offset))

727

{

728

// We need to figure out what the value is for the location.

729

addr_t lo_pc = m_data.GetAddress(&offset);

730

addr_t hi_pc = m_data.GetAddress(&offset);

731

if (lo_pc == 0 && hi_pc == 0)

732

break;

733

else

734

{

Greg Clayton

2010-09-14 02:20:48 +0000

[diff] [blame]

735

lo_pc += loclist_base_addr - m_loclist_slide;

736

hi_pc += loclist_base_addr - m_loclist_slide;

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

737

Greg Clayton

2010-09-14 02:20:48 +0000

[diff] [blame]

738

if (lo_pc <= addr && addr < hi_pc)

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

739

return true;

740

741

offset += m_data.GetU16(&offset);

}

}

}

return false;

}

Greg Clayton

2010-08-24 21:05:24 +0000

[diff] [blame]

747

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

748

bool

Greg Clayton

2011-07-11 05:12:02 +0000

[diff] [blame]

749

DWARFExpression::GetLocation (addr_t base_addr, addr_t pc, uint32_t &offset, uint32_t &length)

750

{

751

offset = 0;

752

if (!IsLocationList())

753

{

754

length = m_data.GetByteSize();

return true;

}

if (base_addr != LLDB_INVALID_ADDRESS && pc != LLDB_INVALID_ADDRESS)

759

{

760

addr_t curr_base_addr = base_addr;

761

762

while (m_data.ValidOffset(offset))

763

{

764

// We need to figure out what the value is for the location.

765

addr_t lo_pc = m_data.GetAddress(&offset);

766

addr_t hi_pc = m_data.GetAddress(&offset);

767

if (lo_pc == 0 && hi_pc == 0)

{

break;

}

else

{

lo_pc += curr_base_addr - m_loclist_slide;

774

hi_pc += curr_base_addr - m_loclist_slide;

775

776

length = m_data.GetU16(&offset);

777

778

if (length > 0 && lo_pc <= pc && pc < hi_pc)

return true;

offset += length;

}

}

}

offset = UINT32_MAX;

length = 0;

return false;

}

bool

DWARFExpression::DumpLocationForAddress (Stream *s,

792

lldb::DescriptionLevel level,

addr_t base_addr,

addr_t address)

{

uint32_t offset = 0;

uint32_t length = 0;

if (GetLocation (base_addr, address, offset, length))

{

if (length > 0)

{

DumpLocation(s, offset, length, level);

return true;

}

}

return false;

}

bool

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

811

DWARFExpression::Evaluate

812

(

813

ExecutionContextScope *exe_scope,

814

clang::ASTContext *ast_context,

Greg Clayton

2011-01-25 23:55:37 +0000

[diff] [blame]

815

ClangExpressionVariableList *expr_locals,

816

ClangExpressionDeclMap *decl_map,

Greg Clayton

2010-09-14 02:20:48 +0000

[diff] [blame]

817

lldb::addr_t loclist_base_load_addr,

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

818

const Value* initial_value_ptr,

Value& result,

Error *error_ptr

) const

{

ExecutionContext exe_ctx (exe_scope);

Greg Clayton

2011-01-25 23:55:37 +0000

[diff] [blame]

824

return Evaluate(&exe_ctx, ast_context, expr_locals, decl_map, NULL, loclist_base_load_addr, initial_value_ptr, result, error_ptr);

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

}

bool

DWARFExpression::Evaluate

829

(

830

ExecutionContext *exe_ctx,

831

clang::ASTContext *ast_context,

Greg Clayton

2011-01-25 23:55:37 +0000

[diff] [blame]

832

ClangExpressionVariableList *expr_locals,

833

ClangExpressionDeclMap *decl_map,

Jason Molenda

2010-11-20 01:28:30 +0000

[diff] [blame]

834

RegisterContext *reg_ctx,

Greg Clayton

2010-09-14 02:20:48 +0000

[diff] [blame]

835

lldb::addr_t loclist_base_load_addr,

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

836

const Value* initial_value_ptr,

Value& result,

Error *error_ptr

) const

{

if (IsLocationList())

842

{

843

uint32_t offset = 0;

Jason Molenda

2010-11-20 01:28:30 +0000

[diff] [blame]

844

addr_t pc;

845

if (reg_ctx)

846

pc = reg_ctx->GetPC();

847

else

848

pc = exe_ctx->frame->GetRegisterContext()->GetPC();

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

849

Greg Clayton

2010-09-14 02:20:48 +0000

[diff] [blame]

850

if (loclist_base_load_addr != LLDB_INVALID_ADDRESS)

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

851

{

Greg Clayton

2010-09-14 02:20:48 +0000

[diff] [blame]

852

if (pc == LLDB_INVALID_ADDRESS)

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

853

{

Greg Clayton

2010-09-14 02:20:48 +0000

[diff] [blame]

854

if (error_ptr)

855

error_ptr->SetErrorString("Invalid PC in frame.");

856

return false;

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

857

}

Greg Clayton

2010-09-14 02:20:48 +0000

[diff] [blame]

858

859

addr_t curr_loclist_base_load_addr = loclist_base_load_addr;

860

861

while (m_data.ValidOffset(offset))

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

862

{

Greg Clayton

2010-09-14 02:20:48 +0000

[diff] [blame]

863

// We need to figure out what the value is for the location.

864

addr_t lo_pc = m_data.GetAddress(&offset);

865

addr_t hi_pc = m_data.GetAddress(&offset);

866

if (lo_pc == 0 && hi_pc == 0)

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

867

{

Greg Clayton

2010-09-14 02:20:48 +0000

[diff] [blame]

868

break;

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

869

}

Greg Clayton

2010-09-14 02:20:48 +0000

[diff] [blame]

870

else

871

{

872

lo_pc += curr_loclist_base_load_addr - m_loclist_slide;

873

hi_pc += curr_loclist_base_load_addr - m_loclist_slide;

874

875

uint16_t length = m_data.GetU16(&offset);

876

877

if (length > 0 && lo_pc <= pc && pc < hi_pc)

878

{

Greg Clayton

2011-01-25 23:55:37 +0000

[diff] [blame]

879

return DWARFExpression::Evaluate (exe_ctx, ast_context, expr_locals, decl_map, reg_ctx, m_data, offset, length, m_reg_kind, initial_value_ptr, result, error_ptr);

Greg Clayton

2010-09-14 02:20:48 +0000

[diff] [blame]

880

}

881

offset += length;

882

}

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

883

}

884

}

885

if (error_ptr)

Greg Clayton

2011-05-30 00:49:24 +0000

[diff] [blame]

886

error_ptr->SetErrorString ("variable not available");

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

return false;

}

// Not a location list, just a single expression.

Greg Clayton

2011-01-25 23:55:37 +0000

[diff] [blame]

891

return DWARFExpression::Evaluate (exe_ctx, ast_context, expr_locals, decl_map, reg_ctx, m_data, 0, m_data.GetByteSize(), m_reg_kind, initial_value_ptr, result, error_ptr);

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

}

bool

DWARFExpression::Evaluate

898

(

899

ExecutionContext *exe_ctx,

900

clang::ASTContext *ast_context,

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

901

ClangExpressionVariableList *expr_locals,

902

ClangExpressionDeclMap *decl_map,

Jason Molenda

2010-11-20 01:28:30 +0000

[diff] [blame]

903

RegisterContext *reg_ctx,

Greg Clayton

2011-01-25 23:55:37 +0000

[diff] [blame]

904

const DataExtractor& opcodes,

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

905

const uint32_t opcodes_offset,

906

const uint32_t opcodes_length,

907

const uint32_t reg_kind,

908

const Value* initial_value_ptr,

Value& result,

Error *error_ptr

)

{

std::vector<Value> stack;

914

Jason Molenda

2010-11-20 01:28:30 +0000

[diff] [blame]

915

if (reg_ctx == NULL && exe_ctx && exe_ctx->frame)

Greg Clayton

08d7d3a

2011-01-06 22:15:06 +0000

[diff] [blame]

916

reg_ctx = exe_ctx->frame->GetRegisterContext().get();

Jason Molenda

2010-11-20 01:28:30 +0000

[diff] [blame]

917

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

918

if (initial_value_ptr)

919

stack.push_back(*initial_value_ptr);

920

921

uint32_t offset = opcodes_offset;

922

const uint32_t end_offset = opcodes_offset + opcodes_length;

Value tmp;

uint32_t reg_num;

// Make sure all of the data is available in opcodes.

927

if (!opcodes.ValidOffsetForDataOfSize(opcodes_offset, opcodes_length))

928

{

929

if (error_ptr)

930

error_ptr->SetErrorString ("Invalid offset and/or length for opcodes buffer.");

931

return false;

932

}

Greg Clayton

e005f2c

2010-11-06 01:53:30 +0000

[diff] [blame]

933

LogSP log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

934

935

936

while (opcodes.ValidOffset(offset) && offset < end_offset)

937

{

938

const uint32_t op_offset = offset;

939

const uint8_t op = opcodes.GetU8(&offset);

940

941

if (log)

942

{

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

943

size_t count = stack.size();

Sean Callanan

2010-06-23 00:47:48 +0000

[diff] [blame]

944

log->Printf("Stack before operation has %d values:", count);

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

945

for (size_t i=0; i<count; ++i)

946

{

947

StreamString new_value;

948

new_value.Printf("[%zu]", i);

949

stack[i].Dump(&new_value);

Sean Callanan

2010-06-23 00:47:48 +0000

[diff] [blame]

950

log->Printf(" %s", new_value.GetData());

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

951

}

952

log->Printf("0x%8.8x: %s", op_offset, DW_OP_value_to_name(op));

}

switch (op)

{

//----------------------------------------------------------------------

957

// The DW_OP_addr operation has a single operand that encodes a machine

958

// address and whose size is the size of an address on the target machine.

959

//----------------------------------------------------------------------

960

case DW_OP_addr:

Greg Clayton

2011-07-07 01:59:51 +0000

[diff] [blame]

961

stack.push_back(Scalar(opcodes.GetAddress(&offset)));

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

962

stack.back().SetValueType (Value::eValueTypeFileAddress);

963

break;

964

965

//----------------------------------------------------------------------

966

// The DW_OP_addr_sect_offset4 is used for any location expressions in

967

// shared libraries that have a location like:

968

// DW_OP_addr(0x1000)

969

// If this address resides in a shared library, then this virtual

970

// address won't make sense when it is evaluated in the context of a

971

// running process where shared libraries have been slid. To account for

972

// this, this new address type where we can store the section pointer

973

// and a 4 byte offset.

974

//----------------------------------------------------------------------

975

// case DW_OP_addr_sect_offset4:

976

// {

977

// result_type = eResultTypeFileAddress;

978

// lldb::Section *sect = (lldb::Section *)opcodes.GetMaxU64(&offset, sizeof(void *));

979

// lldb::addr_t sect_offset = opcodes.GetU32(&offset);

980

//

981

// Address so_addr (sect, sect_offset);

982

// lldb::addr_t load_addr = so_addr.GetLoadAddress();

983

// if (load_addr != LLDB_INVALID_ADDRESS)

984

// {

985

// // We successfully resolve a file address to a load

986

// // address.

987

// stack.push_back(load_addr);

// break;

// }

// else

// {

// // We were able

// if (error_ptr)

// error_ptr->SetErrorStringWithFormat ("Section %s in %s is not currently loaded.\n", sect->GetName().AsCString(), sect->GetModule()->GetFileSpec().GetFilename().AsCString());

// return false;

// }

// }

// break;

//----------------------------------------------------------------------

1001

// OPCODE: DW_OP_deref

1002

// OPERANDS: none

1003

// DESCRIPTION: Pops the top stack entry and treats it as an address.

1004

// The value retrieved from that address is pushed. The size of the

1005

// data retrieved from the dereferenced address is the size of an

1006

// address on the target machine.

1007

//----------------------------------------------------------------------

1008

case DW_OP_deref:

1009

{

1010

Value::ValueType value_type = stack.back().GetValueType();

1011

switch (value_type)

1012

{

1013

case Value::eValueTypeHostAddress:

1014

{

1015

void *src = (void *)stack.back().GetScalar().ULongLong();

1016

intptr_t ptr;

1017

::memcpy (&ptr, src, sizeof(void *));

1018

stack.back().GetScalar() = ptr;

1019

stack.back().ClearContext();

1020

}

1021

break;

1022

case Value::eValueTypeLoadAddress:

1023

if (exe_ctx)

1024

{

1025

if (exe_ctx->process)

1026

{

1027

lldb::addr_t pointer_addr = stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS);

1028

uint8_t addr_bytes[sizeof(lldb::addr_t)];

1029

uint32_t addr_size = exe_ctx->process->GetAddressByteSize();

1030

Error error;

1031

if (exe_ctx->process->ReadMemory(pointer_addr, &addr_bytes, addr_size, error) == addr_size)

1032

{

1033

DataExtractor addr_data(addr_bytes, sizeof(addr_bytes), exe_ctx->process->GetByteOrder(), addr_size);

1034

uint32_t addr_data_offset = 0;

1035

stack.back().GetScalar() = addr_data.GetPointer(&addr_data_offset);

1036

stack.back().ClearContext();

}

else

{

if (error_ptr)

error_ptr->SetErrorStringWithFormat ("Failed to dereference pointer from 0x%llx for DW_OP_deref: %s\n",

pointer_addr,

error.AsCString());

return false;

}

}

else

{

if (error_ptr)

error_ptr->SetErrorStringWithFormat ("NULL process for DW_OP_deref.\n");

return false;

}

}

else

{

if (error_ptr)

error_ptr->SetErrorStringWithFormat ("NULL execution context for DW_OP_deref.\n");

return false;

}

break;

default:

break;

}

}

break;

//----------------------------------------------------------------------

1070

// OPCODE: DW_OP_deref_size

1071

// OPERANDS: 1

1072

// 1 - uint8_t that specifies the size of the data to dereference.

1073

// DESCRIPTION: Behaves like the DW_OP_deref operation: it pops the top

1074

// stack entry and treats it as an address. The value retrieved from that

1075

// address is pushed. In the DW_OP_deref_size operation, however, the

1076

// size in bytes of the data retrieved from the dereferenced address is

1077

// specified by the single operand. This operand is a 1-byte unsigned

1078

// integral constant whose value may not be larger than the size of an

1079

// address on the target machine. The data retrieved is zero extended

1080

// to the size of an address on the target machine before being pushed

1081

// on the expression stack.

1082

//----------------------------------------------------------------------

1083

case DW_OP_deref_size:

Jason Molenda

2010-11-20 01:28:30 +0000

[diff] [blame]

1084

{

1085

uint8_t size = opcodes.GetU8(&offset);

1086

Value::ValueType value_type = stack.back().GetValueType();

1087

switch (value_type)

1088

{

1089

case Value::eValueTypeHostAddress:

1090

{

1091

void *src = (void *)stack.back().GetScalar().ULongLong();

1092

intptr_t ptr;

1093

::memcpy (&ptr, src, sizeof(void *));

1094

// I can't decide whether the size operand should apply to the bytes in their

1095

// lldb-host endianness or the target endianness.. I doubt this'll ever come up

1096

// but I'll opt for assuming big endian regardless.

1097

switch (size)

1098

{

1099

case 1: ptr = ptr & 0xff; break;

1100

case 2: ptr = ptr & 0xffff; break;

1101

case 3: ptr = ptr & 0xffffff; break;

1102

case 4: ptr = ptr & 0xffffffff; break;

Jason Molenda

a99bcaa

2010-11-29 21:38:58 +0000

[diff] [blame]

1103

// the casts are added to work around the case where intptr_t is a 32 bit quantity;

1104

// presumably we won't hit the 5..7 cases if (void*) is 32-bits in this program.

1105

case 5: ptr = (intptr_t) ptr & 0xffffffffffULL; break;

1106

case 6: ptr = (intptr_t) ptr & 0xffffffffffffULL; break;

1107

case 7: ptr = (intptr_t) ptr & 0xffffffffffffffULL; break;

Jason Molenda

2010-11-20 01:28:30 +0000

[diff] [blame]

1108

default: break;

1109

}

1110

stack.back().GetScalar() = ptr;

1111

stack.back().ClearContext();

1112

}

1113

break;

1114

case Value::eValueTypeLoadAddress:

1115

if (exe_ctx)

1116

{

1117

if (exe_ctx->process)

1118

{

1119

lldb::addr_t pointer_addr = stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS);

1120

uint8_t addr_bytes[sizeof(lldb::addr_t)];

1121

Error error;

1122

if (exe_ctx->process->ReadMemory(pointer_addr, &addr_bytes, size, error) == size)

1123

{

1124

DataExtractor addr_data(addr_bytes, sizeof(addr_bytes), exe_ctx->process->GetByteOrder(), size);

1125

uint32_t addr_data_offset = 0;

1126

switch (size)

1127

{

1128

case 1: stack.back().GetScalar() = addr_data.GetU8(&addr_data_offset); break;

1129

case 2: stack.back().GetScalar() = addr_data.GetU16(&addr_data_offset); break;

1130

case 4: stack.back().GetScalar() = addr_data.GetU32(&addr_data_offset); break;

1131

case 8: stack.back().GetScalar() = addr_data.GetU64(&addr_data_offset); break;

1132

default: stack.back().GetScalar() = addr_data.GetPointer(&addr_data_offset);

1133

}

1134

stack.back().ClearContext();

}

else

{

if (error_ptr)

error_ptr->SetErrorStringWithFormat ("Failed to dereference pointer from 0x%llx for DW_OP_deref: %s\n",

pointer_addr,

error.AsCString());

return false;

}

}

else

{

if (error_ptr)

error_ptr->SetErrorStringWithFormat ("NULL process for DW_OP_deref.\n");

return false;

}

}

else

{

if (error_ptr)

error_ptr->SetErrorStringWithFormat ("NULL execution context for DW_OP_deref.\n");

return false;

}

break;

default:

break;

}

}

break;

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

1166

1167

//----------------------------------------------------------------------

1168

// OPCODE: DW_OP_xderef_size

1169

// OPERANDS: 1

1170

// 1 - uint8_t that specifies the size of the data to dereference.

1171

// DESCRIPTION: Behaves like the DW_OP_xderef operation: the entry at

1172

// the top of the stack is treated as an address. The second stack

Greg Clayton

33ed170

2010-08-24 00:45:41 +0000

[diff] [blame]

1173

// entry is treated as an "address space identifier" for those

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

1174

// architectures that support multiple address spaces. The top two

1175

// stack elements are popped, a data item is retrieved through an

1176

// implementation-defined address calculation and pushed as the new

1177

// stack top. In the DW_OP_xderef_size operation, however, the size in

1178

// bytes of the data retrieved from the dereferenced address is

1179

// specified by the single operand. This operand is a 1-byte unsigned

1180

// integral constant whose value may not be larger than the size of an

1181

// address on the target machine. The data retrieved is zero extended

1182

// to the size of an address on the target machine before being pushed

1183

// on the expression stack.

1184

//----------------------------------------------------------------------

1185

case DW_OP_xderef_size:

1186

if (error_ptr)

1187

error_ptr->SetErrorString("Unimplemented opcode: DW_OP_xderef_size.");

1188

return false;

1189

//----------------------------------------------------------------------

1190

// OPCODE: DW_OP_xderef

1191

// OPERANDS: none

1192

// DESCRIPTION: Provides an extended dereference mechanism. The entry at

1193

// the top of the stack is treated as an address. The second stack entry

1194

// is treated as an "address space identifier" for those architectures

1195

// that support multiple address spaces. The top two stack elements are

1196

// popped, a data item is retrieved through an implementation-defined

1197

// address calculation and pushed as the new stack top. The size of the

1198

// data retrieved from the dereferenced address is the size of an address

1199

// on the target machine.

1200

//----------------------------------------------------------------------

1201

case DW_OP_xderef:

1202

if (error_ptr)

1203

error_ptr->SetErrorString("Unimplemented opcode: DW_OP_xderef.");

1204

return false;

1205

1206

//----------------------------------------------------------------------

1207

// All DW_OP_constXXX opcodes have a single operand as noted below:

1208

//

1209

// Opcode Operand 1

1210

// --------------- ----------------------------------------------------

1211

// DW_OP_const1u 1-byte unsigned integer constant

1212

// DW_OP_const1s 1-byte signed integer constant

1213

// DW_OP_const2u 2-byte unsigned integer constant

1214

// DW_OP_const2s 2-byte signed integer constant

1215

// DW_OP_const4u 4-byte unsigned integer constant

1216

// DW_OP_const4s 4-byte signed integer constant

1217

// DW_OP_const8u 8-byte unsigned integer constant

1218

// DW_OP_const8s 8-byte signed integer constant

1219

// DW_OP_constu unsigned LEB128 integer constant

1220

// DW_OP_consts signed LEB128 integer constant

1221

//----------------------------------------------------------------------

Greg Clayton

2011-07-07 01:59:51 +0000

[diff] [blame]

1222

case DW_OP_const1u : stack.push_back(Scalar(( uint8_t)opcodes.GetU8 (&offset))); break;

1223

case DW_OP_const1s : stack.push_back(Scalar(( int8_t)opcodes.GetU8 (&offset))); break;

1224

case DW_OP_const2u : stack.push_back(Scalar((uint16_t)opcodes.GetU16 (&offset))); break;

1225

case DW_OP_const2s : stack.push_back(Scalar(( int16_t)opcodes.GetU16 (&offset))); break;

1226

case DW_OP_const4u : stack.push_back(Scalar((uint32_t)opcodes.GetU32 (&offset))); break;

1227

case DW_OP_const4s : stack.push_back(Scalar(( int32_t)opcodes.GetU32 (&offset))); break;

1228

case DW_OP_const8u : stack.push_back(Scalar((uint64_t)opcodes.GetU64 (&offset))); break;

1229

case DW_OP_const8s : stack.push_back(Scalar(( int64_t)opcodes.GetU64 (&offset))); break;

1230

case DW_OP_constu : stack.push_back(Scalar(opcodes.GetULEB128 (&offset))); break;

1231

case DW_OP_consts : stack.push_back(Scalar(opcodes.GetSLEB128 (&offset))); break;

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

1232

1233

//----------------------------------------------------------------------

1234

// OPCODE: DW_OP_dup

1235

// OPERANDS: none

1236

// DESCRIPTION: duplicates the value at the top of the stack

1237

//----------------------------------------------------------------------

case DW_OP_dup:

if (stack.empty())

{

if (error_ptr)

error_ptr->SetErrorString("Expression stack empty for DW_OP_dup.");

return false;

}

else

stack.push_back(stack.back());

1247

break;

1248

1249

//----------------------------------------------------------------------

1250

// OPCODE: DW_OP_drop

1251

// OPERANDS: none

1252

// DESCRIPTION: pops the value at the top of the stack

1253

//----------------------------------------------------------------------

case DW_OP_drop:

if (stack.empty())

{

if (error_ptr)

error_ptr->SetErrorString("Expression stack empty for DW_OP_drop.");

return false;

}

else

stack.pop_back();

break;

//----------------------------------------------------------------------

1266

// OPCODE: DW_OP_over

1267

// OPERANDS: none

1268

// DESCRIPTION: Duplicates the entry currently second in the stack at

1269

// the top of the stack.

1270

//----------------------------------------------------------------------

1271

case DW_OP_over:

1272

if (stack.size() < 2)

1273

{

1274

if (error_ptr)

1275

error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_over.");

return false;

}

else

stack.push_back(stack[stack.size() - 2]);

break;

//----------------------------------------------------------------------

1284

// OPCODE: DW_OP_pick

1285

// OPERANDS: uint8_t index into the current stack

1286

// DESCRIPTION: The stack entry with the specified index (0 through 255,

1287

// inclusive) is pushed on the stack

1288

//----------------------------------------------------------------------

1289

case DW_OP_pick:

1290

{

1291

uint8_t pick_idx = opcodes.GetU8(&offset);

1292

if (pick_idx < stack.size())

1293

stack.push_back(stack[pick_idx]);

else

{

if (error_ptr)

error_ptr->SetErrorStringWithFormat("Index %u out of range for DW_OP_pick.\n", pick_idx);

return false;

}

}

break;

//----------------------------------------------------------------------

1304

// OPCODE: DW_OP_swap

1305

// OPERANDS: none

1306

// DESCRIPTION: swaps the top two stack entries. The entry at the top

1307

// of the stack becomes the second stack entry, and the second entry

1308

// becomes the top of the stack

1309

//----------------------------------------------------------------------

1310

case DW_OP_swap:

1311

if (stack.size() < 2)

1312

{

1313

if (error_ptr)

1314

error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_swap.");

return false;

}

else

{

tmp = stack.back();

stack.back() = stack[stack.size() - 2];

1321

stack[stack.size() - 2] = tmp;

}

break;

//----------------------------------------------------------------------

1326

// OPCODE: DW_OP_rot

1327

// OPERANDS: none

1328

// DESCRIPTION: Rotates the first three stack entries. The entry at

1329

// the top of the stack becomes the third stack entry, the second

1330

// entry becomes the top of the stack, and the third entry becomes

1331

// the second entry.

1332

//----------------------------------------------------------------------

1333

case DW_OP_rot:

1334

if (stack.size() < 3)

1335

{

1336

if (error_ptr)

1337

error_ptr->SetErrorString("Expression stack needs at least 3 items for DW_OP_rot.");

return false;

}

else

{

size_t last_idx = stack.size() - 1;

1343

Value old_top = stack[last_idx];

1344

stack[last_idx] = stack[last_idx - 1];

1345

stack[last_idx - 1] = stack[last_idx - 2];

1346

stack[last_idx - 2] = old_top;

}

break;

//----------------------------------------------------------------------

1351

// OPCODE: DW_OP_abs

1352

// OPERANDS: none

1353

// DESCRIPTION: pops the top stack entry, interprets it as a signed

1354

// value and pushes its absolute value. If the absolute value can not be

1355

// represented, the result is undefined.

1356

//----------------------------------------------------------------------

case DW_OP_abs:

if (stack.empty())

{

if (error_ptr)

error_ptr->SetErrorString("Expression stack needs at least 1 item for DW_OP_abs.");

1362

return false;

1363

}

1364

else if (stack.back().ResolveValue(exe_ctx, ast_context).AbsoluteValue() == false)

1365

{

1366

if (error_ptr)

1367

error_ptr->SetErrorString("Failed to take the absolute value of the first stack item.");

return false;

}

break;

//----------------------------------------------------------------------

1373

// OPCODE: DW_OP_and

1374

// OPERANDS: none

1375

// DESCRIPTION: pops the top two stack values, performs a bitwise and

1376

// operation on the two, and pushes the result.

1377

//----------------------------------------------------------------------

1378

case DW_OP_and:

1379

if (stack.size() < 2)

1380

{

1381

if (error_ptr)

1382

error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_and.");

return false;

}

else

{

tmp = stack.back();

stack.pop_back();

stack.back().ResolveValue(exe_ctx, ast_context) = stack.back().ResolveValue(exe_ctx, ast_context) & tmp.ResolveValue(exe_ctx, ast_context);

}

break;

//----------------------------------------------------------------------

1394

// OPCODE: DW_OP_div

1395

// OPERANDS: none

1396

// DESCRIPTION: pops the top two stack values, divides the former second

1397

// entry by the former top of the stack using signed division, and

1398

// pushes the result.

1399

//----------------------------------------------------------------------

1400

case DW_OP_div:

1401

if (stack.size() < 2)

1402

{

1403

if (error_ptr)

1404

error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_div.");

return false;

}

else

{

tmp = stack.back();

if (tmp.ResolveValue(exe_ctx, ast_context).IsZero())

1411

{

1412

if (error_ptr)

1413

error_ptr->SetErrorString("Divide by zero.");

return false;

}

else

{

stack.pop_back();

stack.back() = stack.back().ResolveValue(exe_ctx, ast_context) / tmp.ResolveValue(exe_ctx, ast_context);

1420

if (!stack.back().ResolveValue(exe_ctx, ast_context).IsValid())

1421

{

1422

if (error_ptr)

1423

error_ptr->SetErrorString("Divide failed.");

return false;

}

}

}

break;

//----------------------------------------------------------------------

1431

// OPCODE: DW_OP_minus

1432

// OPERANDS: none

1433

// DESCRIPTION: pops the top two stack values, subtracts the former top

1434

// of the stack from the former second entry, and pushes the result.

1435

//----------------------------------------------------------------------

1436

case DW_OP_minus:

1437

if (stack.size() < 2)

1438

{

1439

if (error_ptr)

1440

error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_minus.");

return false;

}

else

{

tmp = stack.back();

stack.pop_back();

stack.back().ResolveValue(exe_ctx, ast_context) = stack.back().ResolveValue(exe_ctx, ast_context) - tmp.ResolveValue(exe_ctx, ast_context);

}

break;

//----------------------------------------------------------------------

1452

// OPCODE: DW_OP_mod

1453

// OPERANDS: none

1454

// DESCRIPTION: pops the top two stack values and pushes the result of

1455

// the calculation: former second stack entry modulo the former top of

1456

// the stack.

1457

//----------------------------------------------------------------------

1458

case DW_OP_mod:

1459

if (stack.size() < 2)

1460

{

1461

if (error_ptr)

1462

error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_mod.");

return false;

}

else

{

tmp = stack.back();

stack.pop_back();

stack.back().ResolveValue(exe_ctx, ast_context) = stack.back().ResolveValue(exe_ctx, ast_context) % tmp.ResolveValue(exe_ctx, ast_context);

}

break;

//----------------------------------------------------------------------

1475

// OPCODE: DW_OP_mul

1476

// OPERANDS: none

1477

// DESCRIPTION: pops the top two stack entries, multiplies them

1478

// together, and pushes the result.

1479

//----------------------------------------------------------------------

1480

case DW_OP_mul:

1481

if (stack.size() < 2)

1482

{

1483

if (error_ptr)

1484

error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_mul.");

return false;

}

else

{

tmp = stack.back();

stack.pop_back();

stack.back().ResolveValue(exe_ctx, ast_context) = stack.back().ResolveValue(exe_ctx, ast_context) * tmp.ResolveValue(exe_ctx, ast_context);

}

break;

//----------------------------------------------------------------------

1496

// OPCODE: DW_OP_neg

1497

// OPERANDS: none

1498

// DESCRIPTION: pops the top stack entry, and pushes its negation.

1499

//----------------------------------------------------------------------

case DW_OP_neg:

if (stack.empty())

{

if (error_ptr)

error_ptr->SetErrorString("Expression stack needs at least 1 item for DW_OP_neg.");

return false;

}

else

{

if (stack.back().ResolveValue(exe_ctx, ast_context).UnaryNegate() == false)

1510

{

1511

if (error_ptr)

1512

error_ptr->SetErrorString("Unary negate failed.");

return false;

}

}

break;

//----------------------------------------------------------------------

1519

// OPCODE: DW_OP_not

1520

// OPERANDS: none

1521

// DESCRIPTION: pops the top stack entry, and pushes its bitwise

1522

// complement

1523

//----------------------------------------------------------------------

case DW_OP_not:

if (stack.empty())

{

if (error_ptr)

error_ptr->SetErrorString("Expression stack needs at least 1 item for DW_OP_not.");

return false;

}

else

{

if (stack.back().ResolveValue(exe_ctx, ast_context).OnesComplement() == false)

1534

{

1535

if (error_ptr)

1536

error_ptr->SetErrorString("Logical NOT failed.");

return false;

}

}

break;

//----------------------------------------------------------------------

1543

// OPCODE: DW_OP_or

1544

// OPERANDS: none

1545

// DESCRIPTION: pops the top two stack entries, performs a bitwise or

1546

// operation on the two, and pushes the result.

1547

//----------------------------------------------------------------------

1548

case DW_OP_or:

1549

if (stack.size() < 2)

1550

{

1551

if (error_ptr)

1552

error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_or.");

return false;

}

else

{

tmp = stack.back();

stack.pop_back();

stack.back().ResolveValue(exe_ctx, ast_context) = stack.back().ResolveValue(exe_ctx, ast_context) | tmp.ResolveValue(exe_ctx, ast_context);

}

break;

//----------------------------------------------------------------------

1564

// OPCODE: DW_OP_plus

1565

// OPERANDS: none

1566

// DESCRIPTION: pops the top two stack entries, adds them together, and

1567

// pushes the result.

1568

//----------------------------------------------------------------------

1569

case DW_OP_plus:

1570

if (stack.size() < 2)

1571

{

1572

if (error_ptr)

1573

error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_plus.");

return false;

}

else

{

tmp = stack.back();

stack.pop_back();

stack.back().ResolveValue(exe_ctx, ast_context) = stack.back().ResolveValue(exe_ctx, ast_context) + tmp.ResolveValue(exe_ctx, ast_context);

}

break;

//----------------------------------------------------------------------

1585

// OPCODE: DW_OP_plus_uconst

1586

// OPERANDS: none

1587

// DESCRIPTION: pops the top stack entry, adds it to the unsigned LEB128

1588

// constant operand and pushes the result.

1589

//----------------------------------------------------------------------

1590

case DW_OP_plus_uconst:

if (stack.empty())

{

if (error_ptr)

error_ptr->SetErrorString("Expression stack needs at least 1 item for DW_OP_plus_uconst.");

return false;

}

else

{

uint32_t uconst_value = opcodes.GetULEB128(&offset);

1600

// Implicit conversion from a UINT to a Scalar...

1601

stack.back().ResolveValue(exe_ctx, ast_context) += uconst_value;

1602

if (!stack.back().ResolveValue(exe_ctx, ast_context).IsValid())

1603

{

1604

if (error_ptr)

1605

error_ptr->SetErrorString("DW_OP_plus_uconst failed.");

return false;

}

}

break;

//----------------------------------------------------------------------

1612

// OPCODE: DW_OP_shl

1613

// OPERANDS: none

1614

// DESCRIPTION: pops the top two stack entries, shifts the former

1615

// second entry left by the number of bits specified by the former top

1616

// of the stack, and pushes the result.

1617

//----------------------------------------------------------------------

1618

case DW_OP_shl:

1619

if (stack.size() < 2)

1620

{

1621

if (error_ptr)

1622

error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_shl.");

return false;

}

else

{

tmp = stack.back();

stack.pop_back();

stack.back().ResolveValue(exe_ctx, ast_context) <<= tmp.ResolveValue(exe_ctx, ast_context);

}

break;

//----------------------------------------------------------------------

1634

// OPCODE: DW_OP_shr

1635

// OPERANDS: none

1636

// DESCRIPTION: pops the top two stack entries, shifts the former second

1637

// entry right logically (filling with zero bits) by the number of bits

1638

// specified by the former top of the stack, and pushes the result.

1639

//----------------------------------------------------------------------

1640

case DW_OP_shr:

1641

if (stack.size() < 2)

1642

{

1643

if (error_ptr)

1644

error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_shr.");

return false;

}

else

{

tmp = stack.back();

stack.pop_back();

if (stack.back().ResolveValue(exe_ctx, ast_context).ShiftRightLogical(tmp.ResolveValue(exe_ctx, ast_context)) == false)

1652

{

1653

if (error_ptr)

1654

error_ptr->SetErrorString("DW_OP_shr failed.");

return false;

}

}

break;

//----------------------------------------------------------------------

1661

// OPCODE: DW_OP_shra

1662

// OPERANDS: none

1663

// DESCRIPTION: pops the top two stack entries, shifts the former second

1664

// entry right arithmetically (divide the magnitude by 2, keep the same

1665

// sign for the result) by the number of bits specified by the former

1666

// top of the stack, and pushes the result.

1667

//----------------------------------------------------------------------

1668

case DW_OP_shra:

1669

if (stack.size() < 2)

1670

{

1671

if (error_ptr)

1672

error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_shra.");

return false;

}

else

{

tmp = stack.back();

stack.pop_back();

stack.back().ResolveValue(exe_ctx, ast_context) >>= tmp.ResolveValue(exe_ctx, ast_context);

}

break;

//----------------------------------------------------------------------

1684

// OPCODE: DW_OP_xor

1685

// OPERANDS: none

1686

// DESCRIPTION: pops the top two stack entries, performs the bitwise

1687

// exclusive-or operation on the two, and pushes the result.

1688

//----------------------------------------------------------------------

1689

case DW_OP_xor:

1690

if (stack.size() < 2)

1691

{

1692

if (error_ptr)

1693

error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_xor.");

return false;

}

else

{

tmp = stack.back();

stack.pop_back();

stack.back().ResolveValue(exe_ctx, ast_context) = stack.back().ResolveValue(exe_ctx, ast_context) ^ tmp.ResolveValue(exe_ctx, ast_context);

}

break;

//----------------------------------------------------------------------

1706

// OPCODE: DW_OP_skip

1707

// OPERANDS: int16_t

1708

// DESCRIPTION: An unconditional branch. Its single operand is a 2-byte

1709

// signed integer constant. The 2-byte constant is the number of bytes

1710

// of the DWARF expression to skip forward or backward from the current

1711

// operation, beginning after the 2-byte constant.

1712

//----------------------------------------------------------------------

1713

case DW_OP_skip:

1714

{

1715

int16_t skip_offset = (int16_t)opcodes.GetU16(&offset);

1716

uint32_t new_offset = offset + skip_offset;

1717

if (new_offset >= opcodes_offset && new_offset < end_offset)

offset = new_offset;

else

{

if (error_ptr)

error_ptr->SetErrorString("Invalid opcode offset in DW_OP_skip.");

return false;

}

}

break;

//----------------------------------------------------------------------

1729

// OPCODE: DW_OP_bra

1730

// OPERANDS: int16_t

1731

// DESCRIPTION: A conditional branch. Its single operand is a 2-byte

1732

// signed integer constant. This operation pops the top of stack. If

1733

// the value popped is not the constant 0, the 2-byte constant operand

1734

// is the number of bytes of the DWARF expression to skip forward or

1735

// backward from the current operation, beginning after the 2-byte

1736

// constant.

1737

//----------------------------------------------------------------------

case DW_OP_bra:

{

tmp = stack.back();

stack.pop_back();

int16_t bra_offset = (int16_t)opcodes.GetU16(&offset);

1743

Scalar zero(0);

1744

if (tmp.ResolveValue(exe_ctx, ast_context) != zero)

1745

{

1746

uint32_t new_offset = offset + bra_offset;

1747

if (new_offset >= opcodes_offset && new_offset < end_offset)

offset = new_offset;

else

{

if (error_ptr)

error_ptr->SetErrorString("Invalid opcode offset in DW_OP_bra.");

return false;

}

}

}

break;

//----------------------------------------------------------------------

1760

// OPCODE: DW_OP_eq

1761

// OPERANDS: none

1762

// DESCRIPTION: pops the top two stack values, compares using the

1763

// equals (==) operator.

1764

// STACK RESULT: push the constant value 1 onto the stack if the result

1765

// of the operation is true or the constant value 0 if the result of the

1766

// operation is false.

1767

//----------------------------------------------------------------------

1768

case DW_OP_eq:

1769

if (stack.size() < 2)

1770

{

1771

if (error_ptr)

1772

error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_eq.");

return false;

}

else

{

tmp = stack.back();

stack.pop_back();

stack.back().ResolveValue(exe_ctx, ast_context) = stack.back().ResolveValue(exe_ctx, ast_context) == tmp.ResolveValue(exe_ctx, ast_context);

}

break;

//----------------------------------------------------------------------

1784

// OPCODE: DW_OP_ge

1785

// OPERANDS: none

1786

// DESCRIPTION: pops the top two stack values, compares using the

1787

// greater than or equal to (>=) operator.

1788

// STACK RESULT: push the constant value 1 onto the stack if the result

1789

// of the operation is true or the constant value 0 if the result of the

1790

// operation is false.

1791

//----------------------------------------------------------------------

1792

case DW_OP_ge:

1793

if (stack.size() < 2)

1794

{

1795

if (error_ptr)

1796

error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_ge.");

return false;

}

else

{

tmp = stack.back();

stack.pop_back();

stack.back().ResolveValue(exe_ctx, ast_context) = stack.back().ResolveValue(exe_ctx, ast_context) >= tmp.ResolveValue(exe_ctx, ast_context);

}

break;

//----------------------------------------------------------------------

1808

// OPCODE: DW_OP_gt

1809

// OPERANDS: none

1810

// DESCRIPTION: pops the top two stack values, compares using the

1811

// greater than (>) operator.

1812

// STACK RESULT: push the constant value 1 onto the stack if the result

1813

// of the operation is true or the constant value 0 if the result of the

1814

// operation is false.

1815

//----------------------------------------------------------------------

1816

case DW_OP_gt:

1817

if (stack.size() < 2)

1818

{

1819

if (error_ptr)

1820

error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_gt.");

return false;

}

else

{

tmp = stack.back();

stack.pop_back();

stack.back().ResolveValue(exe_ctx, ast_context) = stack.back().ResolveValue(exe_ctx, ast_context) > tmp.ResolveValue(exe_ctx, ast_context);

}

break;

//----------------------------------------------------------------------

1832

// OPCODE: DW_OP_le

1833

// OPERANDS: none

1834

// DESCRIPTION: pops the top two stack values, compares using the

1835

// less than or equal to (<=) operator.

1836

// STACK RESULT: push the constant value 1 onto the stack if the result

1837

// of the operation is true or the constant value 0 if the result of the

1838

// operation is false.

1839

//----------------------------------------------------------------------

1840

case DW_OP_le:

1841

if (stack.size() < 2)

1842

{

1843

if (error_ptr)

1844

error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_le.");

return false;

}

else

{

tmp = stack.back();

stack.pop_back();

stack.back().ResolveValue(exe_ctx, ast_context) = stack.back().ResolveValue(exe_ctx, ast_context) <= tmp.ResolveValue(exe_ctx, ast_context);

}

break;

//----------------------------------------------------------------------

1856

// OPCODE: DW_OP_lt

1857

// OPERANDS: none

1858

// DESCRIPTION: pops the top two stack values, compares using the

1859

// less than (<) operator.

1860

// STACK RESULT: push the constant value 1 onto the stack if the result

1861

// of the operation is true or the constant value 0 if the result of the

1862

// operation is false.

1863

//----------------------------------------------------------------------

1864

case DW_OP_lt:

1865

if (stack.size() < 2)

1866

{

1867

if (error_ptr)

1868

error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_lt.");

return false;

}

else

{

tmp = stack.back();

stack.pop_back();

stack.back().ResolveValue(exe_ctx, ast_context) = stack.back().ResolveValue(exe_ctx, ast_context) < tmp.ResolveValue(exe_ctx, ast_context);

}

break;

//----------------------------------------------------------------------

1880

// OPCODE: DW_OP_ne

1881

// OPERANDS: none

1882

// DESCRIPTION: pops the top two stack values, compares using the

1883

// not equal (!=) operator.

1884

// STACK RESULT: push the constant value 1 onto the stack if the result

1885

// of the operation is true or the constant value 0 if the result of the

1886

// operation is false.

1887

//----------------------------------------------------------------------

1888

case DW_OP_ne:

1889

if (stack.size() < 2)

1890

{

1891

if (error_ptr)

1892

error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_ne.");

return false;

}

else

{

tmp = stack.back();

stack.pop_back();

stack.back().ResolveValue(exe_ctx, ast_context) = stack.back().ResolveValue(exe_ctx, ast_context) != tmp.ResolveValue(exe_ctx, ast_context);

}

break;

//----------------------------------------------------------------------

1904

// OPCODE: DW_OP_litn

1905

// OPERANDS: none

1906

// DESCRIPTION: encode the unsigned literal values from 0 through 31.

1907

// STACK RESULT: push the unsigned literal constant value onto the top

1908

// of the stack.

1909

//----------------------------------------------------------------------

case DW_OP_lit0:

case DW_OP_lit1:

case DW_OP_lit2:

case DW_OP_lit3:

case DW_OP_lit4:

case DW_OP_lit5:

case DW_OP_lit6:

case DW_OP_lit7:

case DW_OP_lit8:

case DW_OP_lit9:

case DW_OP_lit10:

case DW_OP_lit11:

case DW_OP_lit12:

case DW_OP_lit13:

case DW_OP_lit14:

case DW_OP_lit15:

case DW_OP_lit16:

case DW_OP_lit17:

case DW_OP_lit18:

case DW_OP_lit19:

case DW_OP_lit20:

case DW_OP_lit21:

case DW_OP_lit22:

case DW_OP_lit23:

case DW_OP_lit24:

case DW_OP_lit25:

case DW_OP_lit26:

case DW_OP_lit27:

case DW_OP_lit28:

case DW_OP_lit29:

case DW_OP_lit30:

case DW_OP_lit31:

Greg Clayton

2011-07-07 01:59:51 +0000

[diff] [blame]

1942

stack.push_back(Scalar(op - DW_OP_lit0));

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

1943

break;

1944

1945

//----------------------------------------------------------------------

1946

// OPCODE: DW_OP_regN

1947

// OPERANDS: none

1948

// DESCRIPTION: Push the value in register n on the top of the stack.

1949

//----------------------------------------------------------------------

case DW_OP_reg0:

case DW_OP_reg1:

case DW_OP_reg2:

case DW_OP_reg3:

case DW_OP_reg4:

case DW_OP_reg5:

case DW_OP_reg6:

case DW_OP_reg7:

case DW_OP_reg8:

case DW_OP_reg9:

case DW_OP_reg10:

case DW_OP_reg11:

case DW_OP_reg12:

case DW_OP_reg13:

case DW_OP_reg14:

case DW_OP_reg15:

case DW_OP_reg16:

case DW_OP_reg17:

case DW_OP_reg18:

case DW_OP_reg19:

case DW_OP_reg20:

case DW_OP_reg21:

case DW_OP_reg22:

case DW_OP_reg23:

case DW_OP_reg24:

case DW_OP_reg25:

case DW_OP_reg26:

case DW_OP_reg27:

case DW_OP_reg28:

case DW_OP_reg29:

case DW_OP_reg30:

case DW_OP_reg31:

{

reg_num = op - DW_OP_reg0;

1984

Jason Molenda

2010-11-20 01:28:30 +0000

[diff] [blame]

1985

if (ReadRegisterValueAsScalar (reg_ctx, reg_kind, reg_num, error_ptr, tmp))

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

1986

stack.push_back(tmp);

else

return false;

}

break;

//----------------------------------------------------------------------

1992

// OPCODE: DW_OP_regx

1993

// OPERANDS:

1994

// ULEB128 literal operand that encodes the register.

1995

// DESCRIPTION: Push the value in register on the top of the stack.

1996

//----------------------------------------------------------------------

1997

case DW_OP_regx:

1998

{

1999

reg_num = opcodes.GetULEB128(&offset);

Jason Molenda

2010-11-20 01:28:30 +0000

[diff] [blame]

2000

if (ReadRegisterValueAsScalar (reg_ctx, reg_kind, reg_num, error_ptr, tmp))

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

2001

stack.push_back(tmp);

else

return false;

}

break;

//----------------------------------------------------------------------

2008

// OPCODE: DW_OP_bregN

2009

// OPERANDS:

2010

// SLEB128 offset from register N

2011

// DESCRIPTION: Value is in memory at the address specified by register

2012

// N plus an offset.

2013

//----------------------------------------------------------------------

case DW_OP_breg0:

case DW_OP_breg1:

case DW_OP_breg2:

case DW_OP_breg3:

case DW_OP_breg4:

case DW_OP_breg5:

case DW_OP_breg6:

case DW_OP_breg7:

case DW_OP_breg8:

case DW_OP_breg9:

case DW_OP_breg10:

case DW_OP_breg11:

case DW_OP_breg12:

case DW_OP_breg13:

case DW_OP_breg14:

case DW_OP_breg15:

case DW_OP_breg16:

case DW_OP_breg17:

case DW_OP_breg18:

case DW_OP_breg19:

case DW_OP_breg20:

case DW_OP_breg21:

case DW_OP_breg22:

case DW_OP_breg23:

case DW_OP_breg24:

case DW_OP_breg25:

case DW_OP_breg26:

case DW_OP_breg27:

case DW_OP_breg28:

case DW_OP_breg29:

case DW_OP_breg30:

case DW_OP_breg31:

{

reg_num = op - DW_OP_breg0;

2048

Jason Molenda

2010-11-20 01:28:30 +0000

[diff] [blame]

2049

if (ReadRegisterValueAsScalar (reg_ctx, reg_kind, reg_num, error_ptr, tmp))

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

2050

{

2051

int64_t breg_offset = opcodes.GetSLEB128(&offset);

2052

tmp.ResolveValue(exe_ctx, ast_context) += (uint64_t)breg_offset;

2053

stack.push_back(tmp);

2054

stack.back().SetValueType (Value::eValueTypeLoadAddress);

}

else

return false;

}

break;

//----------------------------------------------------------------------

2061

// OPCODE: DW_OP_bregx

2062

// OPERANDS: 2

2063

// ULEB128 literal operand that encodes the register.

2064

// SLEB128 offset from register N

2065

// DESCRIPTION: Value is in memory at the address specified by register

2066

// N plus an offset.

2067

//----------------------------------------------------------------------

2068

case DW_OP_bregx:

2069

{

2070

reg_num = opcodes.GetULEB128(&offset);

2071

Jason Molenda

2010-11-20 01:28:30 +0000

[diff] [blame]

2072

if (ReadRegisterValueAsScalar (reg_ctx, reg_kind, reg_num, error_ptr, tmp))

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

2073

{

2074

int64_t breg_offset = opcodes.GetSLEB128(&offset);

2075

tmp.ResolveValue(exe_ctx, ast_context) += (uint64_t)breg_offset;

2076

stack.push_back(tmp);

2077

stack.back().SetValueType (Value::eValueTypeLoadAddress);

}

else

return false;

}

break;

case DW_OP_fbreg:

if (exe_ctx && exe_ctx->frame)

2086

{

2087

Scalar value;

2088

if (exe_ctx->frame->GetFrameBaseValue(value, error_ptr))

2089

{

2090

int64_t fbreg_offset = opcodes.GetSLEB128(&offset);

2091

value += fbreg_offset;

2092

stack.push_back(value);

2093

stack.back().SetValueType (Value::eValueTypeLoadAddress);

}

else

return false;

}

else

{

if (error_ptr)

error_ptr->SetErrorString ("Invalid stack frame in context for DW_OP_fbreg opcode.");

return false;

}

break;

//----------------------------------------------------------------------

2107

// OPCODE: DW_OP_nop

2108

// OPERANDS: none

2109

// DESCRIPTION: A place holder. It has no effect on the location stack

2110

// or any of its values.

2111

//----------------------------------------------------------------------

case DW_OP_nop:

break;

//----------------------------------------------------------------------

2116

// OPCODE: DW_OP_piece

2117

// OPERANDS: 1

2118

// ULEB128: byte size of the piece

2119

// DESCRIPTION: The operand describes the size in bytes of the piece of

2120

// the object referenced by the DWARF expression whose result is at the

2121

// top of the stack. If the piece is located in a register, but does not

2122

// occupy the entire register, the placement of the piece within that

2123

// register is defined by the ABI.

2124

//

2125

// Many compilers store a single variable in sets of registers, or store

2126

// a variable partially in memory and partially in registers.

2127

// DW_OP_piece provides a way of describing how large a part of a

2128

// variable a particular DWARF expression refers to.

2129

//----------------------------------------------------------------------

2130

case DW_OP_piece:

2131

if (error_ptr)

2132

error_ptr->SetErrorString ("Unimplemented opcode DW_OP_piece.");

2133

return false;

2134

2135

//----------------------------------------------------------------------

2136

// OPCODE: DW_OP_push_object_address

2137

// OPERANDS: none

2138

// DESCRIPTION: Pushes the address of the object currently being

2139

// evaluated as part of evaluation of a user presented expression.

2140

// This object may correspond to an independent variable described by

2141

// its own DIE or it may be a component of an array, structure, or class

2142

// whose address has been dynamically determined by an earlier step

2143

// during user expression evaluation.

2144

//----------------------------------------------------------------------

2145

case DW_OP_push_object_address:

2146

if (error_ptr)

2147

error_ptr->SetErrorString ("Unimplemented opcode DW_OP_push_object_address.");

2148

return false;

2149

2150

//----------------------------------------------------------------------

2151

// OPCODE: DW_OP_call2

2152

// OPERANDS:

2153

// uint16_t compile unit relative offset of a DIE

2154

// DESCRIPTION: Performs subroutine calls during evaluation

2155

// of a DWARF expression. The operand is the 2-byte unsigned offset

2156

// of a debugging information entry in the current compilation unit.

2157

//

2158

// Operand interpretation is exactly like that for DW_FORM_ref2.

2159

//

2160

// This operation transfers control of DWARF expression evaluation

2161

// to the DW_AT_location attribute of the referenced DIE. If there is

2162

// no such attribute, then there is no effect. Execution of the DWARF

2163

// expression of a DW_AT_location attribute may add to and/or remove from

2164

// values on the stack. Execution returns to the point following the call

2165

// when the end of the attribute is reached. Values on the stack at the

2166

// time of the call may be used as parameters by the called expression

2167

// and values left on the stack by the called expression may be used as

2168

// return values by prior agreement between the calling and called

2169

// expressions.

2170

//----------------------------------------------------------------------

2171

case DW_OP_call2:

2172

if (error_ptr)

2173

error_ptr->SetErrorString ("Unimplemented opcode DW_OP_call2.");

2174

return false;

2175

//----------------------------------------------------------------------

2176

// OPCODE: DW_OP_call4

2177

// OPERANDS: 1

2178

// uint32_t compile unit relative offset of a DIE

2179

// DESCRIPTION: Performs a subroutine call during evaluation of a DWARF

2180

// expression. For DW_OP_call4, the operand is a 4-byte unsigned offset

2181

// of a debugging information entry in the current compilation unit.

2182

//

2183

// Operand interpretation DW_OP_call4 is exactly like that for

2184

// DW_FORM_ref4.

2185

//

2186

// This operation transfers control of DWARF expression evaluation

2187

// to the DW_AT_location attribute of the referenced DIE. If there is

2188

// no such attribute, then there is no effect. Execution of the DWARF

2189

// expression of a DW_AT_location attribute may add to and/or remove from

2190

// values on the stack. Execution returns to the point following the call

2191

// when the end of the attribute is reached. Values on the stack at the

2192

// time of the call may be used as parameters by the called expression

2193

// and values left on the stack by the called expression may be used as

2194

// return values by prior agreement between the calling and called

2195

// expressions.

2196

//----------------------------------------------------------------------

2197

case DW_OP_call4:

2198

if (error_ptr)

2199

error_ptr->SetErrorString ("Unimplemented opcode DW_OP_call4.");

return false;

//----------------------------------------------------------------------

2204

// OPCODE: DW_OP_call_ref

2205

// OPERANDS:

2206

// uint32_t absolute DIE offset for 32-bit DWARF or a uint64_t

2207

// absolute DIE offset for 64 bit DWARF.

2208

// DESCRIPTION: Performs a subroutine call during evaluation of a DWARF

2209

// expression. Takes a single operand. In the 32-bit DWARF format, the

2210

// operand is a 4-byte unsigned value; in the 64-bit DWARF format, it

2211

// is an 8-byte unsigned value. The operand is used as the offset of a

2212

// debugging information entry in a .debug_info section which may be

2213

// contained in a shared object for executable other than that

2214

// containing the operator. For references from one shared object or

2215

// executable to another, the relocation must be performed by the

2216

// consumer.

2217

//

2218

// Operand interpretation of DW_OP_call_ref is exactly like that for

2219

// DW_FORM_ref_addr.

2220

//

2221

// This operation transfers control of DWARF expression evaluation

2222

// to the DW_AT_location attribute of the referenced DIE. If there is

2223

// no such attribute, then there is no effect. Execution of the DWARF

2224

// expression of a DW_AT_location attribute may add to and/or remove from

2225

// values on the stack. Execution returns to the point following the call

2226

// when the end of the attribute is reached. Values on the stack at the

2227

// time of the call may be used as parameters by the called expression

2228

// and values left on the stack by the called expression may be used as

2229

// return values by prior agreement between the calling and called

2230

// expressions.

2231

//----------------------------------------------------------------------

2232

case DW_OP_call_ref:

2233

if (error_ptr)

2234

error_ptr->SetErrorString ("Unimplemented opcode DW_OP_call_ref.");

2235

return false;

2236

2237

//----------------------------------------------------------------------

2238

// OPCODE: DW_OP_APPLE_array_ref

2239

// OPERANDS: none

2240

// DESCRIPTION: Pops a value off the stack and uses it as the array

2241

// index. Pops a second value off the stack and uses it as the array

2242

// itself. Pushes a value onto the stack representing the element of

2243

// the array specified by the index.

2244

//----------------------------------------------------------------------

2245

case DW_OP_APPLE_array_ref:

2246

{

2247

if (stack.size() < 2)

2248

{

2249

if (error_ptr)

2250

error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_APPLE_array_ref.");

return false;

}

Value index_val = stack.back();

2255

stack.pop_back();

2256

Value array_val = stack.back();

2257

stack.pop_back();

2258

2259

Scalar &index_scalar = index_val.ResolveValue(exe_ctx, ast_context);

Greg Clayton

381f968

2011-04-01 18:14:08 +0000

[diff] [blame]

2260

int64_t index = index_scalar.SLongLong(LLONG_MAX);

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

2261

Greg Clayton

381f968

2011-04-01 18:14:08 +0000

[diff] [blame]

2262

if (index == LLONG_MAX)

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

2263

{

2264

if (error_ptr)

2265

error_ptr->SetErrorString("Invalid array index.");

return false;

}

Greg Clayton

2010-11-13 03:52:47 +0000

[diff] [blame]

2269

if (array_val.GetContextType() != Value::eContextTypeClangType)

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

2270

{

2271

if (error_ptr)

2272

error_ptr->SetErrorString("Arrays without Clang types are unhandled at this time.");

return false;

}

if (array_val.GetValueType() != Value::eValueTypeLoadAddress &&

2277

array_val.GetValueType() != Value::eValueTypeHostAddress)

2278

{

2279

if (error_ptr)

2280

error_ptr->SetErrorString("Array must be stored in memory.");

return false;

}

Greg Clayton

2010-09-29 01:12:09 +0000

[diff] [blame]

2284

void *array_type = array_val.GetClangType();

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

void *member_type;

uint64_t size = 0;

if ((!ClangASTContext::IsPointerType(array_type, &member_type)) &&

2290

(!ClangASTContext::IsArrayType(array_type, &member_type, &size)))

2291

{

2292

if (error_ptr)

2293

error_ptr->SetErrorString("Array reference from something that is neither a pointer nor an array.");

return false;

}

if (size && (index >= size || index < 0))

2298

{

2299

if (error_ptr)

2300

error_ptr->SetErrorStringWithFormat("Out of bounds array access. %lld is not in [0, %llu]", index, size);

return false;

}

Greg Clayton

2010-08-03 00:35:52 +0000

[diff] [blame]

2304

uint64_t member_bit_size = ClangASTType::GetClangTypeBitWidth(ast_context, member_type);

2305

uint64_t member_bit_align = ClangASTType::GetTypeBitAlign(ast_context, member_type);

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

2306

uint64_t member_bit_incr = ((member_bit_size + member_bit_align - 1) / member_bit_align) * member_bit_align;

2307

if (member_bit_incr % 8)

2308

{

2309

if (error_ptr)

2310

error_ptr->SetErrorStringWithFormat("Array increment is not byte aligned", index, size);

2311

return false;

2312

}

2313

int64_t member_offset = (int64_t)(member_bit_incr / 8) * index;

Value member;

Greg Clayton

2010-11-13 03:52:47 +0000

[diff] [blame]

2317

member.SetContext(Value::eContextTypeClangType, member_type);

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

2318

member.SetValueType(array_val.GetValueType());

2319

2320

addr_t array_base = (addr_t)array_val.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);

2321

addr_t member_loc = array_base + member_offset;

2322

member.GetScalar() = (uint64_t)member_loc;

2323

2324

stack.push_back(member);

}

break;

//----------------------------------------------------------------------

2329

// OPCODE: DW_OP_APPLE_uninit

2330

// OPERANDS: none

2331

// DESCRIPTION: Lets us know that the value is currently not initialized

2332

//----------------------------------------------------------------------

2333

case DW_OP_APPLE_uninit:

2334

//return eResultTypeErrorUninitialized;

2335

break; // Ignore this as we have seen cases where this value is incorrectly added

2336

2337

//----------------------------------------------------------------------

2338

// OPCODE: DW_OP_APPLE_assign

2339

// OPERANDS: none

2340

// DESCRIPTION: Pops a value off of the stack and assigns it to the next

2341

// item on the stack which must be something assignable (inferior

2342

// Variable, inferior Type with address, inferior register, or

2343

// expression local variable.

2344

//----------------------------------------------------------------------

2345

case DW_OP_APPLE_assign:

2346

if (stack.size() < 2)

2347

{

2348

if (error_ptr)

2349

error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_APPLE_assign.");

return false;

}

else

{

tmp = stack.back();

stack.pop_back();

Value::ContextType context_type = stack.back().GetContextType();

Greg Clayton

cd54803

2011-02-01 01:31:41 +0000

[diff] [blame]

2357

StreamString new_value(Stream::eBinary, 4, lldb::endian::InlHostByteOrder());

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

2358

switch (context_type)

2359

{

Greg Clayton

2010-11-13 03:52:47 +0000

[diff] [blame]

2360

case Value::eContextTypeClangType:

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

2361

{

Greg Clayton

462d414

2010-09-29 01:12:09 +0000

[diff] [blame]

2362

void *clang_type = stack.back().GetClangType();

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

2363

2364

if (ClangASTContext::IsAggregateType (clang_type))

2365

{

2366

Value::ValueType source_value_type = tmp.GetValueType();

2367

Value::ValueType target_value_type = stack.back().GetValueType();

2368

2369

addr_t source_addr = (addr_t)tmp.GetScalar().ULongLong();

2370

addr_t target_addr = (addr_t)stack.back().GetScalar().ULongLong();

2371

Greg Clayton

960d6a4

2010-08-03 00:35:52 +0000

[diff] [blame]

2372

size_t byte_size = (ClangASTType::GetClangTypeBitWidth(ast_context, clang_type) + 7) / 8;

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

2373

2374

switch (source_value_type)

2375

{

Greg Clayton

4fdf760

2011-03-20 04:57:14 +0000

[diff] [blame]

2376

case Value::eValueTypeScalar:

2377

case Value::eValueTypeFileAddress:

2378

break;

2379

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

2380

case Value::eValueTypeLoadAddress:

2381

switch (target_value_type)

2382

{

2383

case Value::eValueTypeLoadAddress:

2384

{

2385

DataBufferHeap data;

2386

data.SetByteSize(byte_size);

2387

2388

Error error;

2389

if (exe_ctx->process->ReadMemory (source_addr, data.GetBytes(), byte_size, error) != byte_size)

2390

{

2391

if (error_ptr)

2392

error_ptr->SetErrorStringWithFormat ("Couldn't read a composite type from the target: %s", error.AsCString());

return false;

}

if (exe_ctx->process->WriteMemory (target_addr, data.GetBytes(), byte_size, error) != byte_size)

2397

{

2398

if (error_ptr)

2399

error_ptr->SetErrorStringWithFormat ("Couldn't write a composite type to the target: %s", error.AsCString());

return false;

}

}

break;

case Value::eValueTypeHostAddress:

Greg Clayton

cd54803

2011-02-01 01:31:41 +0000

[diff] [blame]

2405

if (exe_ctx->process->GetByteOrder() != lldb::endian::InlHostByteOrder())

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

2406

{

2407

if (error_ptr)

2408

error_ptr->SetErrorStringWithFormat ("Copy of composite types between incompatible byte orders is unimplemented");

return false;

}

else

{

Error error;

if (exe_ctx->process->ReadMemory (source_addr, (uint8_t*)target_addr, byte_size, error) != byte_size)

2415

{

2416

if (error_ptr)

2417

error_ptr->SetErrorStringWithFormat ("Couldn't read a composite type from the target: %s", error.AsCString());

return false;

}

}

break;

default:

return false;

}

break;

case Value::eValueTypeHostAddress:

2427

switch (target_value_type)

2428

{

2429

case Value::eValueTypeLoadAddress:

Greg Clayton

cd54803

2011-02-01 01:31:41 +0000

[diff] [blame]

2430

if (exe_ctx->process->GetByteOrder() != lldb::endian::InlHostByteOrder())

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

2431

{

2432

if (error_ptr)

2433

error_ptr->SetErrorStringWithFormat ("Copy of composite types between incompatible byte orders is unimplemented");

return false;

}

else

{

Error error;

if (exe_ctx->process->WriteMemory (target_addr, (uint8_t*)source_addr, byte_size, error) != byte_size)

2440

{

2441

if (error_ptr)

2442

error_ptr->SetErrorStringWithFormat ("Couldn't write a composite type to the target: %s", error.AsCString());

return false;

}

}

case Value::eValueTypeHostAddress:

2447

memcpy ((uint8_t*)target_addr, (uint8_t*)source_addr, byte_size);

break;

default:

return false;

}

}

}

else

{

Greg Clayton

1674b12

2010-07-21 22:12:05 +0000

[diff] [blame]

2456

if (!ClangASTType::SetValueFromScalar (ast_context,

2457

clang_type,

2458

tmp.ResolveValue(exe_ctx, ast_context),

2459

new_value))

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

2460

{

2461

if (error_ptr)

2462

error_ptr->SetErrorStringWithFormat ("Couldn't extract a value from an integral type.\n");

return false;

}

Value::ValueType value_type = stack.back().GetValueType();

switch (value_type)

{

case Value::eValueTypeLoadAddress:

2471

case Value::eValueTypeHostAddress:

2472

{

Greg Clayton

b344843

2011-03-24 21:19:54 +0000

[diff] [blame]

2473

AddressType address_type = (value_type == Value::eValueTypeLoadAddress ? eAddressTypeLoad : eAddressTypeHost);

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

2474

lldb::addr_t addr = stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS);

Greg Clayton

1674b12

2010-07-21 22:12:05 +0000

[diff] [blame]

2475

if (!ClangASTType::WriteToMemory (ast_context,

clang_type,

exe_ctx,

addr,

address_type,

new_value))

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

2481

{

2482

if (error_ptr)

2483

error_ptr->SetErrorStringWithFormat ("Failed to write value to memory at 0x%llx.\n", addr);

return false;

}

}

break;

default:

break;

}

}

}

break;

default:

if (error_ptr)

error_ptr->SetErrorString ("Assign failed.");

return false;

}

}

break;

//----------------------------------------------------------------------

2505

// OPCODE: DW_OP_APPLE_address_of

2506

// OPERANDS: none

2507

// DESCRIPTION: Pops a value off of the stack and pushed its address.

2508

// The top item on the stack must be a variable, or already be a memory

2509

// location.

2510

//----------------------------------------------------------------------

2511

case DW_OP_APPLE_address_of:

if (stack.empty())

{

if (error_ptr)

error_ptr->SetErrorString("Expression stack needs at least 1 item for DW_OP_APPLE_address_of.");

return false;

}

else

{

Value::ValueType value_type = stack.back().GetValueType();

switch (value_type)

{

default:

case Value::eValueTypeScalar: // raw scalar value

2525

if (error_ptr)

2526

error_ptr->SetErrorString("Top stack item isn't a memory based object.");

2527

return false;

2528

2529

case Value::eValueTypeLoadAddress: // load address value

2530

case Value::eValueTypeFileAddress: // file address value

2531

case Value::eValueTypeHostAddress: // host address value (for memory in the process that is using liblldb)

2532

// Taking the address of an object reduces it to the address

2533

// of the value and removes any extra context it had.

2534

//stack.back().SetValueType(Value::eValueTypeScalar);

2535

stack.back().ClearContext();

break;

}

}

break;

//----------------------------------------------------------------------

2542

// OPCODE: DW_OP_APPLE_value_of

2543

// OPERANDS: none

2544

// DESCRIPTION: Pops a value off of the stack and pushed its value.

2545

// The top item on the stack must be a variable, expression variable.

2546

//----------------------------------------------------------------------

2547

case DW_OP_APPLE_value_of:

if (stack.empty())

{

if (error_ptr)

error_ptr->SetErrorString("Expression stack needs at least 1 items for DW_OP_APPLE_value_of.");

2552

return false;

2553

}

2554

else if (!stack.back().ValueOf(exe_ctx, ast_context))

2555

{

2556

if (error_ptr)

2557

error_ptr->SetErrorString ("Top stack item isn't a valid candidate for DW_OP_APPLE_value_of.");

return false;

}

break;

//----------------------------------------------------------------------

2563

// OPCODE: DW_OP_APPLE_deref_type

2564

// OPERANDS: none

2565

// DESCRIPTION: gets the value pointed to by the top stack item

2566

//----------------------------------------------------------------------

2567

case DW_OP_APPLE_deref_type:

{

if (stack.empty())

{

if (error_ptr)

error_ptr->SetErrorString("Expression stack needs at least 1 items for DW_OP_APPLE_deref_type.");

return false;

}

tmp = stack.back();

stack.pop_back();

Greg Clayton

2010-11-13 03:52:47 +0000

[diff] [blame]

2579

if (tmp.GetContextType() != Value::eContextTypeClangType)

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

2580

{

2581

if (error_ptr)

2582

error_ptr->SetErrorString("Item at top of expression stack must have a Clang type");

return false;

}

Greg Clayton

2010-09-29 01:12:09 +0000

[diff] [blame]

2586

void *ptr_type = tmp.GetClangType();

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

2587

void *target_type;

2588

2589

if (!ClangASTContext::IsPointerType(ptr_type, &target_type))

2590

{

2591

if (error_ptr)

2592

error_ptr->SetErrorString("Dereferencing a non-pointer type");

return false;

}

// TODO do we want all pointers to be dereferenced as load addresses?

2597

Value::ValueType value_type = tmp.GetValueType();

2598

2599

tmp.ResolveValue(exe_ctx, ast_context);

2600

2601

tmp.SetValueType(value_type);

Greg Clayton

2010-11-13 03:52:47 +0000

[diff] [blame]

2602

tmp.SetContext(Value::eContextTypeClangType, target_type);

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

2603

2604

stack.push_back(tmp);

}

break;

//----------------------------------------------------------------------

2609

// OPCODE: DW_OP_APPLE_expr_local

2610

// OPERANDS: ULEB128

2611

// DESCRIPTION: pushes the expression local variable index onto the

2612

// stack and set the appropriate context so we know the stack item is

2613

// an expression local variable index.

2614

//----------------------------------------------------------------------

2615

case DW_OP_APPLE_expr_local:

2616

{

Sean Callanan

a622343

2010-08-20 01:02:30 +0000

[diff] [blame]

2617

/*

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

2618

uint32_t idx = opcodes.GetULEB128(&offset);

2619

if (expr_locals == NULL)

2620

{

2621

if (error_ptr)

2622

error_ptr->SetErrorStringWithFormat ("DW_OP_APPLE_expr_local(%u) opcode encountered with no local variable list.\n", idx);

2623

return false;

2624

}

2625

Value *expr_local_variable = expr_locals->GetVariableAtIndex(idx);

2626

if (expr_local_variable == NULL)

2627

{

2628

if (error_ptr)

2629

error_ptr->SetErrorStringWithFormat ("DW_OP_APPLE_expr_local(%u) with invalid index %u.\n", idx, idx);

2630

return false;

2631

}

Greg Clayton

2011-07-07 01:59:51 +0000

[diff] [blame]

2632

// The proxy code has been removed. If it is ever re-added, please

2633

// use shared pointers or return by value to avoid possible memory

2634

// leak (there is no leak here, but in general, no returning pointers

2635

// that must be manually freed please.

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

2636

Value *proxy = expr_local_variable->CreateProxy();

2637

stack.push_back(*proxy);

2638

delete proxy;

Greg Clayton

2010-11-13 03:52:47 +0000

[diff] [blame]

2639

//stack.back().SetContext (Value::eContextTypeClangType, expr_local_variable->GetClangType());

Sean Callanan

a622343

2010-08-20 01:02:30 +0000

[diff] [blame]

2640

*/

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

}

break;

//----------------------------------------------------------------------

2645

// OPCODE: DW_OP_APPLE_extern

2646

// OPERANDS: ULEB128

2647

// DESCRIPTION: pushes a proxy for the extern object index onto the

2648

// stack.

2649

//----------------------------------------------------------------------

2650

case DW_OP_APPLE_extern:

2651

{

Sean Callanan

8c12720

2010-08-23 23:09:38 +0000

[diff] [blame]

2652

/*

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

2653

uint32_t idx = opcodes.GetULEB128(&offset);

if (!decl_map)

{

if (error_ptr)

error_ptr->SetErrorStringWithFormat ("DW_OP_APPLE_extern(%u) opcode encountered with no decl map.\n", idx);

2658

return false;

2659

}

2660

Value *extern_var = decl_map->GetValueForIndex(idx);

if (!extern_var)

{

if (error_ptr)

error_ptr->SetErrorStringWithFormat ("DW_OP_APPLE_extern(%u) with invalid index %u.\n", idx, idx);

2665

return false;

2666

}

Greg Clayton

2011-07-07 01:59:51 +0000

[diff] [blame]

2667

// The proxy code has been removed. If it is ever re-added, please

2668

// use shared pointers or return by value to avoid possible memory

2669

// leak (there is no leak here, but in general, no returning pointers

2670

// that must be manually freed please.

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

2671

Value *proxy = extern_var->CreateProxy();

2672

stack.push_back(*proxy);

2673

delete proxy;

Sean Callanan

8c12720

2010-08-23 23:09:38 +0000

[diff] [blame]

2674

*/

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

}

break;

case DW_OP_APPLE_scalar_cast:

if (stack.empty())

{

if (error_ptr)

error_ptr->SetErrorString("Expression stack needs at least 1 item for DW_OP_APPLE_scalar_cast.");

return false;

}

else

{

// Simple scalar cast

2688

if (!stack.back().ResolveValue(exe_ctx, ast_context).Cast((Scalar::Type)opcodes.GetU8(&offset)))

2689

{

2690

if (error_ptr)

2691

error_ptr->SetErrorString("Cast failed.");

return false;

}

}

break;

case DW_OP_APPLE_clang_cast:

if (stack.empty())

{

if (error_ptr)

error_ptr->SetErrorString("Expression stack needs at least 1 item for DW_OP_APPLE_clang_cast.");

return false;

}

else

{

void *clang_type = (void *)opcodes.GetMaxU64(&offset, sizeof(void*));

Greg Clayton

2010-11-13 03:52:47 +0000

[diff] [blame]

2708

stack.back().SetContext (Value::eContextTypeClangType, clang_type);

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

2709

}

2710

break;

2711

//----------------------------------------------------------------------

2712

// OPCODE: DW_OP_APPLE_constf

2713

// OPERANDS: 1 byte float length, followed by that many bytes containing

2714

// the constant float data.

2715

// DESCRIPTION: Push a float value onto the expression stack.

2716

//----------------------------------------------------------------------

2717

case DW_OP_APPLE_constf: // 0xF6 - 1 byte float size, followed by constant float data

2718

{

2719

uint8_t float_length = opcodes.GetU8(&offset);

2720

if (sizeof(float) == float_length)

2721

tmp.ResolveValue(exe_ctx, ast_context) = opcodes.GetFloat (&offset);

2722

else if (sizeof(double) == float_length)

2723

tmp.ResolveValue(exe_ctx, ast_context) = opcodes.GetDouble (&offset);

2724

else if (sizeof(long double) == float_length)

2725

tmp.ResolveValue(exe_ctx, ast_context) = opcodes.GetLongDouble (&offset);

2726

else

2727

{

2728

StreamString new_value;

2729

opcodes.Dump(&new_value, offset, eFormatBytes, 1, float_length, UINT32_MAX, DW_INVALID_ADDRESS, 0, 0);

2730

2731

if (error_ptr)

2732

error_ptr->SetErrorStringWithFormat ("DW_OP_APPLE_constf(<%u> %s) unsupported float size.\n", float_length, new_value.GetData());

2733

return false;

2734

}

2735

tmp.SetValueType(Value::eValueTypeScalar);

2736

tmp.ClearContext();

2737

stack.push_back(tmp);

2738

}

2739

break;

2740

//----------------------------------------------------------------------

2741

// OPCODE: DW_OP_APPLE_clear

2742

// OPERANDS: none

2743

// DESCRIPTION: Clears the expression stack.

2744

//----------------------------------------------------------------------

2745

case DW_OP_APPLE_clear:

stack.clear();

break;

//----------------------------------------------------------------------

2750

// OPCODE: DW_OP_APPLE_error

2751

// OPERANDS: none

2752

// DESCRIPTION: Pops a value off of the stack and pushed its value.

2753

// The top item on the stack must be a variable, expression variable.

2754

//----------------------------------------------------------------------

2755

case DW_OP_APPLE_error: // 0xFF - Stops expression evaluation and returns an error (no args)

2756

if (error_ptr)

2757

error_ptr->SetErrorString ("Generic error.");

return false;

}

}

if (stack.empty())

{

if (error_ptr)

error_ptr->SetErrorString ("Stack empty after evaluation.");

return false;

}

else if (log)

{

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

2770

size_t count = stack.size();

Sean Callanan

2010-06-23 00:47:48 +0000

[diff] [blame]

2771

log->Printf("Stack after operation has %d values:", count);

Chris Lattner

2010-06-08 16:52:24 +0000

[diff] [blame]

2772

for (size_t i=0; i<count; ++i)

2773

{

2774

StreamString new_value;

2775

new_value.Printf("[%zu]", i);

2776

stack[i].Dump(&new_value);

Sean Callanan

2010-06-23 00:47:48 +0000

[diff] [blame]

2777

log->Printf(" %s", new_value.GetData());

Chris Lattner