精华内容
下载资源
问答
  • R语言igraph包编写网络分析代码原理和代码例子,怎么在中国知网上搜索相关的论文呢。表示自己查不到,有详细的技术路线更好
  • ARM Cortex-M底层技术(二)启动代码原理分析

    千次阅读 多人点赞 2018-03-10 16:13:47
    ARM Cortex-M底层技术(二)Cortex-M启动代码原理分析写在前面的话: 近些年来ARM Cortex-M阵营各厂商(ST、NXP、ATMEL、Freescale……)发布新产品的节奏越来越快,以及微控制器应用普及程度的加深,越来越多的...

    ARM Cortex-M底层技术(二)Cortex-M启动代码原理分析

    写在前面的话:

        近些年来ARM Cortex-M阵营各厂商(ST、NXP、ATMEL、Freescale……)发布新产品的节奏越来越快,以及微控制器应用普及程度的加深,越来越多的开发者把更多精力投注在应用层开发上,花在对底层技术上的时间越来越少。小编我希望借助我之前对底层的一些积累,可以帮到大家快速的建立对Cortex-M系列处理器(M0/M0+/M3/M4/M7以及新的M23/M33)的底层技术:芯片内核、编译器/开发环境底层、底层软件、调试技术等的快速积累,可以帮助大家更好、更快、更可靠的开发产品。

    Cortex-M启动代码原理分析

            这里以NXP的LPC54608的启动代码startup_LPC54608.s文件为例,分析其启动代码原理。
            选用LPC54608原因,没什么特别原因,手边刚好有这货的板子,而且这颗片子刚发布不久,功能还蛮全的,LCDC、Ethernet、USB-HOST、外部总线……神马的很多外设都有,所有Cortex-M系列的MCU启动代码都大同小异,基本上搞定一个其他的都可以以此类推,当然搞懂启动代码没太大意思,之后我们可以动手一起写一个自己版本的启动代码。你会发现当你要自己写启动代码时,我们会遇到一系列底层的问题,不动手实干一下是不知道的。不废话了,开始吹NB~
            ARM Cortex-M系列MCU的启动代码(使用汇编语言编程则不需要)主要做3件事情:
            1、初始化并正确放置异常/中断向量表;
            2、分散加载;
            3、初始化C语言运行环境(初始化堆栈以及C Library、浮点等)。
            startup_LPC54608.s启动代码的简要说明大致如下(代码中省略若干雷同部分):


        上面我们能看到的启动代码主要是完成了初始化并正确放置异常/中断向量表的工作,C Library初始化以及分散加载的工作是在__main()中完成的,__main()中的代码我们是看不到的,在Keil的根目录下我们可以找到对应的文件,但是我们看不到源码,但是我们可以通过跟踪汇编代码大概看到__main()中的代码。比如这样~
            1、__main()中运行的具体代码会根据不同的工程配置以及用户程序的不同有细微改变;
            2、Keil版本的变更也会导致__main()中运行代码发生改变,但很细微;
            以Keil5.24版本为例我大概抓了一下__main中内容如以下两图所示,这里__main中代码流程的不同主要是由是否勾选了MicroLib来决定的。
            
            microlib是缺省C库的备选库。它旨在与需要装入到极少量内存中的深层嵌入式应用程序配合使用。这些应用程序不在操作系统中运行。microlib进行了高度优化以使代码变得很小。它的功能比缺省C库少,并且根本不具备某些ISOC特性。某些库函数的运行速度也比较慢,例如,memcpy()
     

    microlib是缺省C库的备选库。它旨在与需要装入到极少量内存中的深层嵌入式应用程序配合使用。这些应用程序不在操作系统中运行。microlib进行了高度优化以使代码变得很小。它的功能比缺省C库少,并且根本不具备某些ISOC特性。某些库函数的运行速度也比较慢,例如,memcpy()

    microlib与缺省C库之间的主要差异是:

        l  microlib不符合ISO C库标准。不支持某些ISO特性,并且其他特性具有的功能也较少;

        l  microlib不符合IEEE 754二进制浮点算法标准;

        l  microlib进行了高度优化以使代码变得很小;

        l  无法对区域设置进行配置。缺省C区域设置是唯一可用的区域设置;

        l  不能将main()声明为使用参数,并且不能返回内容;

        l  不支持stdio,但未缓冲的stdinstdoutstderr除外;

        l  microlibC99函数提供有限的支持;

        l  microlib不支持操作系统函数;

        l  microlib不支持与位置无关的代码;

        l  microlib不提供互斥锁来防止非线程安全的代码;

        l  microlib不支持宽字符或多字节字符串;

        l  stdlib不同,microlib不支持可选择的单或双区内存模型。microlib只提供双区内存模型,即单独的堆栈和堆区。

            启动流程1(使用标准库,不使用Microlib)如下图:
            
            启动流程2(使用Microlib)如下图
        
            到这里,关于启动代码的话题并没有讨论完,接下来:
            1、关于分散加载我以后会专门写几篇关于分散加载的文章;
            2、下一步我也会写一篇文章来简要介绍下启动代码的用处以及用法;

    展开全文
  • ARM启动代码原理和分析

    千次阅读 2016-07-10 17:10:51
    RO代码段 ZI未初始化数据段 RW数据段 Load Address加载地址 Execu o n A ddress 执行地址 Stack Pointer栈空间指针 Boot相关硬件 • Flash Rom(可作为bootrom的存储器) Boot相关硬件 Boot相关硬件 Boot...

    内容大纲

    内容关键字:

    映像文件

    RO代码段
    ZI未初始化数据段
    RW数据段
    Load Address加载地址
    Execu o n A ddress 执行地址
    Stack Pointer栈空间指针

    Boot相关硬件

    • Flash Rom(可作为bootrom的存储器)


    Boot相关硬件


    Boot相关硬件

    Boot的主要功能

    • 建立异常向量表
    • 初始化中断
    • 初始化硬件设备

    • 初始化应用程序执行环境

    • 跳转到主应用程序

    初始化硬件
    • 软件的运行离不开硬件,boot必须对硬件进
    行初始化。硬件的初始化主要通过配置特
    殊控制寄存器来完成,包括下面几部分:
    关闭开门狗
    屏蔽所有的中断
    初始化PLL和时钟。

    初始化储存系统

    初始化应用程序的执行环境

    • Elf文件的类型:可执行文件、可重定位文
    件、共享库object(又叫做共享库)文件。
    • Elf文件的功能:
    1、用作链接器的输入生成可执行的映像文件
    2、可装载到内存里运行,完成特定功能的文件。

    elf文件的物理结构

    • Elf文件头
    • Sec o n: .text .d ata .b ss. sym t ab
    • Program header
    • 可重定位文件与可执行文件的区别:
    区与段的概念

    program header


    可执行映像文件的逻辑结构

    由几个可重定位的目标文件的相同属性区组
    成了可执行映像的段,那么段有组成什么?
    在逻辑结构里,段组成了更大的组织:域



    装载域和运行域
    • 域又组成什么呢?当然就是组成可执行文件了,一个映像文件可以包含一到多个域。与看起来有些多余,实际上更为重要的是用域来描述输出区运行前和运行时在存储系统上的位置。所以,域分为装载域和运行域。装载域描述运行前输出段在rom/ram中的分布状态,运行域描述运行时输出段在rom/ram中的分布状态

    • 大多数情况下,映像文件在执行前把它装载到rom中,而当运行时域里 的有些输出段必须复制到ram中,程序才能正常运行,所以,在装载和运行时,有些段处在不同的位置(地址空间)。


    • 由图可以看出,映像文件zi段在装载域里是不存在的,在运行域里才建立的;映像文件在运行时,第一件工作就是把rw输出段复制到ram里的正确位置,第二件工作就是建立zi输出段并初始化为0。这就是应用程序执行环境的初始化。然而,在运行时,代码和数据分布到了不同的地址空间,形成了三个运行域:ro运行域、rw运行域、zi运行域。那么这个过程是如何来实现的?

    • |Image$$RO$$Base|; Base of ROM code
    |Image$$RO$$Limit| ; End of ROM code
    (=start of ROM data)
    |Image$$RW$$Base| ; Base of RAM to
    ini a l ise
    |Image$$ZI$$Base| ; Base and limit of area
    |Image$$ZI$$Limit| ;

    分散装载技术

    • 分散装载技术可以把用户的应用程序分割成多个RO运行域和RW运行域,并且给他们指定不同的地址,这在嵌入式系统的实际应用中有很多的好处。在一个嵌入式系统中,fl a sh 、16位ram、32位ram都可能存在于系统中,所以将不同功能的代码定位于特定的位置上会大大提高系统的运行效率。



    展开全文
  • Java 运行时动态编译源代码原理和实现

    万次阅读 多人点赞 2017-03-02 23:08:37
    编译,一般来说就是将源代码转换成机器码的过程,比如在C语言中中,将C语言源代码编译成a.out,,但是在Java中的理解可能有点不同,编译指的是将java 源代码转换成class字节码的过程,而不是真正的机器码,这是因为...

    编译,一般来说就是将源代码转换成机器码的过程,比如在C语言中中,将C语言源代码编译成a.out,,但是在Java中的理解可能有点不同,编译指的是将java 源代码转换成class字节码的过程,而不是真正的机器码,这是因为中间隔着一个JVM。虽然对于编译的理解不同,但是编译的过程基本上都是相同的。但是我们熟悉的编译大都是点击一下Eclipse或者Intellij Idea的Run或者Build按钮,但是在点击后究竟发生什么?其实我没仔细了解过,只是知道这个程序运行起来了,但是如果你使用过javac命令去编译代码时,可能了解的就更深一些,据说印度的Java程序员最开始编程的时候使用的都是文本编辑器而不是IDE,这样更能接触底层的过程。
    除了使用javac命令编译Java程序,从Java 1.6开始,我们也可以在程序运行时根据程序实际运行来构建一些类并进行编译,这需要JDK提供给我们一些可供调用的接口来完成编译工作。

    一、编译源码需要啥?

    那么问题来了,如果要了解运行时编译的过程和对应的接口,首先要明白的就是编译这个过程都会涉及哪些工具和要解决的问题?从我们熟悉的构建过程开始:

    • 编译工具(编译器):显然没有这个东西我们啥也干不了;
    • 要编译的源代码文件:没有这个东西,到底编啥呢?
    • 源代码、字节码文件的管理:其实这里靠的是文件系统的支持,包括文件的创建和管理;
    • 编译过程中的选项:要编译的代码版本、目标,源代码位置,classpath和编码等等,见相关文章;
    • 编译中编译器输出的诊断信息:告诉你编译成功还是失败,会有什么隐患提出警告信息;

    按照这些信息,JDK也提供了可编程的接口对象上述信息,这些API全部放在javax.tools包下,对应上面的信息如下:

    • 编译器:涉及到的接口和类如下:

      • JavaCompiler
      • JavaCompiler.CompilationTask
      • ToolProvider

      在上面的接口和类中,ToolProvider类似是一个工具箱,它可以提供JavaCompiler类的实例并返回,然后该实例可以获取JavaCompiler.CompilationTask实例,然后由JavaCompiler.CompilationTask实例来执行对应的编译任务,其实这个执行过程是一个并发的过程。

    • 源代码文件:涉及到接口和类如下:

      • FileObject
      • ForwardingFileObject
      • JavaFileObject
      • JavaFileObject.Kind
      • ForwardingJavaFileObject
      • SimpleJavaFileObject

      上述后面的4个接口和类都是FileObject子接口或者实现类,FIleObject接口代表了对文件的一种抽象,可以包括普通的文件,也可以包括数据库中的数据库等,其中规定了一些操作,包括读写操作,读取信息,删除文件等操作。我们要用的其实是JavaFileObject接口,其中还增加了一些操作Java源文件和字节码文件特有的API,而SimpleJavaFileObject是JavaFileObject接口的实现类,但是其中你可以发现很多的接口其实就是直接返回一个值,或者抛出一个异常,并且该类的构造器由protected修饰的,所以要实现复杂的功能,需要我们必须扩展这个类。ForwardingFileObject、ForwardingJavaFileObject类似,其中都是包含了对应的FileObject和JavaFileObject,并将方法的执行委托给这些对象,它的目的其实就是为了提高扩展性。

    • 文件的创建和管理:涉及接口和类如下:

      • JavaFileManager
      • JavaFileManager.Location
      • StandardJavaFileManager
      • ForwardingJavaFileManager
      • StandardLocation

      JavaFileManager用来创建JavaFileObject,包括从特定位置输出和输入一个JavaFileObject,ForwardingJavaFileManager也是出于委托的目的。而StandardJavaFileManager是JavaFileManager直接实现类,JavaFileManager.Location和StandardLocation描述的是JavaFileObject对象的位置,由JavaFileManager使用来决定在哪创建或者搜索文件。由于在javax.tools包下没有JavaFileManager对象的实现类,如果我们想要使用,可以自己实现该接口,也可以通过JavaCompiler类中的getStandardFileManager完成,如下:

      JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
      DiagnosticCollector<JavaFileObject> collector = new DiagnosticCollector<>();
      // 该JavaFileManager实例是com.sun.tools.javac.file.JavacFileManager
      JavaFileManager manager= compiler.getStandardFileManager(collector, null, null);
    • 编译选项的管理:

      • OptionChecker

      这个接口基本上没有用过。

    • 诊断信息的收集:涉及接口和类如下:

      • Diagnostic
      • DiagnosticListener
      • Diagnostic.Kind
      • DiagnosticCollector

      Diagnostic会输出编译过程中产生的问题,包括问题的信息和出现问题的定位信息,问题的类别则在Diagnostic.Kind中定义。DiagnosticListener则是从编译器中获取诊断信息,当出现诊断信息时则会调用其中的report方法,DiagnosticCollector则是进一步实现了DiagnosticListener,并将诊断信息收集到一个list中以便处理。

    在Java源码运行时编译的时候还会遇到一个与普通编译不同的问题,就是类加载器的问题,由于这个问题过大,而且比较核心,将会专门写一篇文章介绍。

    二、如何在运行时编译源代码?

    好了说了这么多了,其实都是为了下面的实例作为铺垫,我们还是从上述的几个组件来说明。

    1、准备编译器对象

    这里只有一种方法,如下:

    JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
    // ......
    // 在其他实例都已经准备完毕后, 构建编译任务, 其他实例的构建见如下
    Boolean result = compiler.getTask(null, manager, collector, options,null,Arrays.asList(javaFileObject));

    2、诊断信息的收集

    // 初始化诊断收集器
    DiagnosticCollector<JavaFileObject> collector = new DiagnosticCollector<>();
    // ......
    // 编译完成之后,获取编译过程中的诊断信息
    collector.getDiagnostics().forEach(item -> System.out.println(item.toString()))

    在这个过程中可以通过Diagnostic实例获取编译过程中出错的行号、位置以及错误原因等信息。

    3、源代码文件对象的构建

    由于JDK提供的FileObject、ForwardingFileObject、JavaFileObject、ForwardingJavaFileObject、SimpleJavaFileObject都无法直接使用,所以我们需要根据需求自定义,此时我们要明白SimpleJavaFileObject类中的哪些方法是必须要覆盖的,可以看如下过程:

    这里写图片描述

    下面是调用compiler中的getTask方法时的调用栈,可以看出从main()方法中开始调用getTask方法开始,直到编译工作开始进行,首先读取源代码,调用com.sun.tools.javac.main包中的readSource()方法,源代码如下:

    public CharSequence readSource(JavaFileObject filename) {
      try {
        inputFiles.add(filename);
        return filename.getCharContent(false);
      } catch (IOException e) {
        log.error("error.reading.file", filename, JavacFileManager.getMessage(e));
        return null;
      }
    }

    其中调用ClientCodeWrapper$WrappedFileObject对象中的filename.getCharContent(false)方法来读取要编译的源码,源代码如下:

    public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
      try {
        return clientFileObject.getCharContent(ignoreEncodingErrors);
      } catch (ClientCodeException e) {
        throw e;
      } catch (RuntimeException e) {
        throw new ClientCodeException(e);
      } catch (Error e) {
        throw new ClientCodeException(e);
      }
    }

    而其中的clientFileObject.getCharContent(ignoreEncodingErrors),其实就是调用我们实现的自定义的JavaFIleObject对象,因此源代码文本是必须的,因此getCharContent方法是必须实现的,另外在编译器编译完成之后要将编译完成的字节码输出,如下图:

    这里写图片描述

    这时调用writeClass()输出字节码,通过打开一个输出流OutputStream来完成该过程,因此openOutputStream()这个方法也是必须实现的。因此该类的实现如下:

    public static class MyJavaFileObject extends SimpleJavaFileObject {
        private String source;
        private ByteArrayOutputStream outPutStream;
        // 该构造器用来输入源代码
        public MyJavaFileObject(String name, String source) {
            // 1、先初始化父类,由于该URI是通过类名来完成的,必须以.java结尾。
            // 2、如果是一个真实的路径,比如是file:///test/demo/Hello.java则不需要特别加.java
            // 3、这里加的String:///并不是一个真正的URL的schema, 只是为了区分来源
            super(URI.create("String:///" + name + Kind.SOURCE.extension), Kind.SOURCE);
            this.source = source;
        }
        // 该构造器用来输出字节码
        public MyJavaFileObject(String name, Kind kind){
            super(URI.create("String:///" + name + kind.extension), kind);
            source = null;
        }
    
        @Override
        public CharSequence getCharContent(boolean ignoreEncodingErrors){
            if(source == null){
                throw new IllegalArgumentException("source == null");
            }
            return source;
        }
    
        @Override
        public OutputStream openOutputStream() throws IOException {
            outPutStream = new ByteArrayOutputStream();
            return outPutStream;
        }
    
        // 获取编译成功的字节码byte[]
        public byte[] getCompiledBytes(){
            return outPutStream.toByteArray();
        }
    }

    4、文件管理器对象的构建

    文件管理对象显然也是不能直接使用JDK提供的接口,因为只有ForwardingJavaFileManager是一个类,其他的都是接口,而且在ForwardingJavaFileManager中构造器又是protected,所以如果想定制化使用的话,需要实现接口或者继承类,如果只是简单使用,可以如下:

    JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
    DiagnosticCollector<JavaFileObject> collector = new DiagnosticCollector<>();
    // 该JavaFileManager实例是com.sun.tools.javac.file.JavacFileManager
    JavaFileManager manager= compiler.getStandardFileManager(collector, null, null);

    但是compiler.getStandardFileManager()返回的是com.sun.tools.javac.file.JavacFileManager实例,这个不是公开的类,所以我们无法直接使用,只能通过这种调用返回实例。

    但是我们课也可以构造自己的FileManager,为了更好的构建,需要理解JavaFileManager在内存中编译时的使用过程,如下:

    1. 在编译过程中,首先是编译器会遍历JavaFileManager对象,获取指定位置的所有符合要求的JavaFileObject对象,甚至可以递归遍历,这时调用的是list()方法,该方法会扫面所有涉及的到的包,包括一个类和它实现的接口和继承的类:

      这里写图片描述

    2. 之后根据获取到的JavaFileObject对象,获取它的二进制表示的名称,通过调用inferBinaryName()方法;

    3. 之后是输出编译类,而类的表示为JavaFileObject对象,注意此时的JavaFileObject.KindCLASS,调用的方法是getJavaFileForOutput(),注意该方法的调用是在JavaFileObjectopenOutputStream()方法之前,如下图:

      这里写图片描述

    既然了解了上述的流程,我们自定义的文件管理器如下:

    private static Map<String, JavaFileObject> fileObjects = new ConcurrentHashMap<>();
    // 这里继承类,不实现接口是为了避免实现过多的方法
    public static class MyJavaFileManager extends ForwardingJavaFileManager<JavaFileManager> {
            protected MyJavaFileManager(JavaFileManager fileManager) {
                super(fileManager);
            }
    
            @Override
            public JavaFileObject getJavaFileForInput(Location location, String className, JavaFileObject.Kind kind) throws IOException {
                JavaFileObject javaFileObject = fileObjects.get(className);
                if(javaFileObject == null){
                    super.getJavaFileForInput(location, className, kind);
                }
                return javaFileObject;
            }
    
            @Override
            public JavaFileObject getJavaFileForOutput(Location location, String qualifiedClassName, JavaFileObject.Kind kind, FileObject sibling) throws IOException {
                JavaFileObject javaFileObject = new MyJavaFileObject(qualifiedClassName, kind);
                fileObjects.put(qualifiedClassName, javaFileObject);
                return javaFileObject;
            }
    }

    5、编译选项的选择

    在使用javac命令的时候,可以添加很多的选项,在实现API完成编译的时候也可以提供参数,比如编译目标,输出路径以及类路径等等,如下:

    List<String> options = new ArrayList<>();
    options.add("-target");
    options.add("1.8");
    options.add("-d");
    options.add("/");
    // 省略......
    compiler.getTask(null, javaFileManager, collector, options, null, Arrays.asList(javaFileObject));

    6、其他问题

    • 想将编译完成的字节码输出为文件,也不需要上面自定义JavaFileManager,直接使用JavaCompiler提供的即可,而且在自定义的JavaFileObject中也不需要实现OpenOutStream这种方法,代替要提供options.add(“-d”),options.add(“/”)等编译选项;如果不输出为文件按照上述的例子即可;
    • StandardLocation中的元素可以代替真实的路径位置,但是不会输出为文件,可以为一个内存中的文件;
    • 在编译完成之后要将字节码文件加载进来,因此就要涉及到类加载机制,由于这也是一个很大的话题,所以后面会专门总结一篇,但是在这里还是要说明一下,由于上面编译时没有额外的依赖包,所以不用考虑加载依赖文件的问题,但是当如果有这样的需求时,我们可以利用类加载的委托机制,将依赖文件的加载全部交给父加载器去做即可。

    三、完整的例子

    public class App {
        private static Map<String, JavaFileObject> fileObjects = new ConcurrentHashMap<>();
        public static void main( String[] args ) throws IOException {
            String code = "public class Man {\n" +
                    "\tpublic void hello(){\n" +
                    "\t\tSystem.out.println(\"hello world\");\n" +
                    "\t}\n" +
                    "}";
    
            JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
            DiagnosticCollector<JavaFileObject> collector = new DiagnosticCollector<>();
            JavaFileManager javaFileManager = new MyJavaFileManager(compiler.getStandardFileManager(collector, null, null));
    
            List<String> options = new ArrayList<>();
            options.add("-target");
            options.add("1.8");
    
            Pattern CLASS_PATTERN = Pattern.compile("class\\s+([$_a-zA-Z][$_a-zA-Z0-9]*)\\s*");
            Matcher matcher = CLASS_PATTERN.matcher(code);
            String cls;
            if(matcher.find()){
                cls = matcher.group(1);
            } else{
                throw new IllegalArgumentException("No such class name in " + code);
            }
    
            JavaFileObject javaFileObject = new MyJavaFileObject(cls, code);
            Boolean result = compiler.getTask(null, javaFileManager, collector, options, null, Arrays.asList(javaFileObject)).call();
    
            ClassLoader classloader = new MyClassLoader();
    
            Class<?> clazz = null;
            try {
                clazz  = classloader.loadClass(cls);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
    
            Method method = null;
            try {
                method = clazz.getMethod("hello");
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            }
            try {
                method.invoke(clazz.newInstance());
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            }
        }
    
        public static class MyClassLoader extends ClassLoader {
    
            @Override
            protected Class<?> findClass(String name) throws ClassNotFoundException {
                JavaFileObject fileObject = fileObjects.get(name);
                if(fileObject != null){
                    byte[] bytes = ((MyJavaFileObject)fileObject).getCompiledBytes();
                    return defineClass(name, bytes, 0, bytes.length);
                }
                try{
                    return ClassLoader.getSystemClassLoader().loadClass(name);
                } catch (Exception e){
                    return super.findClass(name);
                }
            }
        }
    
        public static class MyJavaFileObject extends SimpleJavaFileObject {
            private String source;
            private ByteArrayOutputStream outPutStream;
    
    
            public MyJavaFileObject(String name, String source) {
                super(URI.create("String:///" + name + Kind.SOURCE.extension), Kind.SOURCE);
                this.source = source;
            }
    
            public MyJavaFileObject(String name, Kind kind){
                super(URI.create("String:///" + name + kind.extension), kind);
                source = null;
            }
    
            @Override
            public CharSequence getCharContent(boolean ignoreEncodingErrors){
                if(source == null){
                    throw new IllegalArgumentException("source == null");
                }
                return source;
            }
    
            @Override
            public OutputStream openOutputStream() throws IOException {
                outPutStream = new ByteArrayOutputStream();
                return outPutStream;
            }
    
            public byte[] getCompiledBytes(){
                return outPutStream.toByteArray();
            }
        }
    
        public static class MyJavaFileManager extends ForwardingJavaFileManager<JavaFileManager> {
            protected MyJavaFileManager(JavaFileManager fileManager) {
                super(fileManager);
            }
    
            @Override
            public JavaFileObject getJavaFileForInput(Location location, String className, JavaFileObject.Kind kind) throws IOException {
                JavaFileObject javaFileObject = fileObjects.get(className);
                if(javaFileObject == null){
                    super.getJavaFileForInput(location, className, kind);
                }
                return javaFileObject;
            }
    
            @Override
            public JavaFileObject getJavaFileForOutput(Location location, String qualifiedClassName, JavaFileObject.Kind kind, FileObject sibling) throws IOException {
                JavaFileObject javaFileObject = new MyJavaFileObject(qualifiedClassName, kind);
                fileObjects.put(qualifiedClassName, javaFileObject);
                return javaFileObject;
            }
        }
    }

    相关文章:

    展开全文
  • 位置无关(PIC)代码原理剖析

    千次阅读 2016-01-10 20:32:58
    共享库的一个关键目的是为了使多个进程能够共享内存中的同一份代码拷贝,已达到节约内存资源的目的。如何做到呢?一种方法是预先为每一个共享库指定好加载的地址范围,然后要求加载器总是将共享库加载至指定的位置。...
    共享库的一个关键目的是为了使多个进程能够共享内存中的同一份代码拷贝,已达到节约内存资源的目的。如何做到呢?一种方法是预先为每一个共享库指定好加载的地址范围,然后要求加载器总是将共享库加载至指定的位置。这种方法尽管很简单,但是会产生一些严重的问题。因为就算一个进程并没有用到某个库,相应的地址范围依然会被保留下来,这是一种效率很低的内存使用方式。另外,这种方法管理起来也很困难。我们必须保证预留的地址块之间没有重叠。每当一个库被修改后,我们还必须要保证它能被放回到修改前的位置,否则,我们还要为它重新找一个新的位置。当我们创建一个新的库时,我们还要为它寻找合适的空间,地址空间碎片化造成的大量无用的内存空洞。更糟糕的是,不同的系统为动态库分配内存的方式不尽相同,这使得管理起来更为困难。
    一个更好的方法是将动态库编译成可以在任意位置加载而无需链接器进行修改。这样的代码被称作位置无关代码(PIC)。GNU编译系统可以通过指定-fPIC选项来生成PIC代码。
    在IA32系统中,同一个模块中的过程调用无需特殊处理就是PIC的,因为其引用相对于PC地址的偏移量是已知的。但是,对外部过程的调用和对全局变量的引用一般却不是PIC的,因此需要在链接的时候进行重定位。


    PIC数据引用
    编译器对全局变量生成PIC引用是基于下面这个有趣的事实:无论目标模块(包括共享目标模块)被加载到内存中的什么位置,数据段总是紧跟着地址段的。因此,代码段中的任意指令与数据段中的任意变量之间的距离在运行时都是一个常量,而与代码和数据加载的绝对内存位置无关。
    为了利用这一特点,编译器在数据段的开头创建了一个全局偏移表(GOT)。在GOT中,目标模块所引用的每个全局数据对象都对应一个表项。编译器同时为GOT中的每个表项生成了一个重定位记录。在加载时,动态链接器重定位GOT中的每个表项,使其包含正确的绝对地址。每个包含全局数据引用的目标模块都有其自己的GOT。
    在运行时,每个全局变量通过GOT被间接引用,如下列代码所示:


    	
    call L1
    L1:	popl %ebx            ebx包含着当前的PC
    	addl $VAROFF, %ebx   ebx指向var所对应的GOT表项
    	movl (%ebx), %eax    通过GOT间接引用
    	movl (%eax), %eax
    


    在这段代码中,对L1的调用将返回地址(也就是popl指令所对应的地址)压入堆栈。接着popl指令将其弹出至%ebx。这两条指令的效果就相当于把PC值加载至寄存器%ebx。
    addl指令将%ebx加上一个常数偏移量,使其指向对应的GOT表项,其中包含着引用数据的绝对地址。此时,全局变量可以通过包含在%ebx中的GOT表项被间接引用。在这个例子中,两条movl指令将全局变量的内容通过GOT间接地加载进寄存器%eax。
    PIC代码具有性能上的缺陷。现在每次全局变量引用都需要5条指令而不是1条,同时GOT还需要占用额外的内存空间。并且,PIC代码需要使用额外的寄存器来保存GOT表项的地址。在寄存器较多的机器上,这不是什么大问题。但是在寄存器较少的IA32系统中,缺少哪怕一个寄存器都可能会触发将寄存器内容暂存在堆栈里。


    PIC函数调用
    可以使用相同的方法实现对外部函数调用的PIC代码:

    	
    call L1
    L1:     popl %ebx		ebx保存当前的PC值
    	addl $PROCOFF, %ebx	ebx指向调用函数的GOT表项地址
    	call *(%ebx) 		通过GOT间接调用
    

    但是这种方法对每次调用都需要3条额外的指令。于是,ELF编译系统使用了一种叫做延迟绑定(lazy binding)的技术将函数地址的绑定推迟到函数被首次调用时。这样,仅在第一次调用是会产生额外的时间开销,但在后面的调用中仅仅消耗一条额外指令和内存引用。
    延迟绑定需要在两个数据结构之间进行密集而复杂的交互:GOT和过程连接表(procedure linkage table, PLT)。如果一个目标模块调用了共享库中的任意函数,那么它就有它自己的GOT和PLT。GOT是.data段的一部分。PLT是.text段的一部分。
    GOT的前3项包含了一些特殊的值:GOT[0]中保存的是.dynamic段的地址,其中保存着动态链接器用来绑定过程地址所需要的信息,包括符号表的位置和重定位信息。GOT[1]中保存着当前模块的一些信息。GOT[2]是动态链接器延迟绑定代码的入口地址。每个被调用的动态对象中的函数在GOT中都有一个对应的表项,从GOT[3]开始。比如,定义在libc.so的printf,以及定义在libvector.so的addvec。
    下面的代码展示了PLT的内容。PLT是16字节表项构成的数组。第一项PLT[0]是一个特殊项,为跳到动态链接器的入口。从PLT[1]开始,每一个被调用的函数在PLT中都有对应项,其中,PLT[1]对应printf,PLT[2]对应addvec.

    PLT[0]
    08048444:	pushl	$GOT[1]
    		jmp to	*GOT[2](linker)	 
    		padding
    		padding
    
    PLT[1] <printf>
    8048454:	jmp to	*GOT[3]
    		pushl   $0x0 	ID for	printf
    		jmp to	PLT[0]
    
    PLT[2] <addvec>
    8048464:	jmp to *GOT[4]
    		pushl   $0x8	ID for	addvec
    		jmp to	PLT[0]
    
    <other PLT entries>
    

    在程序被动态链接之后并开始执行时,函数printf和addvec被绑定到相应PLT项的第一条指令,比如,对addvec的调用为:

    call 8048464 <addvec>

    当addvec第一次被调用时,PLT[2]的第一条指令被执行,即间接跳转到GOT[4]保存的地址。GOT表项的初始值为PLT表项中的pushl指令的地址。因此,跳转后的执行指令重新回到了PLT表项的第二条指令。这条指令将addvec符号的ID压入栈中。然后下一条指令跳转到PLT[0],将另一个存放于GOT[1]中的标识信息字压入栈,然后通过GOT[2]间接跳转到动态链接器。动态链接器通过栈中的这两项数据来定位addvec,并用其覆盖GOT[4]的值,然后将控制权交给addvec。

    当下次addvec被调用时,同之前一样,先是执行PLT[2]的第一条指令。但是这次将通过GOT[2]直接跳转到addvec。所增加的开销只是间接跳转所需的内存引用。


    翻译自《深入理解计算机系统》第七章

    展开全文
  • Adaboost算法原理分析和实例+代码(简明易懂)

    万次阅读 多人点赞 2017-05-02 08:52:31
    Adaboost算法原理分析和实例+代码(简明易懂) 【尊重原创,转载请注明出处】 http://blog.csdn.net/guyuealian/article/details/70995333 本人最初了解AdaBoost算法着实是花了几天时间,才明白他的基本原理。...
  • erlang虚拟机代码执行原理

    千次阅读 2015-06-03 20:02:28
    erlang是开源的,很多人都研究过源代码。但是,从erlang代码到c代码,这...所以这里,我利用一些时间,整理下erlang代码的执行过程,从erlang代码编译过程,到代码执行过程做讲解,然后重点讲下虚拟机执行代码原理
  • 基础 | batchnorm原理代码详解

    万次阅读 多人点赞 2018-01-12 22:02:03
    本文旨在用通俗易懂的语言,对深度学习的常用算法–batchnorm的原理及其代码实现做一个详细的解读。本文主要包括以下几个部分。 Batchnorm主要解决的问题 Batchnorm原理解读 Batchnorm的优点 B
  • UTC时间转北京时间原理与matlab代码

    千次阅读 2019-08-21 09:34:51
    UTC时间转北京时间原理与matlab代码 原理 协调世界时(英语:Coordinated Universal Time,法语:Temps Universel Coordonné,简称UTC)是最主要的世界时间标准,其以原子时秒长为基础,在时刻上尽量接近于格林尼治...
  • 代码雨实现原理代码分析

    万次阅读 多人点赞 2016-11-13 22:24:42
    闲来无事,好奇代码雨是怎么实现的,早就听说是利用链表,但自己却想不出实现的思路,花了两个晚上把代码看完了,分析都在代码里,先看下效果吧。 在贴代码之前先简单说下代码,方便读者加深理解。 代码雨所...
  • 二维码生成原理及解析代码

    万次阅读 多人点赞 2017-12-18 22:35:06
    二维码生成原理及解析代码 自从大街小巷的小商小贩都开始布满了腾讯爸爸和阿里爸爸的二维码之后,我才感觉到我大天朝共享支付的优越性。最近毕业论文写的差不多了,在入职之前多学一些东西也是好的。这里秉着好奇心...
  • 编译原理代码优化

    万次阅读 多人点赞 2017-12-18 10:43:49
    编译原理出于代码编译的模块化组装考虑,一般会在语义分析的阶段生成平台无关的中间代码,经过中间代码级的代码优化,而后作为输入进入代码生成阶段,产生最终运行机器平台上的目标代码,再经过一次目标代码级别的...
  • 代码生成器原理

    千次阅读 2014-11-16 11:56:24
    C:一些辅助工具、基础组件,是为了加强自动产生代码的功能、简化代码复杂性,进行合理的分工协作用的。 D:自动生成的代码部分,用PowerDesigner设计简洁明了、易于沟通理解,代码分自动生成及人工部分,为了重复...
  • javascript代码混淆的原理

    千次阅读 2020-09-06 22:19:25
    代码压缩: 去除空格 换行等 代码加密: eval eval可以将其中的参数按照JavaScript的的语法进行解析并执行,其实就是将JavaScript的代码变成了eval的参数其中的一些字符会被按照特定的编码 可以使用eval加密的...
  • javascript实现代码高亮原理

    千次阅读 2017-01-13 12:36:59
    网上有很多的代码高亮库,之前想自己写一个,但是想不出原理。我一开始的想法是把代码赋值给一个变量,然后使用indexOf确定下标,再加上span,再给span颜色。然而,并没有什么卵用…… 2015年08月29日提问...
  • Simulink 自动代码生成原理

    千次阅读 2018-06-12 22:05:50
    典型的 Simulink 用户通常都是,用Simulink设计好算法后,做到生成源代码这一步。然后把生成的算法的.c .h 源代码拷贝到自己的工程目录下(比如 CCS或者CodeWarrior 或者 VC ),去做编译。 但是也有部分人希望把编译...
  • 编译原理 代码优化

    千次阅读 2018-10-22 01:34:29
    代码优化: 因为抽象语法树中可能包括错误,因此不能在抽象语法树阶段进行优化。 函数式的优化:输入一个抽象语法树,输出一个抽象语法树: 在循环中,如果E仍在缩小,就持续常量折叠。 本来...
  • 编译原理代码生成

    千次阅读 2017-12-18 16:13:41
    前面提到了经过了词法分析->语法分析->语义分析->中间代码优化,最后的阶段...之所以将编译原理分成这种多阶段多模块的组织形式,本质的考虑其实只有两个方面: 一、代码复用:尽可能在不增加程序员工作量的前提下,增
  • 深度学习原理详解及Python代码实现

    千人学习 2019-12-07 21:14:52
    【为什么要学习这门课程】 深度学习框架如TensorFlow和Pytorch掩盖了深度学习底层实现方法,那能否能用Python代码从零实现来学习深度学习原理呢? 本课程就为大家提供了这个可能,有助于深刻理解深度学习原理。 左手...
  • WaveNet原理代码分析

    万次阅读 热门讨论 2018-04-11 10:28:22
    之前一直在computer vision方向的研究,现在换成语音方向,这段时间一直在看WaveNet,花了好长时间才把原理代码看懂,记录一下,以防后期遗忘吧。先给链接:WaveNet的论文链接, 代码链接和官方博客链接。 ...
  • CRC校验原理代码

    万次阅读 多人点赞 2018-08-14 14:55:05
    参考:CRC校验原理及步骤https://blog.csdn.net/d_leo/article/details/73572373 什么是CRC校验? CRC即循环冗余校验码:是数据通信领域中最常用的一种查错校验码,其特征是信息字段和校验字段的长度可以任意选定...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 163,519
精华内容 65,407
关键字:

代码原理