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

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

[diff] [blame]

583

s->PutCString("DW_OP_APPLE_address_of");

Chris Lattner

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

[diff] [blame]

584

break;

585

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]

586

s->PutCString("DW_OP_APPLE_value_of");

Chris Lattner

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

[diff] [blame]

587

break;

588

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]

589

s->PutCString("DW_OP_APPLE_deref_type");

Chris Lattner

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

[diff] [blame]

590

break;

591

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

Greg Clayton

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

[diff] [blame]

592

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

Chris Lattner

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

[diff] [blame]

593

break;

594

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

595

{

596

uint8_t float_length = m_data.GetU8(&offset);

Greg Clayton

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

[diff] [blame]

597

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

Chris Lattner

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

[diff] [blame]

598

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

599

s->PutChar(')');

600

// Consume the float data

601

m_data.GetData(&offset, float_length);

602

}

603

break;

604

case DW_OP_APPLE_scalar_cast:

Greg Clayton

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

[diff] [blame]

605

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]

606

break;

607

case DW_OP_APPLE_clang_cast:

608

{

609

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

Greg Clayton

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

[diff] [blame]

610

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

Chris Lattner

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

[diff] [blame]

611

}

612

break;

613

case DW_OP_APPLE_clear:

Greg Clayton

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

[diff] [blame]

614

s->PutCString("DW_OP_APPLE_clear");

Chris Lattner

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

[diff] [blame]

615

break;

616

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]

617

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]

624

DWARFExpression::SetLocationListSlide (addr_t slide)

Chris Lattner

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

[diff] [blame]

625

{

Greg Clayton

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

[diff] [blame]

626

m_loclist_slide = slide;

Chris Lattner

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

[diff] [blame]

}

int

DWARFExpression::GetRegisterKind ()

{

return m_reg_kind;

}

void

Greg Clayton

2011-09-02 01:15:17 +0000

[diff] [blame^]

636

DWARFExpression::SetRegisterKind (RegisterKind reg_kind)

Chris Lattner

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

[diff] [blame]

637

{

638

m_reg_kind = reg_kind;

}

bool

DWARFExpression::IsLocationList() const

643

{

Greg Clayton

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

[diff] [blame]

644

return m_loclist_slide != LLDB_INVALID_ADDRESS;

Chris Lattner

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

[diff] [blame]

645

}

646

647

void

Greg Clayton

2011-09-02 01:15:17 +0000

[diff] [blame^]

648

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

Chris Lattner

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

[diff] [blame]

649

{

650

if (IsLocationList())

651

{

652

// We have a location list

653

uint32_t offset = 0;

654

uint32_t count = 0;

Greg Clayton

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

[diff] [blame]

655

addr_t curr_base_addr = location_list_base_addr;

Chris Lattner

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

[diff] [blame]

656

while (m_data.ValidOffset(offset))

657

{

658

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

659

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

660

if (begin_addr_offset < end_addr_offset)

661

{

662

if (count > 0)

663

s->PutCString(", ");

Greg Clayton

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

[diff] [blame]

664

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

665

addr_range.Dump(s, 0, 8);

Chris Lattner

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

[diff] [blame]

666

s->PutChar('{');

667

uint32_t location_length = m_data.GetU16(&offset);

Greg Clayton

2011-09-02 01:15:17 +0000

[diff] [blame^]

668

DumpLocation (s, offset, location_length, level, abi);

Chris Lattner

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

[diff] [blame]

669

s->PutChar('}');

670

offset += location_length;

671

}

672

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

673

{

674

// 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]

679

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

680

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

Chris Lattner

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

[diff] [blame]

681

{

Greg Clayton

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

[diff] [blame]

682

curr_base_addr = end_addr_offset + location_list_base_addr;

Chris Lattner

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

[diff] [blame]

683

// We have a new base address

684

if (count > 0)

685

s->PutCString(", ");

686

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

}

}

count++;

}

}

else

{

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

Greg Clayton

2011-09-02 01:15:17 +0000

[diff] [blame^]

696

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

Chris Lattner

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

[diff] [blame]

}

}

static bool

ReadRegisterValueAsScalar

702

(

Greg Clayton

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

[diff] [blame]

703

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]

710

if (reg_ctx == NULL)

Chris Lattner

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

[diff] [blame]

711

{

Jason Molenda

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

[diff] [blame]

712

if (error_ptr)

713

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

Chris Lattner

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

[diff] [blame]

714

}

715

else

716

{

Greg Clayton

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

[diff] [blame]

717

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

Jason Molenda

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

[diff] [blame]

718

if (native_reg == LLDB_INVALID_REGNUM)

719

{

720

if (error_ptr)

721

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

722

}

723

else

724

{

Greg Clayton

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

[diff] [blame]

725

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

726

RegisterValue reg_value;

727

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

728

{

729

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

730

{

731

value.SetValueType (Value::eValueTypeScalar);

Greg Clayton

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

[diff] [blame]

732

value.SetContext (Value::eContextTypeRegisterInfo,

733

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]

740

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

741

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

Greg Clayton

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

[diff] [blame]

742

if (error_ptr)

Greg Clayton

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

[diff] [blame]

743

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

744

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]

750

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

Greg Clayton

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

[diff] [blame]

751

}

Jason Molenda

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

[diff] [blame]

752

}

Chris Lattner

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

[diff] [blame]

}

return false;

}

