blocks|key|571178|text|1.为什么使用程序集？|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|571179|因为有些事情只能在程序集中完成，而且程序集会产生更快的代码。例如，“您可以访问不寻常的处理器编程模式(例如，16位模式用于接口启动、固件或英特尔PC上的遗留代码)”。阅读这里有更多的原因。|571180|2.使用什么程序集文件？|571181|来自：https://www.kernel.org/doc/Documentation/arm/README|571182|“进入内核的初始入口是通过head.S，它使用的是机器独立的代码。机器是由条目上的'r1‘值选择的，必须保持惟一。”|571183|来自https://www.ibm.com/developerworks/library/l-linuxboot/|571184|“当调用bzImage+(对于i386映像)时，您可以从start程序集例程中的./arch/i+386/boot/Head.S开始(主要流程见图3)。这个例程做一些基本的硬件设置，并调用./arch/i+386/boot/压缩/Head.S中的startup_32例程，这个例程设置了一个基本的环境(堆栈等)。并清除由符号(BSS)启动的块。然后，通过调用一个名为decompress_kernel的C函数(位于./arch+386/boot/压缩/misc.c中)对内核进行解压缩。当内核被解压缩到内存中时，它被调用。这是另一个startup_32函数，但该函数位于./arch/i+386/内核/head.S.“|571185|除了这些程序集文件之外，许多linux内核代码都使用内嵌组件。|571186|3.体系结构依赖？|571187|您是对的，它依赖于体系结构，这就是为什么linux内核代码是将移植到不同体系结构的原因。|571188|Linux移植指南|unordered-list-item|571189|支承拱表|571190|entityMap|0|LINK|mutability|MUTABLE|url|http://www.tldp.org/HOWTO/html_single/Assembly-HOWTO/|1|https://www.kernel.org/doc/Documentation/arm/README|2|https://www.ibm.com/developerworks/library/l-linuxboot/|3|http://www.ibm.com/developerworks/library/l-ia/|4|http://www.embedded.com/design/connectivity/4023297/Linux-Porting-Guide|5|http://en.wikipedia.org/wiki/List_of_Linux_supported_architectures^0|0|B|0|2D|2|0|0|0|C|0|3|1F|1|0|0|2|1J|2|0|0|Q|4|3|0|0|9|0|U|1|0|0|9|4|0|0|4|5|0^^$0|@$1|2|3|4|5|6|7|1K|8|@$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1N|8|@]|D|@$9|1O|A|1P|1|1Q]]|E|$]]|$1|H|3|I|5|6|7|1R|8|@$9|1S|A|1T|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|1U|8|@]|D|@$9|1V|A|1W|1|1X]]|E|$]]|$1|L|3|M|5|6|7|1Y|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|1Z|8|@]|D|@$9|20|A|21|1|22]]|E|$]]|$1|P|3|Q|5|6|7|23|8|@]|D|@]|E|$]]|$1|R|3|S|5|6|7|24|8|@]|D|@$9|25|A|26|1|27]]|E|$]]|$1|T|3|U|5|6|7|28|8|@$9|29|A|2A|B|C]]|D|@]|E|$]]|$1|V|3|W|5|6|7|2B|8|@$9|2C|A|2D|B|C]]|D|@]|E|$]]|$1|X|3|Y|5|Z|7|2E|8|@]|D|@$9|2F|A|2G|1|2H]]|E|$]]|$1|10|3|11|5|Z|7|2I|8|@]|D|@$9|2J|A|2K|1|2L]]|E|$]]|$1|12|3|-4|5|6|7|2M|8|@]|D|@]|E|$]]]|13|$14|$5|15|16|17|E|$18|19]]|1A|$5|15|16|17|E|$18|1B]]|1C|$5|15|16|17|E|$18|1D]]|1E|$5|15|16|17|E|$18|1F]]|1G|$5|15|16|17|E|$18|1H]]|1I|$5|15|16|17|E|$18|1J]]]]

1. Why assembly is used?

Because there are certain things then can be done only in assembly and because assembly results in a faster code. For eg, "you can get access to unusual programming modes of your processor (e.g. 16 bit mode to interface startup, firmware, or legacy code on Intel PCs)". 
Read <a href="http://www.tldp.org/HOWTO/html_single/Assembly-HOWTO/" rel="noreferrer">here</a> for more reasons.

2. What assembly file are used?

From: <a href="https://www.kernel.org/doc/Documentation/arm/README" rel="noreferrer">https://www.kernel.org/doc/Documentation/arm/README</a>

"The initial entry into the kernel is via head.S, which uses machine
 independent code. The machine is selected by the value of 'r1' on
 entry, which must be kept unique."

From <a href="https://www.ibm.com/developerworks/library/l-linuxboot/" rel="noreferrer">https://www.ibm.com/developerworks/library/l-linuxboot/</a>

