Cannot Load V8 Interface Assembly. Load Failure Information For V8-x64.dll

[Adele Strecker]

Fromversion 6.2 of the pylon Software Suite, 32-bit Windows is no longer officially supported. To help users of previous pylon versions, this document still includes information about deployment on 32-bit systems.

pylon runtime redistributable package (also known as "runtime installer"): Deploy the necessary files and drivers using an installation program. This is the recommended option if you want to perform an unattended or silent installation of the pylon software. For more information, see Runtime Redistributable Package.

You can also use the pylon installer (Basler_pylon_x.x.x.xxxxx.exe) to deploy pylon software and drivers in a silent installation. The advantage of using the installer is that you can install CLI/GUI tools, SDK samples, and documentation at the same time.

You can choose whether to install support for all camera interfaces (GigE, USB 3.0, CXP 2.0, Camera Link) or whether to pick individual interfaces as required. If you want to install support only for selected camera interfaces, see "Configuring and Customizing the Installation".

To access information about the available switches, launch the runtime redistributable package (.exe file) from the command prompt with the /help or /? switch.

Copy deployment, also known as XCopy deployment, allows you to deploy the necessary files simply by copying them to the target computer. Because there is no automatic installation routine, you must provide and maintain your own installation routine to automate the process.

When using copy deployment, don't deploy the files to a target directory that is included in the Windows PATH environment variable and don't extend the PATH variable to include the target directory.

To deploy pylon using copy deployment, a set of .dll and .zip files must be copied to the target computer. The file names and the number of files vary depending on the camera interface(s) that you want your application to support (GigE Vision, USB 3.0 Vision, Camera Link, CoaXPress 2.0, or multiple interfaces).

The files required for each interface are shown in the following table. All files are available in 32-bit and 64-bit versions, with identical file names. If your application is available in both 32-bit and 64-bit versions, you must provide each file twice.

After the installation, you can find the files in the \Runtime\x64 and \Runtime\Win32 subdirectories of the pylon installation directory, unless otherwise noted. For details, see the "Notes" column in the following table.

To determine whether your application requires additional files that are not listed in the following table, you can run the Microsoft Dependency Walker tool (depends.exe), as described in Understanding the Dependencies of a Visual C++ Application.

These files must always be deployed together with the pylon DLLs. The files are available in 32-bit and 64-bit versions, with identical file names. If your application is available in both 32-bit and 64-bit versions, you must provide each file twice.

Manually copy the files listed in the table above to the same target directory as the pylon DLLs. You can use this deployment method to enable installation by users who don't have administrator rights, or for applications that can be run from a network share.

The .msi packages for each interface are shown in the following table. If you want your application to support multiple camera interfaces, execute the respective .msi files one after the other.

To deploy pylon via copy deployment, you must make sure your application's executable file(s) can find the required pylon DLLs on the target computer. Otherwise, your application won't start or issue an error message.

The easiest copy deployment method is to set up your installation routine to copy the required pylon DLLs to the same target directory as your application's executable files. This enables your application to find the pylon DLLs automatically.

If you copy the pylon DLLs and your application's DLLs to a common DLL directory and copy your application's executable files to a different directory. The pylon DLLs and your application's executable files must reside in the same directory.

If your application is available in 32-bit and 64-bit versions and if the 32-bit and 64-bit executable files are copied to the same target directory. You can't copy all files to the same directory as the depending 32-bit and 64-bit pylon DLLs share the same file names.

If you use this method, your application will not be launchable via Windows Command Prompt. For methods that allow launching the application via Command Prompt, see Method 3: Running the Application Using a Batch File, Method 4: Using SetDllDirectory in the Source Code, and Method 5: Creating and Embedding Assembly Manifests.

To use SetDllDirectory, the pylon DLLs must be "delay loaded". Otherwise, the application may search for the pylon DLLs too soon, i.e., before reaching the SetDllDirectory function call, and exit with an error message.

If delay loading is known to cause problems in your application, you should use assembly manifests instead of calling SetDllDirectory. Also, if your application already uses assembly manifests, editing the existing manifest files is generally an easier method. For more information, see Method 5: Creating and Embedding Assembly Manifests.

Replace dllDirectory32 and dllDirectory64 by relative paths to the pylon DLL target directories (see step 1). The paths must be relative to the directory containing the application's executable files. You can use the double-dots specifier to denote the parent directory of the current directory.

Example: These are the target directories (sample values):

The .manifest files contain references to the pylon DLLs. For each version of your application (32 bit or 64 bit), you must create a separate .manifest file. Each file must be copied to the corresponding directory containing the pylon DLLs.

Replace assemblyName64 by a unique identifier for the assembly, e.g., Grab64.Assembly.

If your application is available in both 32-bit and 64-versions, the identifier must be different from the identifier specified in step 2.

Replace dllPath by the relative paths to the directories containing the 32-bit and 64-bit pylon DLLs. Delimit each directory path with a semicolon. Each path must be relative to the directory containing the application's executable files. You can use the double-dots specifier to denote the parent directory of the current directory.

Example:

This website is being translated through machine translation by a third-party service. Basler does not warrant the accuracy, reliability or timeliness of any information translated by this system and will not accept liability for loss or damage incurred as a result. Content that has not yet been translated appears in English. Switch to English version

The LLVM code representation is designed to be used in three differentforms: as an in-memory compiler IR, as an on-disk bitcode representation(suitable for fast loading by a Just-In-Time compiler), and as a humanreadable assembly language representation. This allows LLVM to provide apowerful intermediate representation for efficient compilertransformations and analysis, while providing a natural means to debugand visualize the transformations. The three different forms of LLVM areall equivalent. This document describes the human readablerepresentation and notation.

because the definition of %x does not dominate all of its uses. TheLLVM infrastructure provides a verification pass that may be used toverify that an LLVM module is well formed. This pass is automaticallyrun by the parser after parsing input assembly and by the optimizerbefore it outputs bitcode. The violations pointed out by the verifierpass indicate bugs in transformation passes or input to the parser.

LLVM identifiers come in two basic types: global and local. Globalidentifiers (functions, global variables) begin with the '@'character. Local identifiers (register names, types) begin with the'%' character. Additionally, there are three different formats foridentifiers, for different purposes:

By default, unnamed temporaries are numbered sequentially (using aper-function incrementing counter, starting with 0). However, when explicitlyspecifying temporary numbers, it is allowed to skip over numbers.

Note that basic blocks and unnamed function parameters are included in thisnumbering. For example, if the entry basic block is not given a label nameand all function parameters are named, then it will get number 0.

Strings in LLVM programs are delimited by " characters. Within astring, all bytes are treated literally with the exception of \characters, which start escapes, and the first " character, whichends the string.

In general, a module is made up of a list of global values (where bothfunctions and global variables are global values). Global values arerepresented by a pointer to a memory location (in this case, a pointerto an array of char, and a pointer to a function), and have one of thefollowing linkage types.

Formally, use the following definition: when an odr function iscalled, one of the definitions is non-deterministically chosen to run. Forodr variables, if any byte in the value is not equal in allinitializers, that byte is a poison value. Foraliases and ifuncs, apply the rule for the underlying function or variable.

LLVM functions, calls andinvokes can all have an optional calling conventionspecified for the call. The calling convention of any pair of dynamiccaller/callee must match, or the behavior of the program is undefined.The following calling conventions are supported by LLVM, and more may beadded in the future:

This calling convention (the default if no other calling conventionis specified) matches the target C calling conventions. This callingconvention supports varargs function calls and tolerates somemismatch in the declared prototype and implemented declaration ofthe function (as does normal C).

3a8082e126