linux编译v8

Ⅰ linux驱动模块insmod时处理器类型错误

内核模块有版本识别，必须用目标内核版本的源代码编译才可以。

Ⅱ 在ubuntu里怎样运行编译好的谷歌v8

大名顶顶的Chrome V8引擎大家应该都知道了，我就不废话多说，不知道的可以去GOOGLE Code搜索。
不过不得不提的是Google Chrome V8引擎的开发者拉斯巴克（Lars Bak）。他是一个编程天才，却远离计算机世界的核心，在丹麦为Google工作，
这个工作地方是一个边远的农场，环境很优美。

在编译之前先看一下我的机器环境：
1.Linux yuchao-Latitude-E5410 2.6.35-22-generic #33-Ubuntu SMP Sun Sep 19 20:34:50 UTC 2010 i686 GNU/Linux
2.gcc (Ubuntu/Linaro 4.4.4-14ubuntu5) 4.4.5
3.GNU Make 3.81 这个程序创建为 i686-pc-linux-gnu
4.GNU ld (GNU Binutils for Ubuntu) 2.20.51-system.20100908
5.svn，版本 1.6.12 (r955767)
编译于 Mar 23 2011，12:56:23
6.Python 2.6.6
7.SCons by Steven Knight et al.:
script: v2.0.0.final.0.r5023, 2010/06/14 22:05:46, by scons on scons-dev
engine: v2.0.0.final.0.r5023, 2010/06/14 22:05:46, by scons on scons-dev
特别说明：SCons 是一个用 Python 语言编写的类似于 make 工具的程序。与 make 工具相比较，SCons 的配置文件更加简单清晰明了，
除此之外，它还有许多的优点。本文将简单介绍如何在软件开发项目中使用 SCons，通过本文，读者可以学习到如何使用 SCons 来建造自己的程序项目。

Ⅲ ARMv8 Linux内核错误处理过程分析怎么解决

1.1 Linux内核异常处理相关文件
Linux内核中，异常处理主要由两个文件完成，entry.S和traps.c，当然还有一些其它异常处理函数分布于fault.c, memory.c等等。entry.S包含异常的入口、进入异常处理C函数前的压栈、退出C函数前的出栈、一些fork函数相关的处理代码（暂不分析）、任务切换汇编处理过程（cpu_switch_to函数，暂不分析）。traps.c主要包含异常处理C函数。
本文主要分析entry.S，对于traps.c作简要介绍。
1.2 执行kernel_entry之前的栈

1.3 执行kernel_entry时的栈

1.4 执行kernel_exit 时的栈

1.5 entry.s代码分析
/*
* Low-level exception handling code
*
* Copyright (C) 2012 ARM Ltd.
* Authors: Catalin Marinas <[email protected]>
* Will Deacon <[email protected]>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/

#include <linux/init.h>
#include <linux/linkage.h>

#include <asm/assembler.h>
#include <asm/asm-offsets.h>
#include <asm/errno.h>
#include <asm/thread_info.h>
#include <asm/unistd.h>
#include <asm/unistd32.h>

/*
* Bad Abort numbers
*-----------------
*/
#define BAD_SYNC 0
#define BAD_IRQ 1
#define BAD_FIQ 2
#define BAD_ERROR 3

//根据该结构体内容
/*
struct pt_regs {
union {
struct user_pt_regs user_regs;//结构体user_pt_regs和结构体pt_regs内容一样
struct { //共用体存储31个通用寄存器,外加sp,pc,pstate三个特殊寄存器
//该结构体用于异常处理的压栈弹栈操作
u64 regs[31];
u64 sp;
u64 pc;
u64 pstate;
};
};
u64 orig_x0;
u64 syscallno;
};
*/