Greg Clayton

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

[diff] [blame]

757

//bool

758

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

759

//{

760

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

//}

//

//bool

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

765

//{

766

// if (load_addr == LLDB_INVALID_ADDRESS)

767

// return false;

768

//

769

// if (IsLocationList())

770

// {

771

// uint32_t offset = 0;

772

//

773

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

774

//

775

// if (loc_list_base_addr == LLDB_INVALID_ADDRESS)

776

// return false;

777

//

778

// while (m_data.ValidOffset(offset))

779

// {

780

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

781

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

782

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

783

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

// break;

// else

// {

// lo_pc += loc_list_base_addr;

788

// hi_pc += loc_list_base_addr;

789

//

790

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

791

// return true;

792

//

793

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

// }

// }

// }

// return false;

//}

Greg Clayton

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

[diff] [blame]

799

800

bool

Greg Clayton

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

[diff] [blame]

801

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

Greg Clayton

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

[diff] [blame]

802

{

Greg Clayton

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

[diff] [blame]

803

if (addr == LLDB_INVALID_ADDRESS)

Greg Clayton

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

[diff] [blame]

804

return false;

805

Chris Lattner

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

[diff] [blame]

806

if (IsLocationList())

807

{

808

uint32_t offset = 0;

Chris Lattner

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

[diff] [blame]

809

Greg Clayton

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

[diff] [blame]

810

if (loclist_base_addr == LLDB_INVALID_ADDRESS)

Chris Lattner

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

[diff] [blame]

811

return false;

812

813

while (m_data.ValidOffset(offset))

814

{

815

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

816

addr_t lo_pc = m_data.GetAddress(&offset);

817

addr_t hi_pc = m_data.GetAddress(&offset);

818

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

819

break;

820

else

821

{

Greg Clayton

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

[diff] [blame]

822

lo_pc += loclist_base_addr - m_loclist_slide;

823

hi_pc += loclist_base_addr - m_loclist_slide;

Chris Lattner

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

[diff] [blame]

824

Greg Clayton

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

[diff] [blame]

825

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

Chris Lattner

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

[diff] [blame]

826

return true;

827

828

offset += m_data.GetU16(&offset);

}

}

}

return false;

}

Greg Clayton

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

[diff] [blame]

834

Chris Lattner

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

[diff] [blame]

835

bool

Greg Clayton

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

[diff] [blame]

836

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

837

