Class文件格式实战：使用ASM动态生成class文件

最新推荐文章于 2024-06-28 00:08:37 发布
最新推荐文章于 2024-06-28 00:08:37 发布
阅读量1.9w 收藏 32
点赞数 17
分类专栏： Java 深入理解Java语言 文章标签： class class文件格式 ASM 动态生成字节码 动态生成class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zhangjg_blog/article/details/22976929
版权


概述

本专栏前面的文章，主要详细讲解了Class文件的格式，并且在上一篇文章中做了总结。 众所周知， JVM在运行时， 加载并执行class文件， 这个class文件基本上都是由我们所写的java源文件通过javac编译而得到的。 但是， 我们有时候会遇到这种情况：在前期（编写程序时）不知道要写什么类， 只有到运行时， 才能根据当时的程序执行状态知道要使用什么类。 举一个常见的例子就是JDK中的动态代理。这个代理能够使用一套API代理所有的符合要求的类， 那么这个代理就不可能在JDK编写的时候写出来， 因为当时还不知道用户要代理什么类。 


当遇到上述情况时， 就要考虑这种机制：在运行时动态生成class文件。 也就是说， 这个class文件已经不是由你的Java源码编译而来，而是由程序动态生成。 能够做这件事的，有JDK中的动态代理API， 还有一个叫做cglib的开源库。 这两个库都是偏重于动态代理的， 也就是以动态生成class的方式来支持代理的动态创建。 除此之外， 还有一个叫做ASM的库， 能够直接生成class文件，它的api对于动态代理的API来说更加原生， 每个api都和class文件格式中的特定部分相吻合， 也就是说， 如果对class文件的格式比较熟练， 使用这套API就会相对简单。 下面我们通过一个实例来讲解ASM的使用， 并且在使用的过程中， 会对应class文件中的各个部分来说明。


ASM示例：HelloWorld

ASM的实现基于一套Java API， 所以我们首先得到ASM库， 在这个我使用的是ASM 4.0的jar包 。 


首先以ASM中的HelloWorld实例来讲解， 比如我们要生成以下代码对应的class文件：

public class Example {

	public static void main (String[] args) {
		System.out.println("Hello world!");
}

但是这个class文件不能在开发时通过上面的源码来编译成， 而是要动态生成。 下面我们介绍如何使用ASM动态生成上述源码对应的字节码。


下面是代码示例（该实例来自于ASM官方的sample）：

import java.io.FileOutputStream;

import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;

public class Helloworld extends ClassLoader implements Opcodes {

    public static void main(final String args[]) throws Exception {


        //定义一个叫做Example的类
        ClassWriter cw = new ClassWriter(0);
        cw.visit(V1_1, ACC_PUBLIC, "Example", null, "java/lang/Object", null);

        //生成默认的构造方法
        MethodVisitor mw = cw.visitMethod(ACC_PUBLIC,
                "<init>",
                "()V",
                null,
                null);

        //生成构造方法的字节码指令
        mw.visitVarInsn(ALOAD, 0);
        mw.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V");
        mw.visitInsn(RETURN);
        mw.visitMaxs(1, 1);
        mw.visitEnd();

        //生成main方法
        mw = cw.visitMethod(ACC_PUBLIC + ACC_STATIC,
                "main",
                "([Ljava/lang/String;)V",
                null,
                null);

        //生成main方法中的字节码指令
        mw.visitFieldInsn(GETSTATIC,
                "java/lang/System",
                "out",
                "Ljava/io/PrintStream;");

        mw.visitLdcInsn("Hello world!");
        mw.visitMethodInsn(INVOKEVIRTUAL,
                "java/io/PrintStream",
                "println",
                "(Ljava/lang/String;)V");
        mw.visitInsn(RETURN);
        mw.visitMaxs(2, 2);

        //字节码生成完成
        mw.visitEnd();

        // 获取生成的class文件对应的二进制流
        byte[] code = cw.toByteArray();


        //将二进制流写到本地磁盘上
        FileOutputStream fos = new FileOutputStream("Example.class");
        fos.write(code);
        fos.close();

        //直接将二进制流加载到内存中
        Helloworld loader = new Helloworld();
        Class<?> exampleClass = loader.defineClass("Example", code, 0, code.length);

        //通过反射调用main方法
        exampleClass.getMethods()[0].invoke(null, new Object[] { null });

        
    }
}

下面详细介绍生成class的过程：


1 首先定义一个类
相关代码片段如下： 

