this is from the Technical Reference Manual for the ARM Cortex-A15 MPCore Processor:
The Virtualization Extensions are an extension to the ARMv7 architecture
profile that provides a set of hardware features that support virtualizing
the Non-secure state of an ARM VMSAv7 implementation. This supports system
use of a virtual machine monitor, known as the hypervisor, that is responsible
for switching Guest operating systems. The Virtualization Extensions require
implementation of the Security Extensions and the Large Physical Address
Extension (LPAE).
I get why the Virtualization Extensions might rely on the LPAE, but I don't get why it also relies on the Security Extension.
Anybody have a clue about this ?
Best,
V.
Related
ARM offers emulators for development at Fixed Virtual Platforms (FVPs). ARM also announced ARMv8.4-a, which provides hardware acceleration for cryptographic algorithms, including SHA2-512, SHA3, SM3 and SM4. I have some C++ code I want t port to the new instructions.
I need access to a FVP or machine with ARMv8.4-a. I don't believe there is any silicon in the field with ARMv8.4-a at the moment. I think that means FVPs are my only choice at the moment.
My question is, do the FVP's support ARMv8.4?
My question is, do the FVP's support ARMv8.4?
According to Barry Spotts of ARM FVP team:
Our ARM AEMv8 FVP is free and can be downloaded from
https://developer.arm.com/products/system-design/fixed-virtual-platforms
It does support ARM 8.4 extensions. Linaro build does support our AEMv8 FVP.
It looks like QEMU added ARMv8.4-a support in February 2018 so the instructions can be emulated.
I've successfully built CEF for x86, now I'm trying to cross-compile it for ARM. I've almost done it, but came across an issue with atomic operations support for the platform:
In file included from ../../cef/include/base/cef_atomic_ref_count.h:55:0,
from ../../cef/include/cef_base.h:35,
from ../../cef/include/cef_auth_callback.h:41,
from ../../cef/include/cef_request_handler.h:41,
from ../../cef/libcef_dll/ctocpp/allow_certificate_error_callback_ctocpp.h:21,
from ../../cef/libcef_dll/ctocpp/allow_certificate_error_callback_ctocpp.cc:13:
../../cef/include/base/cef_atomicops.h:187:2: error: #error "Atomic operations are not supported on your platform"
From what I see, by default it has support only for x86 and mac platforms. For me it seems quite strange that CEF requires some x86 features with lack of support for other platforms. Though I've used GYP_CROSSCOMPILE=1 and " target_arch=arm embedded=1" in GYP_DEFINES while generating ninja files.
So, is there any way to turn off use of atomic operations in CEF? Or any other way to overcome this problem?
Thanks in advance!
I've found answer. Something was broken in defines. If you define BUILDING_CEF_SHARED, it starts to use chromium atomics which support ARM platform.
And can we hope it will be supported in all future mobile devices on ARM architecture (including NVIDIA Tegra)?
Unlike certain other ISA author companies, ARM does not have a hard commitment to backward compatibility. Mobile devices, the primary market for ARM cores, are unique and heterogeneous to the point where having a stable ISA would not make much difference. ARM is also targeted at low-power applications, meaning it is desirable to exclude unwanted features and keep the instruction set small, using only what the target application can take advantage of. As a result, a given release of the ARM architecture is a union of ISA families that together define feature-rich a system with relatively few unwanted instruction families.
An (incomplete) argument for a changing instruction set across releases is that an ISA is no longer seen as the programmer abstraction, and a chip-specific compiler is tasked with presenting a stable language for the programmer. Of course, compilers are only so good at squeezing C into extravagant instructions, and architecture-specific directives (and hand-coded segments of assembly) are still common in efficiency-critical libraries.
While some of the ISA extensions we have seen crop up over the years that prove to be widely useful ISA features (NEON appearing to be one of them - 128-bit SIMD is handy!) persist more reliably than others, there does not appear to be a guarantee that any specific ISA extension is to become future-compatible.
In response to the original question, NEON is mandatory in all Cortex-A8 devices but optional in Cortex-A9. ARM's business model allows companies to license a Cortex-A9 core and omit non-mandatory extensions. Tegra 2 appears to exclude NEON (but makes up for it by offering a "SIMD"-ish coprocessor in form of the GPU).
In theory, NEON is optional in ARM processors implementing ARM v7 architecture (for example Cortex-A9 based SoCs). In practice, most modern SoCs indeed have NEON.
On the other hand, NEON is mandatory in ARM processors based on ARMv8 architecture (the processors with 64-bit support).
As I understand, on linux systems debugging is done via the ptrace sys-call.
I would like to know how would I write a debugger for a micro-controller (no-OS).
Let us for the sake of simplicity assume the case of a software debugger for a board like Arduino Due (ARM based).
What would I have to learn to accomplish such a project, assuming I have a fair idea on how debuggers work on Linux and Windows
How different would programming a debugger for a MCU system be? (I can't use sys-calls)
Is debugging achievable via USB or serial interface?
Which languages should I use? (C, C++, Arm assembly)
How can the armgcc compiler help me with my project (are there flag options such as -g etc?)
I plan to implement the debugger as a command line Linux utility.
Most modern processors, including the ARM on the Arduino Due have on-chip debug support accesses via a JTAG interface. The Cortex-M3 on-chip debug supports 8 hardware breakpoints and some other features - with code running in flash memory you cannot set software breakpoints.
The JTAG interface itself is rather simple, but you will need special hardware to support it from a PC. Depending of performance and features a JTAG debugger may vary in cost hugely from very low to serious money. Software to interface the JTAG to the debugger software is required. OpenOCD is an open source tool for interfacing JTAG/On-chip debug to GDB allowing GDB-ARM to be hosted on a PC to debug the remote ARM target.
You could in theory write your own software to to access the OCD via JTAG. I have never considered implementating a target hosted debugger on a microcontroller, although I have used VxWorks on ARM9, SrongARM and x86 and it has limited support for target hosted debugging. The utility of target hosted debug is limited by the lack of the source code and symbol table information that is available to a hosted debugger to support source-level debugging.
Even so, I believe that it is possible to access the on-chip debug from the target itself see ARM's documentation for details.
I have compiled a simple executable application written in C, using the arm-linux-gnueabi compiler for ARM.
How to run it on device?
Assuming that I have two devices for test it:
A Samsung phone with Windows Mobile 6.1, ARM926EJ OMAP1710 processor
A Foston tablet with Android 2.x, the processor name I not found but is one of processors in the ARM family.
If is not possible run it on the current operating system, then how to format the device and put my kernel instead of Android/Linux?
An application is typically built to run on top of an operating system. An operating system is typically built to run on top of hardware. Keep this in mind.
Running your application instead of Android/Linux implies that your application is a operating system of some sort. If you didn't write or include explicit code to control the hardware chips in the device, then you are only asking the wrong question, you should ask "I've wrtten an application in C, now how do I run it on my phone's operating system." If you did write or include explicit code to control the hardware chips in the device, then you did ask the right question (but some of the details seem off). This style of development happens a lot with the arduino/PIC/embedded ARM community.
Assuming you are not doing embedded development, the application must be compiled with some understanding of what the operating system offers (against the operating system's available api's) which generally makes them incompatible with other operating systems. This means the first step is to determine what operating system you are targeting, and obtain it's development suite. Once you have that, assuming that it supports C code (as most do), the suite will recompile your source code in a format that is both compatible with the CPU of the device and the API of the operating system on the device.
Small devices like phones typically run operating systems that have a tiny fraction of the features of a PC, so be prepared for fewer convenience features, and possibly "missing" libraries. That said, if you do get it to compile, typically you then hook the device up with the supported "bus" (USB is very popular), and save the program on the device (which sometimes involves sending "development / debugging" codes across the bus, and the development suite does this for you).
If everything worked well, you can then launch your program from the phone. If the program misbehaves and renders the phone inoperable, each development suite / phone has specific instructions on how to recover or reload a fresh operating system.
Here are resources for a few well known platforms (and percentages of the phones using them)
(worldwide according to Gartner's latest study, US according to Nielsen's latest study)
As referenced from wikipedia on 4/27/2012
(52%, 46.3%) Android Standard Development Kit
(16.9%, 1.4%) Symbian Standard Development Kit
(15%, 30%) iOS Phone Standard Development Kit
(11%, 14.9%) Blackberry Phone Standard Development Kit
(2.2%, 0%) Bada Standard Development Kit
(1.5%, 5.9%) Windows Phone Standard Development Kit
Note that these measurements are like most surveys, while they attempt to be random and unbiased, they are prone to measurement error and sampling error, so the numbers are more useful as relative indicators than absolute values.