internal error: entered unreachable code: The given type is not a basic type. (when looking at the operands of a call)

[Yoric]

Describe the Bug
I'm trying to use inkwell to inspect some LLVM IR.

To Reproduce

use std::path::Path;

use inkwell::{context::Context, memory_buffer::MemoryBuffer, values::InstructionOpcode};

fn main() {
     // Read the IR file into a memory buffer
    let memory_buffer = MemoryBuffer::create_from_file(Path::new("/tmp/test.ll")).unwrap();

    let context = Context::create();
    // Parse the IR into a module
    let module = context
        .create_module_from_ir(memory_buffer).unwrap();

    let main = module.get_function("main").unwrap();
    for bb in main.get_basic_blocks() {
        for instruction in bb.get_instructions() {
            eprintln!("Instruction: {:?}", instruction);
            if instruction.get_opcode() == InstructionOpcode::Call {
                eprintln!("Looking at {} operands", instruction.get_num_operands());
                for (i, operand) in instruction.get_operands().enumerate() {
                    eprintln!("Operand {i}: {:?}", operand);
                }
            }
        }
    }
}

I have applied this to the LLVM IR for the following file:

#include <fcntl.h>
#include <unistd.h>

int main() {
    int fd = open("/tmp/test.txt", O_RDONLY);
    if (fd >= 0) {
        char buffer[256];
        read(fd, buffer, sizeof(buffer));
        close(fd);
    }
    return 0;
}

(corresponding .ll)

In the first call, this panics with

internal error: entered unreachable code: The given type is not a basic type.

Expected Behavior
I expected to be able to look at all the operands of the call.

LLVM Version (please complete the following information):

• LLVM Version: [e.g. 6.0] llvm18-1
• Inkwell Branch Used: 0.7.1

Desktop (please complete the following information):

• OS: [e.g. Ubuntu 16.04, Windows 10] macOS 12.7.6.

[Yoric]

Looking at it more in depth, the error shows up at the following IR:

  call void @llvm.dbg.declare(metadata i32* %2, metadata !16, metadata !DIExpression()), !dbg !17

the panic is raised because the arguments are metadata, which cannot be converted into BasicValueEnum. If I skip llvm.dbg.*, other functions work nicely.

[TheDan64]

I think we have a MetadataBasicValueEnum which is probably want wherever it's failing

[Yoric]

Let me see if I can write a PR for this.

[Yoric]

PR opened.

[jlegare]

I believe I've stumbled across this same error in a different context. Rather than open a new bug, I thought it would make sense to add to this one. (Please let me know if this was an incorrect assumption on my behalf.)

The error is triggered by the following IR

declare i32 @may_throw()

define i32 @catchswitch_example() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
entry:
  invoke i32 @may_throw()
    to label %normal unwind label %catch.dispatch

normal:
  ret i32 0

catch.dispatch:
  %cs = catchswitch within none [label %catch.handler] unwind to caller

catch.handler:
  %cp = catchpad within %cs [i8* null, i32 64, i8* null]
  catchret from %cp to label %continue

continue:
  ret i32 1
}

declare i32 @__CxxFrameHandler3(...)

using essentially the same harness program as originally posted above, by @Yoric . I doctored the harness slightly to track down where the error was occurring, and it appears to be caused (in this case) by the catchswitch instruction, specifically its first argument. The value here is a ConstantTokenNone, which is not covered by BasicTypeEnum.