{

838

offset = 0;

839

if (!IsLocationList())

840

{

841

length = m_data.GetByteSize();

return true;

}

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

846

{

847

addr_t curr_base_addr = base_addr;

848

849

while (m_data.ValidOffset(offset))

850

{

851

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

852

addr_t lo_pc = m_data.GetAddress(&offset);

853

addr_t hi_pc = m_data.GetAddress(&offset);

854

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

{

break;

}

else

{

lo_pc += curr_base_addr - m_loclist_slide;

861

hi_pc += curr_base_addr - m_loclist_slide;

862

863

length = m_data.GetU16(&offset);

864

865

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,

879

lldb::DescriptionLevel level,

880

addr_t base_addr,

Greg Clayton

2011-09-02 01:15:17 +0000

[diff] [blame^]

881

addr_t address,

882

ABI *abi)

Greg Clayton

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

[diff] [blame]

{

uint32_t offset = 0;

uint32_t length = 0;

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

888

{

889

if (length > 0)

890

{

Greg Clayton

2011-09-02 01:15:17 +0000

[diff] [blame^]

891

DumpLocation(s, offset, length, level, abi);

Greg Clayton

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

[diff] [blame]

return true;

}

}

return false;

}

bool

Chris Lattner

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

[diff] [blame]

899

DWARFExpression::Evaluate

900

(

901

ExecutionContextScope *exe_scope,

902

clang::ASTContext *ast_context,

Greg Clayton

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

[diff] [blame]

903

ClangExpressionVariableList *expr_locals,

904

ClangExpressionDeclMap *decl_map,

Greg Clayton

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

[diff] [blame]

905

lldb::addr_t loclist_base_load_addr,

Chris Lattner

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

[diff] [blame]

906

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]

912

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

917

(

918

ExecutionContext *exe_ctx,

919

clang::ASTContext *ast_context,

Greg Clayton

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

[diff] [blame]

920

ClangExpressionVariableList *expr_locals,

921

ClangExpressionDeclMap *decl_map,

Jason Molenda

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

[diff] [blame]

922

RegisterContext *reg_ctx,

Greg Clayton

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

[diff] [blame]

923

lldb::addr_t loclist_base_load_addr,

Chris Lattner

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

[diff] [blame]

924

const Value* initial_value_ptr,

Value& result,

Error *error_ptr

) const

{

if (IsLocationList())

930

{

931

uint32_t offset = 0;

Jason Molenda

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

[diff] [blame]

932

addr_t pc;

933

if (reg_ctx)

934

pc = reg_ctx->GetPC();

935

else

936

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

Chris Lattner

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

[diff] [blame]

937

Greg Clayton

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

[diff] [blame]

938

if (loclist_base_load_addr != LLDB_INVALID_ADDRESS)

Chris Lattner

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

[diff] [blame]

939

{

Greg Clayton

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

[diff] [blame]

940

if (pc == LLDB_INVALID_ADDRESS)

Chris Lattner

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

[diff] [blame]

941

{

Greg Clayton

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

[diff] [blame]

942

if (error_ptr)

943

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

944

return false;

Chris Lattner

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

[diff] [blame]

945

}

Greg Clayton

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

[diff] [blame]

946

947

addr_t curr_loclist_base_load_addr = loclist_base_load_addr;

948

949

while (m_data.ValidOffset(offset))

Chris Lattner

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

[diff] [blame]

950

{

Greg Clayton

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

[diff] [blame]

951

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

952

addr_t lo_pc = m_data.GetAddress(&offset);

953

addr_t hi_pc = m_data.GetAddress(&offset);

954

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

Chris Lattner

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

[diff] [blame]

955

{

Greg Clayton

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

[diff] [blame]

956

break;

Chris Lattner

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

[diff] [blame]

957

}

Greg Clayton

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

[diff] [blame]

958

else

959

{

960

lo_pc += curr_loclist_base_load_addr - m_loclist_slide;

961

hi_pc += curr_loclist_base_load_addr - m_loclist_slide;

962

963

uint16_t length = m_data.GetU16(&offset);

964

965

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

966

{

Greg Clayton

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

[diff] [blame]

967

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]

968

}

969

offset += length;

970

}

Chris Lattner

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

[diff] [blame]

971

}

972

}

973

if (error_ptr)

Greg Clayton

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

[diff] [blame]

974

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]

979

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

986

(

987

ExecutionContext *exe_ctx,

988

clang::ASTContext *ast_context,

Chris Lattner

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

[diff] [blame]

989

ClangExpressionVariableList *expr_locals,

990

ClangExpressionDeclMap *decl_map,

Jason Molenda

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

[diff] [blame]

991

RegisterContext *reg_ctx,

Greg Clayton

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

[diff] [blame]

992

const DataExtractor& opcodes,

Chris Lattner

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

[diff] [blame]

993

const uint32_t opcodes_offset,

994

const uint32_t opcodes_length,

995

const uint32_t reg_kind,

996

const Value* initial_value_ptr,

Value& result,

Error *error_ptr

)

{

std::vector<Value> stack;

1002

Jason Molenda

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

[diff] [blame]

1003

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

Greg Clayton

08d7d3a

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

[diff] [blame]

1004

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

Jason Molenda

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

[diff] [blame]

1005

Chris Lattner

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

[diff] [blame]

1006

if (initial_value_ptr)

1007

stack.push_back(*initial_value_ptr);

1008

1009

uint32_t offset = opcodes_offset;

1010

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.

1015

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

1016

{

1017

if (error_ptr)

1018

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

1019

return false;

1020

}

Greg Clayton

e005f2c

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

[diff] [blame]

1021

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

Chris Lattner

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

[diff] [blame]

1022

1023

1024

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

1025

{

1026

const uint32_t op_offset = offset;

1027

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

1028

1029

if (log)

1030

{

Chris Lattner

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

[diff] [blame]

1031

size_t count = stack.size();

Sean Callanan

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

[diff] [blame]

1032

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

Chris Lattner

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

[diff] [blame]

1033

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

1034

{

1035

StreamString new_value;

1036

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

1037

stack[i].Dump(&new_value);

Sean Callanan

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

[diff] [blame]

1038

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

Chris Lattner

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

[diff] [blame]

1039

}

1040

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

}

switch (op)

{

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

1045

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

1046

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

1047

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

1048

case DW_OP_addr:

Greg Clayton

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

[diff] [blame]

1049

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

Chris Lattner

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

[diff] [blame]

1050

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

1051

break;

1052

1053

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

1054

// The DW_OP_addr_sect_offset4 is used for any location expressions in

1055

// shared libraries that have a location like:

1056

// DW_OP_addr(0x1000)

1057

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

1058

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

1059

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

1060

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

1061

// and a 4 byte offset.

1062

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

1063

// case DW_OP_addr_sect_offset4:

1064

// {

1065

// result_type = eResultTypeFileAddress;

1066

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

1067

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

1068

//

1069

// Address so_addr (sect, sect_offset);

1070

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

1071

// if (load_addr != LLDB_INVALID_ADDRESS)

1072

// {

1073

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

1074

// // address.

1075

// 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;

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

1089

// OPCODE: DW_OP_deref

1090

// OPERANDS: none

1091

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

1092

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

1093

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

1094

// address on the target machine.

1095

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

1096

case DW_OP_deref:

1097

{

1098

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

1099

switch (value_type)

1100

{

1101

case Value::eValueTypeHostAddress:

1102

{

1103

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

1104

intptr_t ptr;

1105

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

1106

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

1107

stack.back().ClearContext();

1108

}

1109

break;

1110

case Value::eValueTypeLoadAddress:

1111

if (exe_ctx)

1112

{

1113

if (exe_ctx->process)

1114

{

1115

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

1116

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

1117

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

1118

Error error;

1119

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

1120

{

1121

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

1122

uint32_t addr_data_offset = 0;

1123

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

1124

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;

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

1158

// OPCODE: DW_OP_deref_size

1159

// OPERANDS: 1

1160

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

1161

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

1162

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

1163

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

1164

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

1165

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

1166

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

1167

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

1168

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

1169

// on the expression stack.

1170

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

1171

case DW_OP_deref_size:

Jason Molenda

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

[diff] [blame]

1172

{

1173

uint8_t size = opcodes.GetU8(&offset);

1174

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

1175

switch (value_type)

1176

{

1177

case Value::eValueTypeHostAddress:

1178

{

1179

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

1180

intptr_t ptr;

1181

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

1182

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

1183

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

1184

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

1185

switch (size)

1186

{

1187

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

1188

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

1189

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

1190

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

Jason Molenda

a99bcaa

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

[diff] [blame]

1191

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

1192

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

1193

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

1194

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

1195

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

Jason Molenda

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

[diff] [blame]

1196

default: break;

1197

}

1198

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

1199

stack.back().ClearContext();

1200

}

1201

break;

1202

case Value::eValueTypeLoadAddress:

1203

if (exe_ctx)

1204

{

1205

if (exe_ctx->process)

1206

{

1207

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

1208

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

1209

Error error;

1210

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

1211

{

1212

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

1213

uint32_t addr_data_offset = 0;

1214

switch (size)

1215

{

1216

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

1217

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

1218

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

1219

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

1220

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

1221

}

1222

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]

1254

1255

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

1256

// OPCODE: DW_OP_xderef_size

1257

// OPERANDS: 1

1258

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

1259

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

1260

// 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]

1261

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

Chris Lattner

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

[diff] [blame]

1262

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

1263

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

1264

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

1265

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

1266

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

1267

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

1268

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

1269

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

1270

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

1271

// on the expression stack.

1272

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

1273

case DW_OP_xderef_size:

1274

if (error_ptr)

1275

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

1276

return false;

1277

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

1278

// OPCODE: DW_OP_xderef

1279

// OPERANDS: none

1280

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

1281

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

1282

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

1283

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

1284

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

1285

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

1286

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

1287

// on the target machine.

1288

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

1289

case DW_OP_xderef:

1290

if (error_ptr)

1291

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

1292

return false;

1293

1294

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

1295

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

1296

//

1297

// Opcode Operand 1

1298

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

1299

// DW_OP_const1u 1-byte unsigned integer constant

1300

// DW_OP_const1s 1-byte signed integer constant

1301

// DW_OP_const2u 2-byte unsigned integer constant

1302

// DW_OP_const2s 2-byte signed integer constant

1303

// DW_OP_const4u 4-byte unsigned integer constant

1304

// DW_OP_const4s 4-byte signed integer constant

1305

// DW_OP_const8u 8-byte unsigned integer constant

1306

// DW_OP_const8s 8-byte signed integer constant

1307

// DW_OP_constu unsigned LEB128 integer constant

1308

// DW_OP_consts signed LEB128 integer constant

1309

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

Greg Clayton

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

[diff] [blame]

1310

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

1311

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

1312

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

1313

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

1314

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

1315

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

1316

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

1317

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

1318

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

1319

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

Chris Lattner

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

[diff] [blame]

1320

1321

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

1322

// OPCODE: DW_OP_dup

1323

// OPERANDS: none

1324

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

1325

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

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());

1335

break;

1336

1337

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

1338

// OPCODE: DW_OP_drop

1339

// OPERANDS: none

1340

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

1341

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

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;

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

1354

// OPCODE: DW_OP_over

1355

// OPERANDS: none

1356

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

1357

// the top of the stack.

1358

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

1359

case DW_OP_over:

1360

if (stack.size() < 2)

1361

{

1362

if (error_ptr)

1363

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;

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

1372

// OPCODE: DW_OP_pick

1373

// OPERANDS: uint8_t index into the current stack

1374

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

1375

// inclusive) is pushed on the stack

1376

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

1377

case DW_OP_pick:

1378

{

1379

uint8_t pick_idx = opcodes.GetU8(&offset);

1380

if (pick_idx < stack.size())

1381

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;

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

1392

// OPCODE: DW_OP_swap

1393

// OPERANDS: none

1394

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

1395

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

1396

// becomes the top of the stack

1397

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

1398

case DW_OP_swap:

1399

if (stack.size() < 2)

1400

{

1401

if (error_ptr)

1402

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];

1409

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

}

break;

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

1414

// OPCODE: DW_OP_rot

1415

// OPERANDS: none

1416

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

1417

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

1418

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

1419

// the second entry.

1420

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

1421

case DW_OP_rot:

1422

if (stack.size() < 3)

1423

{

1424

if (error_ptr)

1425

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

return false;

}

else

{

size_t last_idx = stack.size() - 1;

1431

Value old_top = stack[last_idx];

1432

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

1433

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

1434

stack[last_idx - 2] = old_top;

}

break;

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

1439

// OPCODE: DW_OP_abs

1440

// OPERANDS: none

1441

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

1442

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

1443

// represented, the result is undefined.

1444

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

case DW_OP_abs:

if (stack.empty())

{

if (error_ptr)

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

1450

return false;

1451

}

1452

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

1453

{

1454

if (error_ptr)

1455

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

return false;

}

break;

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

1461

// OPCODE: DW_OP_and

1462

// OPERANDS: none

1463

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

1464

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

1465

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

1466

case DW_OP_and:

1467

if (stack.size() < 2)

1468

{

1469

if (error_ptr)

1470

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;

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

1482

// OPCODE: DW_OP_div

1483

// OPERANDS: none

1484

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

1485

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

1486

// pushes the result.

1487

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

1488

case DW_OP_div:

1489

if (stack.size() < 2)

1490

{

1491

if (error_ptr)

1492

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())

1499

{

1500

if (error_ptr)

1501

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);

1508

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

1509

{

1510

if (error_ptr)

1511

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

return false;

}

}

}

break;

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

1519

// OPCODE: DW_OP_minus

1520

// OPERANDS: none

1521

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

1522

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

1523

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

1524

case DW_OP_minus:

1525

if (stack.size() < 2)

1526

{

1527

if (error_ptr)

1528

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;

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

1540

// OPCODE: DW_OP_mod

1541

// OPERANDS: none

1542

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

1543

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

1544

// the stack.

1545

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

1546

case DW_OP_mod:

1547

if (stack.size() < 2)

1548

{

1549

if (error_ptr)

1550

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;

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

1563

// OPCODE: DW_OP_mul

1564

// OPERANDS: none

1565

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

1566

// together, and pushes the result.

1567

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

1568

case DW_OP_mul:

1569

if (stack.size() < 2)

1570

{

1571

if (error_ptr)

1572

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;

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

1584

// OPCODE: DW_OP_neg

1585

// OPERANDS: none

1586

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

1587

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

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)

1598

{

1599

if (error_ptr)

1600

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

return false;

}

}

break;

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

1607

// OPCODE: DW_OP_not

1608

// OPERANDS: none

1609

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

1610

// complement

1611

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

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)

1622

{

1623

if (error_ptr)

1624

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

return false;

}

}

break;

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

1631

// OPCODE: DW_OP_or

1632

// OPERANDS: none

1633

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

1634

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

1635

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

1636

case DW_OP_or:

1637

if (stack.size() < 2)

1638

{

1639

if (error_ptr)

1640

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;

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

1652

// OPCODE: DW_OP_plus

1653

// OPERANDS: none

1654

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

1655

// pushes the result.

1656

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

1657

case DW_OP_plus:

1658

if (stack.size() < 2)

1659

{

1660

if (error_ptr)

1661

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;

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

1673

// OPCODE: DW_OP_plus_uconst

1674

// OPERANDS: none

1675

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

1676

// constant operand and pushes the result.

1677

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

1678

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);

1688

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

1689

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

1690

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

1691

{

1692

if (error_ptr)

1693

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

return false;

}

}

break;

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

1700

// OPCODE: DW_OP_shl

1701

// OPERANDS: none

1702

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

1703

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

1704

// of the stack, and pushes the result.

1705

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

1706

case DW_OP_shl:

1707

if (stack.size() < 2)

1708

{

1709

if (error_ptr)

1710

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;

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

1722

// OPCODE: DW_OP_shr

1723

// OPERANDS: none

1724

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

1725

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

1726

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

1727

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

1728

case DW_OP_shr:

1729

if (stack.size() < 2)

1730

{

1731

if (error_ptr)

1732

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)

1740

{

1741

if (error_ptr)

1742

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

return false;

}

}

break;

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

1749

// OPCODE: DW_OP_shra

1750

// OPERANDS: none

1751

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

1752

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

1753

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

1754

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

1755

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

1756

case DW_OP_shra:

1757

if (stack.size() < 2)

1758

{

1759

if (error_ptr)

1760

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;

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

1772

// OPCODE: DW_OP_xor

1773

// OPERANDS: none

1774

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

1775

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

1776

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

1777

case DW_OP_xor:

1778

if (stack.size() < 2)

1779

{

1780

if (error_ptr)

1781

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;

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

1794

// OPCODE: DW_OP_skip

1795

// OPERANDS: int16_t

1796

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

1797

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

1798

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

1799

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

1800

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

1801

case DW_OP_skip:

1802

{

1803

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

1804

uint32_t new_offset = offset + skip_offset;

1805

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;

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

1817

// OPCODE: DW_OP_bra

1818

// OPERANDS: int16_t

1819

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

1820

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

1821

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

1822

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

1823

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

1824

// constant.

1825

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

case DW_OP_bra:

{

tmp = stack.back();

stack.pop_back();

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

1831

Scalar zero(0);

1832

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

1833

{

1834

uint32_t new_offset = offset + bra_offset;

1835

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;

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

1848

// OPCODE: DW_OP_eq

1849

// OPERANDS: none

1850

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

1851

// equals (==) operator.

1852

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

1853

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

1854

// operation is false.

1855

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

1856

case DW_OP_eq:

1857

if (stack.size() < 2)

1858

{

1859

if (error_ptr)

1860

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;

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

1872

// OPCODE: DW_OP_ge

1873

// OPERANDS: none

1874

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

1875

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

1876

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

1877

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

1878

// operation is false.

1879

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

1880

case DW_OP_ge:

1881

if (stack.size() < 2)

1882

{

1883

if (error_ptr)

1884

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;

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

1896

// OPCODE: DW_OP_gt

1897

// OPERANDS: none

1898

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

1899

// greater than (>) operator.

1900

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

1901

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

1902

// operation is false.

1903

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

1904

case DW_OP_gt:

1905

if (stack.size() < 2)

1906

{

1907

if (error_ptr)

1908

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;

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

1920

// OPCODE: DW_OP_le

1921

// OPERANDS: none

1922

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

1923

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

1924

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

1925

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

1926

// operation is false.

1927

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

1928

case DW_OP_le:

1929

if (stack.size() < 2)

1930

{

1931

if (error_ptr)

1932

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;

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

1944

// OPCODE: DW_OP_lt

1945

// OPERANDS: none

1946

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

1947

// less than (<) operator.

1948

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

1949

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

1950

// operation is false.

1951

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

1952

case DW_OP_lt:

1953

if (stack.size() < 2)

1954

{

1955

if (error_ptr)

1956

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;

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

1968

// OPCODE: DW_OP_ne

1969

// OPERANDS: none

1970

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

1971

// not equal (!=) operator.

1972

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

1973

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

1974

// operation is false.

1975

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

1976

case DW_OP_ne:

1977

if (stack.size() < 2)

1978

{

1979

if (error_ptr)

1980

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;

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

1992

// OPCODE: DW_OP_litn

1993

// OPERANDS: none

1994

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

1995

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

1996

// of the stack.

1997

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

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]

2030

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

Chris Lattner

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

[diff] [blame]

2031

break;

2032

2033

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

2034

// OPCODE: DW_OP_regN

2035

// OPERANDS: none

2036

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

2037

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

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;

2072

Jason Molenda

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

[diff] [blame]

2073

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

Chris Lattner

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

[diff] [blame]

2074

stack.push_back(tmp);

else

return false;

}

break;

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

2080

// OPCODE: DW_OP_regx

2081

// OPERANDS:

2082

// ULEB128 literal operand that encodes the register.

2083

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

2084

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

2085

case DW_OP_regx:

2086

{

2087

reg_num = opcodes.GetULEB128(&offset);

Jason Molenda

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

[diff] [blame]

2088

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

Chris Lattner

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

[diff] [blame]

2089

stack.push_back(tmp);

else

return false;

}

break;

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

2096

// OPCODE: DW_OP_bregN

2097

// OPERANDS:

2098

// SLEB128 offset from register N

2099

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

2100

// N plus an offset.

2101

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

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;

2136

Jason Molenda

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

[diff] [blame]

2137

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

Chris Lattner

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

[diff] [blame]

2138

{

2139

int64_t breg_offset = opcodes.GetSLEB128(&offset);

2140

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

2141

stack.push_back(tmp);

2142

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

}

else

return false;

}

break;

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

2149

// OPCODE: DW_OP_bregx

2150

// OPERANDS: 2

2151

// ULEB128 literal operand that encodes the register.

2152

// SLEB128 offset from register N

2153

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

2154

// N plus an offset.

2155

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

2156

case DW_OP_bregx:

2157

{

2158

reg_num = opcodes.GetULEB128(&offset);

2159

Jason Molenda

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

[diff] [blame]

2160

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

Chris Lattner

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

[diff] [blame]

2161

{

2162

int64_t breg_offset = opcodes.GetSLEB128(&offset);

2163

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

2164

stack.push_back(tmp);

2165

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

}

else

return false;

}

break;

case DW_OP_fbreg:

if (exe_ctx && exe_ctx->frame)

2174

{

2175

Scalar value;

2176

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

2177

{

2178

int64_t fbreg_offset = opcodes.GetSLEB128(&offset);

2179

value += fbreg_offset;

2180

stack.push_back(value);

2181

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;

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

2195

// OPCODE: DW_OP_nop

2196

// OPERANDS: none

2197

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

2198

// or any of its values.

2199

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

case DW_OP_nop:

break;

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

2204

// OPCODE: DW_OP_piece

2205

// OPERANDS: 1

2206

// ULEB128: byte size of the piece

2207

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

2208

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

2209

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

2210

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

2211

// register is defined by the ABI.

2212

//

2213

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

2214

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

2215

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

2216

// variable a particular DWARF expression refers to.

2217

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

2218

case DW_OP_piece:

2219

if (error_ptr)

2220

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

2221

return false;

2222

2223

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

2224

// OPCODE: DW_OP_push_object_address

2225

// OPERANDS: none

2226

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

2227

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

2228

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

2229

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

2230

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

2231

// during user expression evaluation.

2232

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

2233

case DW_OP_push_object_address:

2234

if (error_ptr)

2235

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

2236

return false;

2237

2238

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

2239

// OPCODE: DW_OP_call2

2240

// OPERANDS:

2241

// uint16_t compile unit relative offset of a DIE

2242

// DESCRIPTION: Performs subroutine calls during evaluation

2243

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

2244

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

2245

//

2246

// Operand interpretation is exactly like that for DW_FORM_ref2.

2247

//

2248

// This operation transfers control of DWARF expression evaluation

2249

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

2250

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

2251

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

2252

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

2253

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

2254

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

2255

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

2256

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

2257

// expressions.

2258

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

2259

case DW_OP_call2:

2260

if (error_ptr)

2261

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

2262

return false;

2263

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

2264

// OPCODE: DW_OP_call4

2265

// OPERANDS: 1

2266

// uint32_t compile unit relative offset of a DIE

2267

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

2268

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

2269

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

2270

//

2271

// Operand interpretation DW_OP_call4 is exactly like that for

2272

// DW_FORM_ref4.

2273

//

2274

// This operation transfers control of DWARF expression evaluation

2275

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

2276

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

2277

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

2278

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

2279

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

2280

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

2281

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

2282

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

2283

// expressions.

2284

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

2285

case DW_OP_call4:

2286

if (error_ptr)

2287

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

return false;

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

2292

// OPCODE: DW_OP_call_ref

2293

// OPERANDS:

2294

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

2295

// absolute DIE offset for 64 bit DWARF.

2296

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

2297

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

2298

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

2299

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

2300

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

2301

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

2302

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

2303

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

2304

// consumer.

2305

//

2306

// Operand interpretation of DW_OP_call_ref is exactly like that for

2307

// DW_FORM_ref_addr.

2308

//

2309

// This operation transfers control of DWARF expression evaluation

2310

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

2311

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

2312

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

2313

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

2314

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

2315

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

2316

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

2317

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

2318

// expressions.

2319

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

2320

case DW_OP_call_ref:

2321

if (error_ptr)

2322

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

2323

return false;

2324

2325

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

2326

// OPCODE: DW_OP_APPLE_array_ref

2327

// OPERANDS: none

2328

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

2329

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

2330

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

2331

// the array specified by the index.

2332

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

2333

case DW_OP_APPLE_array_ref:

2334

{

2335

if (stack.size() < 2)

2336

{

2337

if (error_ptr)

2338

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

return false;

}

Value index_val = stack.back();

2343

stack.pop_back();

2344

Value array_val = stack.back();

2345

stack.pop_back();

2346

2347

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

Greg Clayton

381f968

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

[diff] [blame]

2348

int64_t index = index_scalar.SLongLong(LLONG_MAX);

Chris Lattner

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

[diff] [blame]

2349

Greg Clayton

381f968

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

[diff] [blame]

2350

if (index == LLONG_MAX)

Chris Lattner

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

[diff] [blame]

2351

{

2352

if (error_ptr)

2353

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

return false;

}

Greg Clayton

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

[diff] [blame]

2357

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

Chris Lattner

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

[diff] [blame]

2358

{

2359

if (error_ptr)

2360

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

return false;

}

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

2365

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

2366

{

2367

if (error_ptr)

2368

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

return false;

}

Greg Clayton

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

[diff] [blame]

2372

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)) &&

2378

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

2379

{

2380

if (error_ptr)

2381

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

return false;

}

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

2386

{

2387

if (error_ptr)

2388

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]

2392

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

2393

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

Chris Lattner

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

[diff] [blame]

2394

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

2395

if (member_bit_incr % 8)

2396

{

2397

if (error_ptr)

2398

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

2399

return false;

2400

}

2401

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

Value member;

Greg Clayton

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

[diff] [blame]

2405

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

Chris Lattner

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

[diff] [blame]

2406

member.SetValueType(array_val.GetValueType());

2407

2408

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

2409

addr_t member_loc = array_base + member_offset;

2410

member.GetScalar() = (uint64_t)member_loc;

2411

2412

stack.push_back(member);

}

break;

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

2417

// OPCODE: DW_OP_APPLE_uninit

2418

// OPERANDS: none

2419

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

2420

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

2421

case DW_OP_APPLE_uninit:

2422

//return eResultTypeErrorUninitialized;

2423

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

2424

2425

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

2426

// OPCODE: DW_OP_APPLE_assign

2427

// OPERANDS: none

2428

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

2429

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

2430

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

2431

// expression local variable.

2432

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

2433

case DW_OP_APPLE_assign:

2434

if (stack.size() < 2)

2435

{

2436

if (error_ptr)

2437

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]

2445

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

Chris Lattner

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

[diff] [blame]

2446

switch (context_type)

2447

{

Greg Clayton

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

[diff] [blame]

2448

case Value::eContextTypeClangType:

Chris Lattner

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

[diff] [blame]

2449

{

Greg Clayton

462d414

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

[diff] [blame]

2450

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

Chris Lattner

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

[diff] [blame]

2451

2452

if (ClangASTContext::IsAggregateType (clang_type))

2453

{

2454

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

2455

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

2456

2457

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

2458

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

2459

Greg Clayton

960d6a4

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

[diff] [blame]

2460

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

Chris Lattner

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

[diff] [blame]

2461

2462

switch (source_value_type)

2463

{

Greg Clayton

4fdf760

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

[diff] [blame]

2464

case Value::eValueTypeScalar:

2465

case Value::eValueTypeFileAddress:

2466

break;

2467

Chris Lattner

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

[diff] [blame]

2468

case Value::eValueTypeLoadAddress:

2469

switch (target_value_type)

2470

{

2471

case Value::eValueTypeLoadAddress:

2472

{

2473

DataBufferHeap data;

2474

data.SetByteSize(byte_size);

2475

2476

Error error;

2477

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

2478

{

2479

if (error_ptr)

2480

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)

2485

{

2486

if (error_ptr)

2487

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]

2493

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

Chris Lattner

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

[diff] [blame]

2494

{

2495

if (error_ptr)

2496

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)

2503

{

2504

if (error_ptr)

2505

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:

2515

switch (target_value_type)

2516

{

2517

case Value::eValueTypeLoadAddress:

Greg Clayton

cd54803

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

[diff] [blame]

2518

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

Chris Lattner

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

[diff] [blame]

2519

{

2520

if (error_ptr)

2521

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)

2528

{

2529

if (error_ptr)

2530

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

return false;

}

}

case Value::eValueTypeHostAddress:

2535

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]

2544

if (!ClangASTType::SetValueFromScalar (ast_context,

2545

clang_type,

2546

tmp.ResolveValue(exe_ctx, ast_context),

2547

new_value))

Chris Lattner

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

[diff] [blame]

2548

{

2549

if (error_ptr)

2550

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:

2559

case Value::eValueTypeHostAddress:

2560

{

Greg Clayton

b344843

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

[diff] [blame]

2561

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

Chris Lattner

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

[diff] [blame]

2562

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

Greg Clayton

1674b12

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

[diff] [blame]

2563

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]

2569

{

2570

if (error_ptr)

2571

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;

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

2593

// OPCODE: DW_OP_APPLE_address_of

2594

// OPERANDS: none

2595

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

2596

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

2597

// location.

2598

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

2599

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

2613

if (error_ptr)

2614

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

2615

return false;

2616

2617

case Value::eValueTypeLoadAddress: // load address value

2618

case Value::eValueTypeFileAddress: // file address value

2619

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

2620

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

2621

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

2622

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

2623

stack.back().ClearContext();

break;

}

}

break;

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

2630

// OPCODE: DW_OP_APPLE_value_of

2631

// OPERANDS: none

2632

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

2633

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

2634

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

2635

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.");

2640

return false;

2641

}

2642

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

2643

{

2644

if (error_ptr)

2645

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

return false;

}

break;

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

2651

// OPCODE: DW_OP_APPLE_deref_type

2652

// OPERANDS: none

2653

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

2654

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

2655

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]

2667

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

Chris Lattner

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

[diff] [blame]

2668

{

2669

if (error_ptr)

2670

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]

2674

void *ptr_type = tmp.GetClangType();

Chris Lattner

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

[diff] [blame]

2675

void *target_type;

2676

2677

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

2678

{

2679

if (error_ptr)

2680

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

return false;

}

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

2685

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

2686

2687

tmp.ResolveValue(exe_ctx, ast_context);

2688

2689

tmp.SetValueType(value_type);

Greg Clayton

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

[diff] [blame]

2690

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

Chris Lattner

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

[diff] [blame]

2691

2692

stack.push_back(tmp);

}

break;

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

2697

// OPCODE: DW_OP_APPLE_expr_local

2698

// OPERANDS: ULEB128

2699

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

2700

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

2701

// an expression local variable index.

2702

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

2703

case DW_OP_APPLE_expr_local:

2704

{

Sean Callanan

a622343

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

[diff] [blame]

2705

/*

Chris Lattner

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

[diff] [blame]

2706

uint32_t idx = opcodes.GetULEB128(&offset);

2707

if (expr_locals == NULL)

2708

{

2709

if (error_ptr)

2710

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

2711

return false;

2712

}

2713

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

2714

if (expr_local_variable == NULL)

2715

{

2716

if (error_ptr)

2717

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

2718

return false;

2719

}

Greg Clayton

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

[diff] [blame]

2720

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

2721

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

2722

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

2723

// that must be manually freed please.

Chris Lattner

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

[diff] [blame]

2724

Value *proxy = expr_local_variable->CreateProxy();

2725

stack.push_back(*proxy);

2726

delete proxy;

Greg Clayton

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

[diff] [blame]

2727

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

Sean Callanan

a622343

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

[diff] [blame]

2728

*/

Chris Lattner

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

[diff] [blame]

}

break;

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

2733

// OPCODE: DW_OP_APPLE_extern

2734

// OPERANDS: ULEB128

2735

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

2736

// stack.

2737

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

2738

case DW_OP_APPLE_extern:

2739

{

Sean Callanan

8c12720

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

[diff] [blame]

2740

/*

Chris Lattner

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

[diff] [blame]

2741

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);

2746

return false;

2747

}

2748

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);

2753

return false;

2754

}

Greg Clayton

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

[diff] [blame]

2755

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

2756

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

2757

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

2758

// that must be manually freed please.

Chris Lattner

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

[diff] [blame]

2759

Value *proxy = extern_var->CreateProxy();

2760

stack.push_back(*proxy);

2761

delete proxy;

Sean Callanan

8c12720

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

[diff] [blame]

2762

*/

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

2776

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

2777

{

2778

if (error_ptr)

2779

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]

2796

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

Chris Lattner

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

[diff] [blame]

2797

}

2798

break;

2799

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

2800

// OPCODE: DW_OP_APPLE_constf

2801

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

2802

// the constant float data.

2803

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

2804

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

2805

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

2806

{

2807

uint8_t float_length = opcodes.GetU8(&offset);

2808

if (sizeof(float) == float_length)

2809

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

2810

else if (sizeof(double) == float_length)

2811

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

2812

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

2813

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

2814

else

2815

{

2816

StreamString new_value;

2817

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

2818

2819

if (error_ptr)

2820

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

2821

return false;

2822

}

2823

tmp.SetValueType(Value::eValueTypeScalar);

2824

tmp.ClearContext();

2825

stack.push_back(tmp);

2826

}

2827

break;

2828

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

2829

// OPCODE: DW_OP_APPLE_clear

2830

// OPERANDS: none

2831

// DESCRIPTION: Clears the expression stack.

2832

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

2833

case DW_OP_APPLE_clear:

stack.clear();

break;

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

2838

// OPCODE: DW_OP_APPLE_error

2839

// OPERANDS: none

2840

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

2841

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

2842

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

2843

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

2844

if (error_ptr)

2845

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]

2858

size_t count = stack.size();

Sean Callanan

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

[diff] [blame]

2859

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

Chris Lattner

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

[diff] [blame]

2860

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

2861

{

2862

StreamString new_value;

2863

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

2864

stack[i].Dump(&new_value);

Sean Callanan

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

[diff] [blame]

2865

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

Chris Lattner