"When the bzImage (for an i386 image) is invoked, you begin at ./arch/i386/boot/head.S in the start assembly routine (see Figure 3 for the major flow). This routine does some basic hardware setup and invokes the startup_32 routine in ./arch/i386/boot/compressed/head.S. This routine sets up a basic environment (stack, etc.) and clears the Block Started by Symbol (BSS). The kernel is then decompressed through a call to a C function called decompress_kernel (located in ./arch/i386/boot/compressed/misc.c). When the kernel is decompressed into memory, it is called. This is yet another startup_32 function, but this function is in ./arch/i386/kernel/head.S."

Apart from these assembly files, lot of linux kernel code has usage of <a href="http://www.ibm.com/developerworks/library/l-ia/" rel="noreferrer">inline assembly</a>.

3. Architecture dependence?

And you are right about it being architecture dependent, that's why the linux kernel code is ported to different architecture.

<ul>
<li><a href="http://www.embedded.com/design/connectivity/4023297/Linux-Porting-Guide" rel="noreferrer">Linux porting guide</a></li>
<li><a href="http://en.wikipedia.org/wiki/List_of_Linux_supported_architectures" rel="noreferrer">List of supported arch</a></li>
</ul>

blocks|key|1291973|text|Linux不是Unix的第二个版本(一般情况下也不是Unix+)。它与Unix兼容，但是Unix和Linux有着不同的历史，并且，就代码基(内核)而言，它们是完全独立的。的想法是编写一个开源的Unix。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1291974|一些较低级别的东西，如内存管理中的一些依赖于体系结构的部分，都是在组装中完成的。用于x86的旧的(但仍然可用的)+Linux内核API+int0x80是在程序集中实现的。内核中可能还有其他地方是在程序集中实现的，但我不知道还有其他地方。|1291975|在编译内核时，可以选择要针对的体系结构。根据目标，构建中包含了该体系结构的正确程序集文件。|1291976|你找不到任何东西的原因是因为你在搜索头，而不是源。从kernel.org下载一个tar球并搜索它。|1291977|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Linux is not the second version of Unix (or Unix in general). It is Unix compatible, but Unix and Linux have separate histories and, in terms of code base (of their kernels), are completely separate. Linus Torvald's idea was to write an open source Unix.

Some of the lower level things like some of the architecture dependent parts of memory management are done in assembly. The old (but still available) Linux kernel API for x86, int 0x80, is implemented in assembly. There are probably other places in the kernel that are implemented in assembly, but I don't know any others.

When you compile the kernel, you select an architecture to target. Depending on the target, the right assembly files for that architecture are included in the build.

The reason you don't find anything is because you're searching the headers, not the sources. Download a tar ball from kernel.org and search that.

blocks|key|571222|text|内核中的汇编代码通常用于无法直接从C完成的底层硬件交互，它们就像一个特定于平台的基础，由内核中用C编写的更高级别的部分使用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|571223|内核源代码树包含各种系统的汇编代码。当您为特定类型的系统(如x86+PC)编译内核时，构建过程中只包含该平台的适当组装代码。|571224|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Assembly code in the kernel is generally used for low-level hardware interaction that can't be done directly from C. They're like a platform- specific foundation that's used by higher-level parts of the kernel that are written in C.

The kernel source tree contains assembly code for a variety of systems. When you compile a kernel for a particular type of system (such as an x86 PC), only the appropriate assembly code for that platform is included in the build process.

blocks|key|571295|text|在Linux中主要用程序集编写的东西：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|571296|引导代码：引导机器并将其设置为可以开始执行C代码的状态(例如:在某些处理器上，您可能需要手动初始化缓存和TLB，在x86上必须切换到保护模式，.)|unordered-list-item|offset|length|style|BOLD|571297|中断/异常/陷阱入口点/返回：在那里您需要做非常特定于处理器的事情，例如:保存寄存器和重新启用中断，并最终恢复寄存器并正确返回用户模式。有些异常可以完全在程序集中处理。|571298|指令仿真：某些CPU模型可能不支持某些指令，可能不支持未对齐的数据访问，或者可能没有FPU。一个选项是在获取相应的异常时使用仿真。|571299|是内核映射到用户空间的虚拟库。它允许为当前CPU选择最佳的syscall序列(如果可用的话，在x86上使用sysenter/syscall而不是int+0x80+)，并在不需要上下文切换的情况下实现某些系统调用(例如：gettimeofday())。|CODE|571300|原子操作和锁：可能在将来使用对原子操作的C11支持来编写其中一些操作。|571301|将内存从/复制到用户模式：除了使用优化的副本外，还检查是否存在超出范围的访问。|571302|优化例程：内核有一些例程的优化版本，例如:加密例程、memset、clear_page、csum_copy+(校验和一次拷贝到另一个地方IP数据)，.|571303|对挂起/恢复和其他/EFI/固件的支持|571304|BPF+JIT：较新的内核包含用于BPF表达式的JIT编译器(例如，tcpdump，secmode2，.)|571305|..。|571306|为了支持不同的体系结构，Linux为其支持的每一种体系结构编写了汇编代码(重新编写)(有时，使用相同的CPU体系结构为不同平台编写了一些代码的实现)。只需查看arch/下的所有子目录|571307|entityMap^0|0|0|4|0|0|E|0|0|5|0|1H|G|20|8|31|E|0|0|7|0|0|D|0|0|4|0|0|9|0|0|7|Y|7|0|0|27|5|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|16|8|@$E|17|F|18|G|H]]|9|@]|A|$]]|$1|I|3|J|5|D|7|19|8|@$E|1A|F|1B|G|H]]|9|@]|A|$]]|$1|K|3|L|5|D|7|1C|8|@$E|1D|F|1E|G|H]]|9|@]|A|$]]|$1|M|3|N|5|D|7|1F|8|@$E|1G|F|1H|G|O]|$E|1I|F|1J|G|O]|$E|1K|F|1L|G|O]]|9|@]|A|$]]|$1|P|3|Q|5|D|7|1M|8|@$E|1N|F|1O|G|H]]|9|@]|A|$]]|$1|R|3|S|5|D|7|1P|8|@$E|1Q|F|1R|G|H]]|9|@]|A|$]]|$1|T|3|U|5|D|7|1S|8|@$E|1T|F|1U|G|H]]|9|@]|A|$]]|$1|V|3|W|5|D|7|1V|8|@$E|1W|F|1X|G|H]]|9|@]|A|$]]|$1|X|3|Y|5|D|7|1Y|8|@$E|1Z|F|20|G|H]|$E|21|F|22|G|O]]|9|@]|A|$]]|$1|Z|3|10|5|D|7|23|8|@]|9|@]|A|$]]|$1|11|3|12|5|6|7|24|8|@$E|25|F|26|G|O]]|9|@]|A|$]]|$1|13|3|-4|5|6|7|27|8|@]|9|@]|A|$]]]|14|$]]