//S_FRAME_SIZE定义在asm-offsets.c中，DEFINE(S_FRAME_SIZE,sizeof(struct pt_regs));
//即结构体pt_regs的大小，结构体pt_regs的定义见上面
//S_LR定义：DEFINE(S_LR,offsetof(struct pt_regs, regs[30]));
//即31号寄存器在结构体pt_regs中的偏移量
//阅读以下内容请参考图1 和图2
.macro kernel_entry, el, regsize = 64
sub sp, sp, #S_FRAME_SIZE - S_LR // room for LR, SP, SPSR, ELR，见图2中sp'指向的位置
.if \regsize == 32
mov w0, w0 // zero upper 32 bits of x0
.endif
/*
*.macro push, xreg1, xreg2 //压栈两个寄存器
*stp \xreg1, \xreg2, [sp, #-16]! //注意！！！push指令也改变sp的值！！！
*.endm
*/
push x28, x29 //进行压栈操作，push也是一个宏定义，因为ARMv8没有push指令，用stp代替
push x26, x27
push x24, x25
push x22, x23
push x20, x21
push x18, x19
push x16, x17
push x14, x15
push x12, x13
push x10, x11
push x8, x9
push x6, x7
push x4, x5
push x2, x3
push x0, x1 //此时sp指向位置见图2中sp''
.if \el == 0 //如果异常级是el0，把el0的sp栈指针给x21寄存器
mrs x21, sp_el0
.else
add x21, sp, #S_FRAME_SIZE //如果异常级不是el0,把sp指针指向的地方加上pt_regs大小后的地址放入x21，
//即指向没进入kernel_entry函数钱的sp指向的位置，见图2中x21指向的地址
.endif
mrs x22, elr_el1 //把el1的lr寄存器给x22
mrs x23, spsr_el1 //把spsr给x23
stp lr, x21, [sp, #S_LR] //把lr，x21寄存器存入sp+S_LR指向的地方
stp x22, x23, [sp, #S_PC] //把lr，存入sp+s_PC指向的位置，用于异常返回

/*
* Set syscallno to -1 by default (overridden later if real syscall).
*/
.if \el == 0
mvn x21, xzr
str x21, [sp, #S_SYSCALLNO]
.endif
/*
* Registers that may be useful after this macro is invoked:
*
* x21 - aborted SP
* x22 - aborted PC
* x23 - aborted PSTATE
*/
.endm

.macro kernel_exit, el, ret = 0
//把此时sp（即图2中sp''）+S_PC位置处开始的16字节内容分别给x21,x22
//即把栈中存的x21和x22内容取出来
ldp x21, x22, [sp, #S_PC] // load ELR, SPSR
.if \el == 0
ldr x23, [sp, #S_SP] // load return stack pointer，取出
.endif
.if \ret
ldr x1, [sp, #S_X1] // preserve x0 (syscall return)，如果ret=1，则保存x0，用于系统调用，暂不分析
add sp, sp, S_X2
.else
pop x0, x1 //如果ret=0，弹出x0,x1
.endif
pop x2, x3 // load the rest of the registers
pop x4, x5
pop x6, x7
pop x8, x9
msr elr_el1, x21 // set up the return data，把前面弹出的x21,x22分别赋值给elr_el1,spsr_el1
msr spsr_el1, x22
.if \el == 0
msr sp_el0, x23
.endif
pop x10, x11
pop x12, x13
pop x14, x15
pop x16, x17
pop x18, x19
pop x20, x21
pop x22, x23
pop x24, x25
pop x26, x27
pop x28, x29
ldr lr, [sp], #S_FRAME_SIZE - S_LR // load LR and restore SP，把lr弹出
eret // return to kernel，异常返回，该指令会把lr给pc，完成跳转
.endm

.macro get_thread_info, rd
mov \rd, sp
and \rd, \rd, #~((1 << 13) - 1) // top of 8K stack
.endm

/*
* These are the registers used in the syscall handler, and allow us to
* have in theory up to 7 arguments to a function - x0 to x6.
*
* x7 is reserved for the system call number in 32-bit mode.
*/
sc_nr .req x25 // number of system calls
scno .req x26 // syscall number
stbl .req x27 // syscall table pointer
tsk .req x28 // current thread_info

/*
* Interrupt handling.
*/
.macro irq_handler
ldr x1, handle_arch_irq
mov x0, sp
blr x1
.endm

.text

/*
* Exception vectors.
*/
.macro ventry label //这里是2^7对齐，即对齐到内存地址的0x80
.align 7
b \label
.endm

.align 11

/* ENTRY也是一个宏，定义在include/linkage.h中
* #ifndef ENTRY
* #define ENTRY(name) \
* .globl name; \
* ALIGN; \
* name:
* #endif

Ⅳ ARMv8 Linux内核错误处理过程分析怎么解决

你是安装了什么自己开发的驱动吗？还是安装了第三方程序出现的? 从贴出的信息可以看出，建议根据内核oops定位错误，从之前的经验来看，很可能是使用了未定义的变量。

Ⅳ 安装了VMwareWorkstation.v8并安装了Red Hat Enterprise Linux 6，但是里面没有安装g++编译器，只有gcc

建议：
1. 打开终端，输入命令“ rpm -qa |grep c++”查看C++编译器是否存在，如果存在应该显示如下：
[root@localhost ~]# rpm -qa |grep c++
gcc-c++-4.1.2-46.el5
libstdc++-devel-4.1.2-46.el5
compat-libstdc++-33-3.2.3-61
compat-gcc-34-c++-3.4.6-4
compat-libstdc++-296-2.96-138
libstdc++-4.1.2-46.el5
2. 如果没有反馈，说明对应的RPM包没有安装；
3. 可以在系统光盘的“Server”文件夹下，找到对应的RPM安装包；
4. 将对应的RPM包拷贝到你的RHEL6中，安装方式如下：
4.1 在图形界面，直接双击安装即可，如果出现错误，检查是否一些相关联的软件包没有正确安装，按照提示信息，顺序安装即可；
4.2 在命令行界面，使用命令“rpm -ivh 对应的软件包全名.rpm"安装即可；
4.3 安装完成后使用命令“rpm -qa |grep c++”查询即可知道是否安装正确。
5. 如果你购买了Redhat的服务或者是在Redhat中注册过了的话，也可以使用Yum功能实现在线安装；
6. 其他可能的方法。

Ⅵ node.js安装后自带哪个工具

node.js安装后自带工具：已经在node的shell中了，直接输入js代码。

遇到问题就解决问题嘛，上StackOverflow一般都能找到先例的，如果是网络问题（npm默认仓库在墙外）导致的包无法安装，请采用cnpm，切换到国内的淘宝仓库。 如果是因为windows的问题导致一些模块无法正常编译，建议学习一下linux系统。

主要功能：

V8引擎本身使用了一些最新的编译技术。这使得用javascript这类脚本语言编写出来的代码运行速度获得了极大提升，又节省了开发成本。对性能的苛求是Node的一个关键因素。 Javascript是一个事件驱动语言，Node利用了这个优点，编写出可扩展性高的服务器。

Node采用了一个称为“事件循环(event loop）”的架构，使得编写可扩展性高的服务器变得既容易又安全。提高服务器性能的技巧有多种多样。Node选择了一种既能提高性能，又能减低开发复杂度的架构。这是一个非常重要的特性。并发编程通常很复杂且布满地雷。Node绕过了这些，但仍提供很好的性能。

Ⅶ ARMv8 Linux内核错误处理过程分析怎么解决

使用 crash 的先决条件 1. kernel 映像文件 vmlinux 在编译的时候必须指定了 -g 参数，即带有调试信息。 2. 需要有一个内存崩溃转储文件（例如 vmcore），或者可以通过 /dev/mem 或 /dev/crash 访问的实时系统内存。如果 crash 命令行没有指定转...

Ⅷ 操作系统内核为linuxarmv8i是什么意思

Android是基于Linux内核的操作系统。

提到Linux内核的时候，应该把它从概念上和“Linux操作系统”分割看来，内核只包括最基本的抽象，内存模型、进程调度、中断处理等等。而操作系统是一个更广的概念，不光包括内核，还包括了设备驱动、应用程序框架以及一些关键的能够让这个操作系统能为人所用的软件。所以Ubuntu, Fedora等等这些桌面发行版可以看做是包装了Linux内核的、不同的Linux操作系统。

Ⅸ android jni程序（c++）如何编译适用于arm-v8指令集的32位程序

可以看到Android上层的Application和ApplicationFramework都是使用编写，

底层包括系统和使用众多的LIiraries都是C/C++编写的。

所以上层Java要调用底层的C/C++函数库必须通过Java的JNI来实现。

下面将学习Android是如何通过Jni来实现Java对C/C++函数的调用。以HelloWorld程序为例：

第一步：

使用Java编写HelloWorld 的Android应用程序：

package com.lucyfyr;
import android.app.Activity;
import android.os.Bundle;
import android.util.Log;

public class HelloWorld extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
Log.v("fresne", printJNI("I am HelloWorld Activity"));
}
static
{
//加载库文件
System.loadLibrary("HelloWorldJni");
}
//声明原生函数 参数为String类型 返回类型为String
private native String printJNI(String inputStr);
}

这一步我们可以使用eclipse来生成一个App；

因为eclipse会自动为我们编译此Java文件，后面要是用到。

第二步：

生成共享库的头文件：

进入到eclipse生成的Android Project中 ：/HelloWorld/bin/classes/com/lucyfyr/
下：

可以看到里面后很多后缀为.class的文件，就是eclipse为我们自动编译好了的java文件，其中就有：

HelloWorld.class文件。

退回到classes一级目录：/HelloWorld/bin/classes/

执行如下命令：

javah com.lucyfyr.HelloWorld

生成文件:com_lucyfyr_HelloWorld.h

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class com_lucyfyr_HelloWorld */
#ifndef _Included_com_lucyfyr_HelloWorld
#define _Included_com_lucyfyr_HelloWorld
#ifdef __cplusplus
extern "C" {
#endif
/*
* Class: com_lucyfyr_HelloWorld
* Method: printJNI
* Signature: (Ljava/lang/String;)Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL Java_com_lucyfyr_HelloWorld_printJNI
(JNIEnv *, jobject, jstring);
#ifdef __cplusplus
}
#endif
#endif

可以看到自动生成对应的函数：Java_com_lucyfyr_HelloWorld_printJNI

Java_ + 包名（com.lucyfyr） + 类名(HelloWorld) + 接口名(printJNI)：必须要按此JNI规范来操作；

java虚拟机就可以在com.simon.HelloWorld类调用printJNI接口的时候自动找到这个C实现的Native函数调用。

当然函数名太长，可以在.c文件中通过函数名映射表来实现简化。

第三步：

实现JNI原生函数源文件：

新建com_lucyfyr_HelloWorld.c文件：

#include <jni.h>
#define LOG_TAG "HelloWorld"
#include <utils/Log.h>
/* Native interface, it will be call in java code */
JNIEXPORT jstring JNICALL Java_com_lucyfyr_HelloWorld_printJNI(JNIEnv *env, jobject obj,jstring inputStr)
{
LOGI("fresne Hello World From libhelloworld.so!");
// 从 instring 字符串取得指向字符串 UTF 编码的指针
const char *str =
(const char *)(*env)->GetStringUTFChars( env,inputStr, JNI_FALSE );
LOGI("fresne--->%s",(const char *)str);
// 通知虚拟机本地代码不再需要通过 str 访问 Java 字符串。
(*env)->ReleaseStringUTFChars(env, inputStr, (const char *)str );
return (*env)->NewStringUTF(env, "Hello World! I am Native interface");
}
/* This function will be call when the library first be load.
* You can do some init in the libray. return which version jni it support.
*/
jint JNI_OnLoad(JavaVM* vm, void* reserved)
{
void *venv;
LOGI("fresne----->JNI_OnLoad!");
if ((*vm)->GetEnv(vm, (void**)&venv, JNI_VERSION_1_4) != JNI_OK) {
LOGE("fresne--->ERROR: GetEnv failed");
return -1;
}
return JNI_VERSION_1_4;
}

OnLoadJava_com_lucyfyr_HelloWorld_printJNI

函数里面做一些log输出 注意JNI中的log输出的不同。

JNI_OnLoad函数JNI规范定义的，当共享库第一次被加载的时候会被回调，

这个函数里面可以进行一些初始化工作，比如注册函数映射表，缓存一些变量等，

最后返回当前环境所支持的JNI环境。本例只是简单的返回当前JNI环境。

http://www.cnblogs.com/bastard/archive/2012/05/19/2508913.html

Ⅹ 如何使用QEMU来模拟ARMv8开发平台

使用Qemu模拟Cortex-A9运行U-boot和Linux 作者来源于网络
我的开发环境： Ubuntu-12.04 所有软件包为最新

1. 安装GNU工具链

sudo apt-get insatll gcc-arm-linux-gnueabi

sudo apt-get insatll g++-arm-linux-gnueabi
安装完成后会在 /usr/arm-linux-gnueabi/ 目录下生成库文件、头文件等。 我安装的GCC版本为：
arm-linux-gnueabi-gcc (Ubuntu/Linaro 4.6.3-1ubuntu5) 4.6.3

Copyright (C) 2011 Free Software Foundation, Inc.

2. 安装Qemu模拟器
sudo apt-get install qemu qemu-system qemu-utils

这时应该已经可以运行qemu-system-arm命令了, 其版本为：
qemu-system-arm --version

QEMU emulator version 1.0.50 (Debian 1.0.50-2012.03-0ubuntu2), Copyright (c) 2003-2008 Fabrice Bellard

3. 编译和运行U-boot：
到 ftp://ftp.denx.de/pub/u-boot/ 下载最新版本的U-Boot源代码， 我用的目前最新版本 u-boot-2012.04.tar.bz2
解压后进入源代码目录，在Makefile里面增加两行：