        //定义一个叫做Example的类
        ClassWriter cw = new ClassWriter(0);
        cw.visit(V1_1, ACC_PUBLIC, "Example", null, "java/lang/Object", null);

ClassWriter类是ASM中的核心API ， 用于生成一个类的字节码。 ClassWriter的visit方法定义一个类。 

第一个参数V1_1是生成的class的版本号， 对应class文件中的主版本号和次版本号， 即minor_version和major_version 。 

第二个参数ACC_PUBLIC表示该类的访问标识。这是一个public的类。 对应class文件中的access_flags 。

第三个参数是生成的类的类名。 需要注意，这里是类的全限定名。 如果生成的class带有包名， 如com.jg.zhang.Example， 那么这里传入的参数必须是com/jg/zhang/Example  。对应class文件中的this_class  。

第四个参数是和泛型相关的， 这里我们不关新， 传入null表示这不是一个泛型类。这个参数对应class文件中的Signature属性（attribute） 。
 
第五个参数是当前类的父类的全限定名。 该类直接继承Object。 这个参数对应class文件中的super_class 。 

第六个参数是String[]类型的， 传入当前要生成的类的直接实现的接口。 这里这个类没实现任何接口， 所以传入null 。 这个参数对应class文件中的interfaces 。 


2 定义默认构造方法， 并生成默认构造方法的字节码指令 
相关代码片段如下： 
        //生成默认的构造方法
        MethodVisitor mw = cw.visitMethod(ACC_PUBLIC,
                "<init>",
                "()V",
                null,
                null);

        //生成构造方法的字节码指令
        mw.visitVarInsn(ALOAD, 0);
        mw.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V");
        mw.visitInsn(RETURN);
        mw.visitMaxs(1, 1);
        mw.visitEnd();


使用上面创建的ClassWriter对象， 调用该对象的visitMethod方法， 得到一个MethodVisitor对象， 这个对象定义一个方法。 对应class文件中的一个method_info 。 


第一个参数是 ACC_PUBLIC ， 指定要生成的方法的访问标志。 这个参数对应method_info 中的access_flags 。 

第二个参数是方法的方法名。 对于构造方法来说， 方法名为<init> 。 这个参数对应method_info 中的name_index ， name_index引用常量池中的方法名字符串。 

第三个参数是方法描述符， 在这里要生成的构造方法无参数， 无返回值， 所以方法描述符为 ()V  。 这个参数对应method_info 中的descriptor_index 。 

第四个参数是和泛型相关的， 这里传入null表示该方法不是泛型方法。这个参数对应method_info 中的Signature属性。

第五个参数指定方法声明可能抛出的异常。 这里无异常声明抛出， 传入null 。 这个参数对应method_info 中的Exceptions属性。

接下来调用MethodVisitor中的多个方法， 生成当前构造方法的字节码。 对应method_info 中的Code属性。

1 调用visitVarInsn方法，生成aload指令， 将第0个本地变量（也就是this）压入操作数栈。

2 调用visitMethodInsn方法， 生成invokespecial指令， 调用父类（也就是Object）的构造方法。

3 调用visitInsn方法，生成return指令， 方法返回。 

4 调用visitMaxs方法， 指定当前要生成的方法的最大局部变量和最大操作数栈。 对应Code属性中的max_stack和max_locals 。 

5 最后调用visitEnd方法， 表示当前要生成的构造方法已经创建完成。 


3 定义main方法， 并生成main方法中的字节码指令
对应的代码片段如下： 
        mw = cw.visitMethod(ACC_PUBLIC + ACC_STATIC,
                "main",
                "([Ljava/lang/String;)V",
                null,
                null);

        //生成main方法中的字节码指令
        mw.visitFieldInsn(GETSTATIC,
                "java/lang/System",
                "out",
                "Ljava/io/PrintStream;");

        mw.visitLdcInsn("Hello world!");
        mw.visitMethodInsn(INVOKEVIRTUAL,
                "java/io/PrintStream",
                "println",
                "(Ljava/lang/String;)V");
        mw.visitInsn(RETURN);
        mw.visitMaxs(2, 2);
        mw.visitEnd();

这个过程和上面的生成默认构造方法的过程是一致的。 读者可对比上一步执行分析。


4 生成class数据， 保存到磁盘中， 加载class数据
对应代码片段如下： 
        // 获取生成的class文件对应的二进制流
        byte[] code = cw.toByteArray();