Things written mainly in assembly in Linux:

<ul>
<li>Boot code: boots up the machine and sets it up in a state in which it can start executing C code (e.g: on some processors you may need to manually initialize caches and TLBs, on x86 you have to switch to protected mode, ...)</li>
<li>Interrupts/Exceptions/Traps entry points/returns: there you need to do very processor-specific things, e.g: saving registers and reenabling interrupts, and eventually restoring registers and properly returning to user mode. Some exceptions may be handled entirely in assembly.</li>
<li>Instruction emulation: some CPU models may not support certain instructions, may not support unaligned data access, or may not have an FPU. An option is using emulation when getting the corresponding exception.</li>
<li>VDSO: the VDSO is a virtual library that the kernel maps into userspace. It allows e.g: selecting the optimal syscall sequence for the current CPU (on x86 use <code>sysenter/syscall</code> instead of <code>int 0x80</code> if available), and implementing certain system calls without requiring a context switch (e.g: <code>gettimeofday()</code>).</li>
<li>Atomic operations and locks: Maybe in a future some of these could be written using C11 support for atomic operations.</li>
<li>Copying memory from/to user mode: Besides using an optimized copy, these check for out-of-bounds access. </li>
<li>Optimized routines: the kernel has optimized version of some routines, e.g: crypto routines, memset, clear_page, csum_copy (checksum and copy to another place IP data in one pass), ...</li>
<li>Support for suspend/resume and other ACPI/EFI/firmware thingies</li>
<li>BPF JIT: newer kernels include a JIT compiler for BPF expressions (used for example by <code>tcpdump</code>, secmode mode 2, ...)</li>
<li>...</li>
</ul>

To support different architectures, Linux has assembly code (re-)written for each architecture it supports (and sometimes, there are several implementations of some code for different platforms using the same CPU architecture). Just look at all the subdirectories under <code>arch/</code>

My question is somewhat weird but I will do my best to explain. 

Looking at the languages the linux kernel has, I got C and assembly even though I read a text that said [quote] Second iteration of Unix is written completely in C [/quote]

I thought that was misleading but when I said that kernel has assembly code I got 2 questions of the start

<ol>
<li>What assembly files are in the kernel and what's their use?</li>
<li>Assembly is architecture dependant so how can linux be installed on more than one CPU architecture </li>
</ol>

And if linux kernel is truly written completely in C than how can it get GCC needed for compiling? 

I did a complete <code>find / -name *.s</code>
and just got one assembly file (asm-offset.s) somewhere in the /usr/src/linux-headers-<code>`uname -r</code>/

Somehow I don't think that is helping with the GCC working, so how can linux work without assembly or if it uses assembly where is it and how can it be stable when it depends on the arch. 

Thanks in advance

Linux kernel assembly and logic

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我的问题有点奇怪，但我会尽力解释的。看看linux内核所使用的语言，我得到了C和程序集，尽管我读到了一段文本，其中说引用Unix的第二次迭代完全是用C /quote编写的我认为这是误导性的，但当我说内核有汇编代码时，我首先遇到了两个问题。内核中有哪些程序集文件，它们的用途是什么？程序集依赖于体系结构，因此如何在多个CP...

问Linux内核组装与逻辑
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Linux内核组装与逻辑EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Linux内核组装与逻辑
EN