精华内容
下载资源
问答
  • 寻址

    2018-05-27 15:54:25
    2. 间接寻址:带方括号的寄存器寄存器相对寻址:在间接寻址的基础上和立即数做一个加法运算基址变址寻址:基址+变址(在方括号里)相对基址变址寻址:结合基址变址寻址,再与一个立即数做加法...
    立即寻址:

    操作数以常量(立即数)的形式出现在指令中


    存储器寻址:

    1. 直接寻址:带方括号的常量或变量。


    2. 间接寻址:带方括号的寄存器


    寄存器相对寻址:

    在间接寻址的基础上和立即数做一个加法运算


    基址变址寻址:

    基址+变址(在方括号里)


    相对基址变址寻址:

    结合基址变址寻址,再与一个立即数做加法


    展开全文
  • 直接寻址、间接寻址、立即寻址

    万次阅读 多人点赞 2018-06-01 11:38:56
    一、前言 直接寻址、间接寻址、立即寻址,只是CPU在通过总线与内存交互时的不同交互方法,而产生的三种概念词!对于这些寻址方式,很多人没有听说过,但是对于学习汇编的同学来说,非常熟悉,很多书中都有提到过这几...

    一、前言

        直接寻址、间接寻址、立即寻址,只是CPU在通过总线与内存交互时的不同交互方法,而产生的三种概念词!

    对于这些寻址方式,很多人没有听说过,但是对于学习汇编的同学来说,非常熟悉,很多书中都有提到过这几种寻址方式,但是没有细说,这里来给大家详细介绍一下这三种寻址方式的不同体现在哪里!

    二、直接寻址

        直接寻址即直接给出内存单元的物理地址/虚拟地址直接寻址!

    详细说一下:

    假如有一个内存,且大小是:0x00000000~0xFFFFFFFF

    每个物理地址代表一个内存单元(这里抛开虚拟内存管理机制),那么我想要取得0x00000001地址里的数据,首先CPU需要通过地址总线找到该内存单元,然后通过控制总线确定操作方法,在通过数据总线将其数据送回来,便于处理!

    那么我们要怎样将地址给CPU呢?

    答:

    放到CS段地址寄存器中,CS寄存器负责保存段地址,CPU会根据此段地址,去内存中将指令读取到CS:IP寄存器当中,然后执行!

    假如我想要将0x00000001地址里的数据取出来,放到AX寄存器当中,那么需要在内存中写好指定代码:

    MOVE AX,[DS:0x00000001H]

    MOVE AX,[0x00000001H]

    (AX内存=DS+0x00000001H)

     

    DS是段寄存器,这里无需多说,详细介绍可以看这篇文章:C语言内存模型详细介绍_堆栈介绍

     

    操作系统会自动帮我们把CS:IR寄存器指向我们的代码段,当CPU将指令取到CS:IP寄存器以后,就会通过CU控制单元译码解析指令转换成对应的电平信号,驱动CPU晶体管工作!

    CPU会直接将段地址+0x00000001的物理地址通过北桥,传送给内存芯片,内存芯片会把该地址里的数据取回来传递给CPU,当CPU接受到返回来的数据时,会把该数据写入到AX寄存器,这样一个指令就执行完成了,实际上并不是一个指令,其实CPU要分好几次时钟周期来执行,第一次去将DS寄存器里的段首地址读取出来,第二次加上0x00000001,第三次去内存中取数据,第四次将获取到的数据写入到AX中,即四个个时钟周期来完成一个指令,其中还会用到alu运算单元来进行段地址+偏移地址的运算,所以实际上可能需要多个时钟周期来完成!

    CPU是由晶体管来驱动的,每次开关驱动一次都称为一次时钟周期,时间周长不算,一般用赫兹来表示时钟周期的单位!

    上面的过程仅一步到位非常之快,因为我们直接给出了实际物理地址!

    下面来说说间接寻址

    三、间接寻址

    间接寻址是建立在直接寻址之上的一种概念,地址不是直接寻址那样直接给出,而是通过某个特定的内存单元得出,第一次是得到某个特定内存单元里的地址数据,第二次在将得出的地址进行DS+偏移地址H的运算直接寻址!

    这样说可能有点含糊不清,不过来看一下这段汇编代码,你就应该能明白直接寻址与间接寻址之间的区别了:

    MOV esp,0x00000001
    MOV AX,[esp]

    esp、eax等寄存器均为8086寻址寄存器,用于暂时存放地址的,并且寻址时也是以DS+esp的方式!

    其实esp和eax等e开头的寄存器和AX,BX,CX通用寄存器的作用没有区别,只是CPU设计者,设计出这么多寄存器是为了方便区分,某些寄存器做某些事情,这样更加方便于统一和区分,你也可以使用BX来进行间接寻址,只要你在里面写上[],这个括号在汇编里表示寻址括号,如果你把bx用[]括起来,CPU会把BX里的内容当做地址看待!

    这样的话,CPU要做的工作可就很多了,首先要将0x00000001地址送入到esp里,在将esp里的地址取出来,然后通过DS+esp在去内存中寻址,在取回来放到AX中!

    所以间接寻址说的明白一点,就是通过寄存器得到要寻址的地址,然后在寻址,而非直接给出地址直接寻址!

     

    上面有个疑惑,就是直接寻址的地址是怎么来的?

    答:在内存中取出指令存入到IP寄存器时,这个地址就已经存放进去了,在IP寄存器的低位,直接寻址的地址是存放在指令中的,而不需要二次获取!

     

    其如果使用间接寻址,在8085系列的CPU设计出了R0,R1的寄存器,并且如果间接寻址使用@符号表示

    mov R0,0x00000001
    mov ax,@R0

    用于表示间接寻址,不过这种寻址方式更加少见了,因为自8086系列CPU出现以后,[]指令的出现,更加方便于寻址,并且直观性更强,但是还是可以使用上面这种方法寻址的,因为向前兼容(即新的东西兼容老的东西),只是不同架构的CPU编写方法不同,但意思都是一个样!

     

    三、立即寻址

     

    通过上面的了解,立即寻址就非常简单了,即立即数寻址!

    立即数即指令的一部分,平常我们所看到的编程语言当中:

    int a = 5;

    这样我们在栈中保存了一个数据5,但是它是有空间的,在汇编中对它寻址是这样的:

    比如a在栈中的偏移地址是0x135h

    mov ax,[135h]

    CPU会到135h的内存中根据位宽寻址,将值寻回来以后,放入到ax寄存器当中!

     

    立即数不同,立即数是不占任何空间的,它存在于代码段,是指令的一部分:

     

    mov ax,135H

    ax内容=135

    当这个指令执行完成之后内存被释放掉之后,我们下次想要找到这个内存空间是找不到的!

    立即寻址要快于其它寻址,因为它无需进行寻址!

     

    展开全文
  • Json寻址工具类

    万次阅读 2020-04-15 17:05:52
    抽空写了个根据地址寻址json内容中的某个值的工具类。 说明: 1.工具类使用google Gson,有兴趣的可以使用其他json序列号工具改造。大概流程都一样 private static final String JSON_ARRAY_FORMAT...

    在项目使用中,经常使用json的反序列化获取某个值,如果某个值的路径比较深,除了编写工作量变大和风险扩大外,还有就是代码不够整洁。抽空写了个根据地址寻址json内容中的某个值的工具类。

    说明:

    1.工具类使用google Gson,有兴趣的可以使用其他json序列号工具改造。大概流程都一样

         private static final String JSON_ARRAY_FORMAT = "(.)*(\\[(\\d)+])$";
    
     /**
         * 根据路径获取json对象的值
         * 约定:
         * 路径格式:下层用点代表 数组用[index]代表
         * 举例:
         * a.b[1].c
         * [0].a.c
         * a[1].b
         * a.
         * [0]
         *
         * @param json
         * @param path
         * @return Object 如果获取不到 返回null
         */
        public static <T> T getObjectGson4Path(String json, String path, Class<T> tClass) {
            Gson gson = new Gson();
            JsonElement value4Path = getValue4Path(json, path);
            if (null == value4Path) {
                LOGGER.error("can't find value by path {} ", path);
                return null;
            }
            try {
                return gson.fromJson(value4Path, tClass);
            } catch (JsonSyntaxException e) {
                LOGGER.error("can't find format Type is {} value", tClass.getName());
                return null;
            }
        }
    
        /**
         * 根据路径获取json对象的值
         * 约定:
         * 路径格式:下层用点代表 数组用[index]代表
         * 举例:
         * a.b[1].c
         * [0].a.c
         * a[1].b
         * a.
         * [0]
         *
         * @param json
         * @param path
         * @return List 如果获取不到 返回null
         */
        public static <T> List<T> getListGson4Path(String json, String path, Class<T> tClass) {
            Gson gson = new Gson();
            JsonElement value4Path = getValue4Path(json, path);
            if (null == value4Path) {
                LOGGER.error("can't find value by path {} ", path);
                return null;
            }
            if (!value4Path.isJsonArray()) {
                throw new IllegalArgumentException("parse format not match");
            }
            JsonArray asJsonArray = value4Path.getAsJsonArray();
            ArrayList<T> objects = new ArrayList<>(asJsonArray.size());
            try {
                for (JsonElement jsonElement : asJsonArray) {
                    objects.add(gson.fromJson(value4Path, tClass));
                }
            } catch (JsonSyntaxException e) {
                LOGGER.error("can't find format Type is {} value", tClass.getName());
                return null;
            }
            return objects;
        }
    
    
        private static JsonElement getValue4Path(String content, String path) {
            LOGGER.info("content={},path={}", content, path);
            if (StringUtils.isBlank(path)) {
                LOGGER.warn("path is blank");
                return null;
            }
            if (!isJSONStr(content)) {
                LOGGER.warn("content format not json");
                return null;
            }
            JsonParser parser = new JsonParser();
            JsonElement parse = parser.parse(content);
            String[] split = path.split("\\.");
            StringBuilder stringBuilder = new StringBuilder();
            for (String s : split) {
                try {
                    parse = parseJson(parse, s, stringBuilder);
                } catch (Exception e) {
                    LOGGER.warn("can't find value ,this path is {}", path);
                    return null;
                }
            }
            return parse;
        }
    
        private static JsonElement parseJson(JsonElement jsonElement, String childPath, StringBuilder sb) {
            if (jsonElement.isJsonNull()) {
                return null;
            }
            if (StringUtils.isBlank(childPath)) {
                return jsonElement;
            }
            sb.append(".").append(childPath);
            Matcher matcher = Pattern.compile(JSON_ARRAY_FORMAT).matcher(childPath);
            if (matcher.find()) {
                String group = matcher.group(1);
                if (null == group) {
                    group = matcher.group(0);
                }
                String s = group.replaceAll("\\[", "\\\\[");
                String[] split1 = childPath.split(s);
                String key = null;
                if (null == split1 || split1.length == 0) {
                    key = "";
                } else {
                    key = split1[0];
                }
                String index = group.substring(1, group.length() - 1);
                if (StringUtils.isBlank(key)) {
                    if (!jsonElement.isJsonArray()) {
                        LOGGER.warn("can't find value by this childPath,path={}", sb.substring(1));
                        return null;
                    }
                    JsonArray asJsonArray = jsonElement.getAsJsonArray();
                    JsonElement res = asJsonArray.get(Integer.valueOf(index));
                    return res;
                } else {
                    JsonObject asJsonObject = jsonElement.getAsJsonObject();
                    JsonElement res = asJsonObject.get(key);
                    return res;
                }
            } else {
                JsonObject asJsonObject = jsonElement.getAsJsonObject();
                JsonElement res = asJsonObject.get(childPath);
                return res;
            }
    
        }
    
        public static void main(String[] args) {
            String str12 = "{\"additionJson\":{\"needPush\":true},\"id\":123456,\"date\":\"2013-4-13 12: 36: 54\"}";
            Boolean objectGson4Path12 = getObjectGson4Path(str12, "additionJson.needPush", Boolean.class);
            System.out.println(objectGson4Path12);
        }
    

     

    展开全文
  • 本文主要介绍ARM寻址方式中的堆栈寻址,感兴趣的朋友可以看看。
  • 基址寻址与变址寻址的区别

    万次阅读 多人点赞 2018-12-21 09:31:01
    基址寻址与变址寻址都类似于相对寻址,它们的有效地址EA = 基址+指令字中形式地址A。 1、基址寻址 计算公式:EA = (BR) + A 有效地址是将CPU中基址寄存器BR的内容加上指令字中形式地址A。BR的内容由操作系统决定...

    说到区别一般来讲都会有共同点。基址寻址与变址寻址都类似于相对寻址,它们的有效地址EA = 基址+指令字中形式地址A。

    1、基址寻址

    计算公式:EA = (BR) + A

    有效地址是将CPU中基址寄存器BR的内容加上指令字中形式地址A。BR的内容由操作系统决定,在程序执行过程中BR的内容不可变,而形式地址是可变的。基址寻址方式适合解决动态定位的问题。在多道程序的环境当中,操作系统根据内存空间的情况赋值给BR,一旦赋值成功就不可更改,直至用户程序结束,使得用户不必关心实际的地址而只需要关心自己的地址空间即可。

    2、变址寻址

    计算公式:EA = (IX) + A

    有效地址是将CPU中变址寄存器IX的内容加上指令字中有效地址A。其指令字的形式地址作为一个基准地址,内容不可变,而CPU中变址寄存器IX在程序执行过程中根据使用情况发生改变。这样的寻址方式非常适合于循环问题,原因在于指令的“基址”(形式地址)保持不变,使得执行循环时,只需要改变IX的内容即可(比如迭代时,不断加4)。假若使用基址寻址的方式,意味着循环过程中不断需要新的“基址”,也就是需要更多的指令字加以控制。而变址寻址只需要一条指令即可完成相关操作,可以大量缩短指令编码的长度,提高指令字的可用性。

    两种寻址方式都是解决特定应用场景的问题,它们本质上是一样的,只是表现形式的不同而已。

    展开全文
  • 本文主要简单介绍了单片机的寻址方式
  • 基址寻址与变址寻址

    万次阅读 多人点赞 2018-01-04 14:06:56
    基址寻址与变址寻址
  • 直接寻址直接的指出指令的确切操作地址。例如A Q10.0,对于指令A来说,Q10.0就是其直接操作的地址。因此,相对的,间接寻址即间接的指出指令的确切操作地址。例如A Q[MD10],这里的地址不是直接给出的,而是通过MD10...
  • 直接寻址,指令中直接放地址: MOV A, 50H 把internal ram上,地址为80H单元里的数据送进A,假设80H地址里放的数据是01,那么最后A里的数据就是01 间接寻址,地址存于寄存器中 MOV A,@R0 R0中存放的是地址值,把这...
  • 寻址空间与寻址范围

    万次阅读 多人点赞 2017-04-07 23:39:16
    寻址空间一般指的是CPU对于内存寻址的能力。通俗地说,就是能最多用到多少内存的一个问题,即能够寻址的最大容量。一般用MB和G来表示。 数据在存储器(RAM)中存放是有规律的 ,CPU在运算的时候需要把数据提取出来就...
  • 间接寻址和寄存器寻址的比较间接寻址优点 扩大了操作数的寻址范围 便于编制程序,方便地完成子程序的返回 缺点 访存次数多,执行时间长 寄存器寻址优点 无须访存,减少执行时间 指令字短,节省存储空间 基址...
  • 直接寻址、间接寻址、立即寻址,只是CPU在通过总线与内存交互时的不同交互方法,而产生的三种概念词! 对于这些寻址方式,很多人没有听说过,但是对于学习汇编的同学来说,非常熟悉,很多书中都有提到过这几种寻址...
  • 2、指令寻址与数据寻址指令寻址思维导图顺序寻址跳跃寻址数据寻址直接寻址间接寻址寄存器寻址寄存器间接寻址隐含寻址立即寻址总结偏移寻址基址寻址变址寻址相对寻址堆栈寻址比较 指令寻址 思维导图 顺序寻址 由于...
  • 寻址空间与内存寻址

    2020-05-06 01:51:30
    寻址空间: 寻址空间一般指的是CPU对于内存寻址的能力。通俗地说,就是能最多用到多少内存的一个问题。数据在存储器(RAM)中存放是有规律的 ,CPU在运算的时候需要把数据提取出来就需要知道数据存放在哪里 ,这时候...
  • 本文章区分了按字寻址和按字节寻址两种寻址方式,希望大家会从中有所收获。
  • 偏移寻址

    2020-07-27 14:34:05
    偏移寻址 1.基址寻址 2.变址寻址 3.相对寻址 4.总结
  • 立即寻址,直接寻址,间接寻址

    万次阅读 多人点赞 2017-04-10 23:17:40
    立即寻址就是指令当中自带数据,直接读取,最快; 直接寻址就是指令中存放的是地址,直接解析这个地址; 间接寻址就只指令中存放的是地址的地址,或者是存放地址的寄存器,最慢。 ...
  • 数据寻址

    2020-07-27 10:15:43
    数据寻址 1.操作数类型 2.数据寻址 3.立即寻址 4.直接寻址 5.间接寻址 5.寄存器寻址 6.寄存器间接寻址 7.隐含寻址 8.总结
  • 堆栈寻址

    2020-07-27 14:47:22
    堆栈寻址
  • 寻址寻址方式

    千次阅读 热门讨论 2016-11-05 20:09:28
    寻址方式
  • 直接寻址---直接的指出指令的确切操作地址。例如A Q10.0,对于指令A来说,Q10.0就是其直接操作的地址。因此,相对的,间接寻址即间接的指出指令的确切操作地址。例如A Q[MD10],这里的地址不是直接给出的,而是通过...
  • 寻址方式

    2020-07-09 11:41:07
    寻址方式指令寻址数据寻址 寻址方式 确定 本条指令 的 操作数地址(数据寻址) 下一条 欲执行指令 的 指令地址(指令寻址) 指令寻址 顺序 ( PC ) + 1 ----> PC 数据寻址 数据寻址有多种,需要在指令中明确...
  • 单片机什么叫位寻址?/不可位寻址
  • 指令寻址

    2020-10-21 15:47:08
    本节概览 编址 寻址 顺序寻址 :程序累加器自动+1,即指向下一条需要执行的指令的地址 跳跃寻址

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,413
精华内容 10,565
关键字:

寻址