        //将二进制流写到本地磁盘上
        FileOutputStream fos = new FileOutputStream("Example.class");
        fos.write(code);
        fos.close();

        //直接将二进制流加载到内存中
        Helloworld loader = new Helloworld();
        Class<?> exampleClass = loader.defineClass("Example", code, 0, code.length);

        //通过反射调用main方法
        exampleClass.getMethods()[0].invoke(null, new Object[] { null });

这段代码首先获取生成的class文件的字节流， 把它写在本地磁盘的Example.class文件中。 然后加载class字节流， 并通过反射调用main方法。

这段代码执行完， 可以看到控制台有以下输出： 
Hello world!

然后在当前测试工程的根目录下， 生成一个Example.class文件文件。



下面我们使用javap反编译这个class文件： 
javap -c -v -classpath . -private Example

输出的完整信息如下： 
Classfile /C:/Users/纪刚/Desktop/生成字节码/AsmJavaTest/Example.class
  Last modified 2014-4-5; size 338 bytes
  MD5 checksum 281abde0e2012db8ad462279a1fbb6a4
public class Example
  minor version: 3
  major version: 45
  flags: ACC_PUBLIC
Constant pool:
   #1 = Utf8               Example
   #2 = Class              #1             //  Example
   #3 = Utf8               java/lang/Object
   #4 = Class              #3             //  java/lang/Object
   #5 = Utf8               <init>
   #6 = Utf8               ()V
   #7 = NameAndType        #5:#6          //  "<init>":()V
   #8 = Methodref          #4.#7          //  java/lang/Object."<init>":()V
   #9 = Utf8               main
  #10 = Utf8               ([Ljava/lang/String;)V
  #11 = Utf8               java/lang/System
  #12 = Class              #11            //  java/lang/System
  #13 = Utf8               out
  #14 = Utf8               Ljava/io/PrintStream;
  #15 = NameAndType        #13:#14        //  out:Ljava/io/PrintStream;
  #16 = Fieldref           #12.#15        //  java/lang/System.out:Ljava/io/PrintStream;
  #17 = Utf8               Hello world!
  #18 = String             #17            //  Hello world!
  #19 = Utf8               java/io/PrintStream
  #20 = Class              #19            //  java/io/PrintStream
  #21 = Utf8               println
  #22 = Utf8               (Ljava/lang/String;)V
  #23 = NameAndType        #21:#22        //  println:(Ljava/lang/String;)V
  #24 = Methodref          #20.#23        //  java/io/PrintStream.println:(Ljava/lang/String;)V
  #25 = Utf8               Code
{
  public Example();
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #8                  // Method java/lang/Object."<init>":()V
         4: return

  public static void main(java.lang.String[]);
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=2, args_size=1
         0: getstatic     #16                 // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #18                 // String Hello world!
         5: invokevirtual #24                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
}

正是一个标准的class格式的文件， 它和以下源码是对应的： 

public class Example {

	public static void main (String[] args) {
		System.out.println("Hello world!");
}

只是， 上面的class文件不是由这段源代码生成的， 而是使用ASM动态创建的。 



ASM示例二： 生成字段， 并给字段加注解
上面的HelloWorld示例演示了如何生成类和方法， 该示例演示如何生成字段， 并给字段加注解。  

public class BeanTest extends ClassLoader implements Opcodes {

	/*
	 * 生成以下类的字节码
	 * 
	 * public class Person {
	 * 
	 * 		@NotNull
	 * 		public String name；
	 * 
	 * }
	 */

	public static void main(String[] args) throws Exception {
		
		/********************************class***********************************************/

		// 创建一个ClassWriter, 以生成一个新的类

		ClassWriter cw = new ClassWriter(0);
		cw.visit(V1_6, ACC_PUBLIC, "com/pansoft/espdb/bean/Person", null, "java/lang/Object", null);
		
		
		
		/*********************************constructor**********************************************/
		
		MethodVisitor mw = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null,
				null);
		mw.visitVarInsn(ALOAD, 0);
		mw.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V");
		mw.visitInsn(RETURN);
		mw.visitMaxs(1, 1);
		mw.visitEnd();
		
		
		/*************************************field******************************************/
	
		//生成String name字段
		FieldVisitor  fv = cw.visitField(ACC_PUBLIC, "name", "Ljava/lang/String;", null, null);
		AnnotationVisitor  av = fv.visitAnnotation("LNotNull;", true);
		av.visit("value", "abc");
		av.visitEnd();
		fv.visitEnd();

		
		
		/***********************************generate and load********************************************/
		
		byte[] code = cw.toByteArray();
		
		BeanTest loader = new BeanTest();
		Class<?> clazz = loader.defineClass(null, code, 0, code.length);
		
		
		/***********************************test********************************************/
		
		Object beanObj = clazz.getConstructor().newInstance();
		
		clazz.getField("name").set(beanObj, "zhangjg");
		
		String nameString = (String) clazz.getField("name").get(beanObj);
		System.out.println("filed value : " + nameString);
		
		String annoVal = clazz.getField("name").getAnnotation(NotNull.class).value();
		System.out.println("annotation value: " + annoVal);
		
	}
}

上面代码是完整的代码， 用于生成一个和以下代码相对应的class： 
    public class Person {
    
         @NotNull
         public String name；
    
    }

生成类和构造方法的部分就略过了， 和上面的示例是一样的。 下面看看字段和字段的注解是如何生成的。 相关逻辑如下： 

		FieldVisitor  fv = cw.visitField(ACC_PUBLIC, "name", "Ljava/lang/String;", null, null);
		AnnotationVisitor  av = fv.visitAnnotation("LNotNull;", true);
		av.visit("value", "abc");
		av.visitEnd();
		fv.visitEnd();

ClassWriter的visitField方法， 用于定义一个字段。 对应class文件中的一个filed_info 。 

第一个参数是字段的访问修饰符， 这里传入ACC_PUBLIC表示是一个public的属性。 这个参数和filed_info 中的access_flags相对应。

第二个参数是字段的字段名。 这个参数和filed_info 中的name_index相对应。

第三个参数是字段的描述符， 这个字段是String类型的，它的字段描述符为 "Ljava/lang/String;" 。 这个参数和filed_info 中的descriptor_index相对应。

第四个参数和泛型相关的， 这里传入null， 表示该字段不是泛型的。 这个参数和filed_info 中的Signature属性相对应。

第五个参数是字段的值， 只适用于静态字段，当前要生成的字段不是静态的， 所以传入null 。 这个参数和filed_info 中的ConstantValue属性相对应。

使用visitField方法定义完当前字段， 返回一个FieldVisitor对象。 下面调用这个对象的visitAnnotation方法， 为该字段生成注解信息。 visitAnnotation的两个参数如下：

第一个参数是要生成的注解的描述符， 传入"LNotNull;" 。

第二个参数表示该注解是否运行时可见。 如果传入true， 表示运行时可见， 这个注解信息就会生成filed_info 中的一个RuntimeVisibleAnnotation属性。 传入false， 表示运行时不可见，个注解信息就会生成filed_info 中的一个RuntimeInvisibleAnnotation属性 。 

接下来调用上一步返回的AnnotationVisitor对象的visit方法， 来生成注解的值信息。 



ClassWriter的其他重要方法
ClassWriter中还有其他一些重要方法， 这些方法能够生成class文件中的所有相关信息。 这些方法， 以及对象生成class文件中的什么信息， 都列在下面： 

    //定义一个类
    public void visit(
        int version,
        int access,
        String name,
        String signature,
        String superName,
        String[] interfaces)


    //定义源文件相关的信息，对应class文件中的Source属性
    public void visitSource(String source, String debug)

    //以下两个方法定义内部类和外部类相关的信息， 对应class文件中的InnerClasses属性
    public void visitOuterClass(String owner, String name, String desc) 

    public void visitInnerClass(
        String name,
        String outerName,
        String innerName,
        int access)


    //定义class文件中的注解信息， 对应class文件中的RuntimeVisibleAnnotations属性或者RuntimeInvisibleAnnotations属性
    public AnnotationVisitor visitAnnotation(String desc, boolean visible)

    //定义其他非标准属性
    public void visitAttribute(Attribute attr)



    //定义一个字段， 返回的FieldVisitor用于生成字段相关的信息
    public FieldVisitor visitField(
        int access,
        String name,
        String desc,
        String signature,
        Object value)


    //定义一个方法， 返回的MethodVisitor用于生成方法相关的信息
    public MethodVisitor visitMethod(
        int access,
        String name,
        String desc,
        String signature,
        String[] exceptions)

每个方法都是和class文件中的某部分数据相对应的， 如果对class文件的格式比较熟悉的话， 使用ASM生成一个简单的类， 还是很容易的。


总结
在本文中， 通过使用开源的ASM库， 动态生成了两个类。 通过讲解这两个类的生成过程， 可以加深对class文件格式的理解。 因为ASM库中的每个API都是对应class文件中的某部分信息的。 如果对class文件格式不熟悉， 可以参考本专栏之前的讲解class文件格式的一系列博客。 

本文使用的两个示例都放在了一个单独的， 可直接运行的工程中， 该工程已经上传到我的百度网盘， 这个工程的lib目录中， 有ASM 4.0的jar包。 和该工程一起打包的， 还有ASM 4.0的源码和示例程序。 

上述资源下载地址： http://pan.baidu.com/s/1dDmq84T 




更多关于深入理解Java的文章, 请关注我的专栏 : http://blog.youkuaiyun.com/column/details/zhangjg-java-blog.html

更多关于Java和Android等其他技术的文章, 请关注我的博客: http://blog.youkuaiyun.com/zhangjg_blog

【ASM】字节码操作 MethodVisitor 案例实战 init 方法生成
九师兄
08-05 347
第一点，如何使用 ClassWriter 类。第一步，创建 ClassWriter 美的实例。第二步，调用 ClassWriter 类的 visitXxx() 方法。第三步，调用 ClassWriter 类的 toByteArray() 方法。又使用。第二点，在使用MethodVisitor 类时,其中visitXxx() 方法需要遵循的调用顺序。第一步，调用visitCode()方法，调用一-次第二步，调用visitXxxInsn()方法,可以调用多次。......
1 用ASM生成一个class文件
Edison的博客
04-01 440
1 简介 ASM是一个可以用来生成、转换和分析以字节数组表示的已编译 Java 类的工具。 ASM 库提供了两个用于生成和转换已编译类的 API，一个是核心 API，以基于事件的形式来表示类，另 一个是树 API，以基于对象的形式来表示类。 基于事件就是每个把方法声明、字段、指令看成事件，这些事件有必须遵循的发生顺序。 基于对象就是把方法声明、字段、指令看成看成对象，每个对象都有一些引用，指向表示其组成部分的 对象。 下面介绍如何使用ASM来生成一个类，并让它能够输出"Hello, world!"。 2 实
asm动态生成class,并且动态加载执行
04-06
NULL 博文链接：https://name327.iteye.com/blog/1554558
java ASM动态生成类
weixin_30627341的博客
11-14 199
BeanTest2.java import java.io.FileOutputStream; import org.objectweb.asm.AnnotationVisitor; import org.objectweb.asm.ClassWriter; import org.objectweb.asm.FieldVisitor; import org.objectweb.a...
使用asm创建动态class
u012599432的博客
07-11 860
asm不是一个新的东西，javaee领域的开源框架都有asm的用武之地。准确来说 asm是用来操作字节码的，源代码是java编写。 asm官网https://asm.ow2.io/index.html asm的使用稍微复杂，需要了解字节码。我强烈建议从事java开发的同学必须会asm的基本操作，这会让你非常容易接近jvm的编译指令，类加载等原理上的东西，便于更好的理解jvm与java特性。 ...
【Java字节码操作】：利用ASM框架从jar文件中提取字节数组
!...# 1. Java字节码与ASM框架基础 Java字节码是运行在Java虚拟机（JVM）上的一种指令集，它是Java源代码编译后的产物，具有跨平台性。了解Java字节码对深入理解Java程序的运行机制、...通过ASM，开发者可以动态生成新的
JVM——Class文件
qq_37658380的博客
04-08 527
文章目录简介文件结构实战 简介 C或者C++传统语言写的程序通常首先被编译，然后被连接成单独的、专门支持特定硬件平台和操作系统的二进制文件，因此一个平台上的二进制可执行文件往往不能在其他平台上工作，而Java 程序是先被编译成Class文件，然后通过Classloader装载进入JVM运行时环境的方法区中，然后被字节码执行引擎执行。 写完Java程序点击运行，编译器会自动将代码编译成class文件然后交给JVM去执行，但是JVM只认Class文件，毫不关心这个Class是如何生成的，只要符合JVM规范中定义
Android ASM插桩探索及实战
AS011x的博客
09-08 833
前言我们都知道，在Android编译过程中，Java代码会被编译成Class文件，Class文件再被打进Dex文件，虚拟机最终会加载Dex文件去执行。​编辑添加图片注释，不超过 140 字（可选）插桩，就是干涉代码的编译过程，在编译期间生成新的代码或者修改已有的代码。常用的EventBus、ARouter，内部就是使用了APT（Annotation Process Tool），在编译的最开始解析Java文件中的注解，并生成新的Java文件。但如果有以下两个需求：给Activity的attach()方法加日志
Byte Buddy实战：动态代理与字节码增强技术全解
![Byte Buddy实战：动态代理与字节码增强技术全解]...而字节码增强则是在JVM加载类文件之前，动态地修改类的
ASM操作字节码，动态生成Java类class文件
02-03
ASM操作字节码，动态生成Java类class文件，模拟Spring的AOP实现原理。
hello.asm 一个简单汇编程序
03-09
hello.asm 汇编程序 Data SEGMENT string DB "HELLO WORLD! $" data ENDS CODE SEGMENT ASSUME CS:code,DS:data start: MOV AX,data MOV DS,AX MOV DX,OFFSET string MOV AH,9 INT 21H MOV AH,4CH INT 21H code ENDS END start
用Asm生成Class字节码文件
程序员青菜学厨记
10-23 164
这语法还是很难写的，调了好久才成功输出了HelloWorld，可以在Eclipse或IDEA中安装bytecode可以查一个Class文件的字节码，然后参照字节码文件修改代码，这个对字节码的编码需要特别了解才能写得好，一般我们直接使用。相对于Javassist，Asm是直接生成二进制Class文件，效率会更高，但编写代码特别繁琐，我只做简单了解一下，知道有这个玩意就行。这其实是一个系列，所讲的都是关于如何在执行的时候动态更改代码，从动态代理、到Javaassist，然后到Asm，都是为了做同一件事情。
利用ASM和Javassist动态生成Class 类(set和get)
最新发布
Dream It Possible
06-28 399
利用jvm的指令集直接构造class，简单的bean class 还是有应用场景的。在此利用ASM和Javassist各造例子以备忘！抽象类：SimpleJbean。
【ASM】ASM 与 Presto 动态代码生成简介
九师兄
04-17 651
1.概述 转载：ASM 与 Presto 动态代码生成简介 代码生成是很多计算引擎中常用的执行优化技术，比如我们熟悉的 Apache Spark 和 Presto 在表达式等地方就使用到代码生成技术。这两个计算引擎虽然都用到了代码生成技术，但是实现方式完全不一样。在 Spark 中，代码生成其实就是在 SQL 运行的时候根据相关算子动态拼接 Java 代码，然后使用 Janino 来动态编译生成相关的 Java 字节码并加载到相关 classLoader 中，这个动态编译会带来一定的使用成本，不过这个对于.
nasm-64_hello.asm
virhuiai的专栏
04-22 2629
;hello.asm a first program for nasm for Linux,Intel,gcc ; ;assemble: nasm -f elf64 -l hello.lst hello.asm ;link: gcc -o hello hello.o ;run: hello ;output is: Hello World SECTION .data ;data section
hello.asm
lhm的博客
03-18 786
一个操作系统的实现 第五章第一个程序 [section .data] strHello db "Hello, world!", 0Ah STRLEN equ $ - strHello [section .text] global _start _start: mov edx, STRLEN mov ecx, strHello mov ebx...
VS2013-调试汇编代码-生成asm文件-结构体内存布局-函数参数压栈-调用约定
插件开发
08-09 2702
参数按照从右至左的方式入栈。对齐数 = 编译器默认的一个对齐数与该成员大小中的较小值，vs中默认值是8，取较小值1，char类型的对齐数是1，所以对齐到1 的整数倍，那就是偏移量为1开始的地址空间。如果写一个汇编函数，给 C/C++ 调用，在 __cdecl 方式下，则汇编函数无需清除堆栈，在 __stdcall 方式下，汇编函数需要在返回（RET）之前恢复堆栈。4.如果嵌套结构体，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（包含嵌套结构体的对齐数）的整数倍。...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值