从调试器中获取函数调用关系。

在我的 上一篇文章 中，我展示了如何使用 debuginfo 在当前指令指针（IP）和包含它的函数或行之间进行映射。该信息对于显示 CPU 当前正在执行的代码很有帮助。不过，如果能显示更多的有关当前函数调用栈及其正在执行语句的上下文对我们定位问题来说也是十分有助的。

例如，将空指针作为参数传递到函数中而导致非法内存访问的问题，只需查看当前执行函数行，即可发现该错误是由尝试通过空指针进行访问而触发的。但是，你真正想知道的是导致空指针访问的函数调用的完整上下文，以便确定该空指针最初是如何传递到该函数中的。此上下文信息由回溯提供，可以让你确定哪些函数可能对空指针参数负责。

有一点是肯定的：确定当前活动的函数调用栈不是一项简单的操作。

函数激活记录

现代编程语言具有局部变量，并允许函数可以调用自身的递归。此外，并发程序具有多个线程，这些线程可能同时运行相同的函数。在这些情况下，局部变量不能存储在全局位置。对于函数的每次调用，局部变量的位置必须是唯一的。它的工作原理如下：

• 每次调用函数时，编译器都会生成函数激活记录，以将局部变量存储在唯一位置。
• 为了提高效率，处理器堆栈用于存储函数激活记录。
• 当函数被调用时，会在处理器堆栈的顶部为该函数创建一条新的函数激活记录。
• 如果该函数调用另一个函数，则新的函数激活记录将放置在现有函数激活记录之上。
• 每次函数返回时，其函数激活记录都会从堆栈中删除。

函数激活记录的创建是由函数中称为“ 序言 prologue ”的代码创建的。函数激活记录的删除由函数“ 尾声 epilogue ”处理。函数体可以利用堆栈上为其预留的内存来存储临时值和局部变量。

函数激活记录的大小可以是可变的。对于某些函数，不需要空间来存储局部变量。理想情况下，函数激活记录只需要存储调用 该 函数的函数的返回地址。对于其他函数，除了返回地址之外，可能还需要大量空间来存储函数的本地数据结构。帧大小的可变导致编译器使用帧指针来跟踪函数激活帧的开始。函数序言代码具有在为当前函数创建新帧指针之前存储旧帧指针的额外任务，并且函数尾声必须恢复旧帧指针值。

函数激活记录的布局方式、调用函数的返回地址和旧帧指针是相对于当前帧指针的恒定偏移量。通过旧的帧指针，可以定位堆栈上下一个函数的激活帧。重复此过程，直到检查完所有函数激活记录为止。

优化复杂性

在代码中使用显式帧指针有几个缺点。在某些处理器上，可用的寄存器相对较少。具有显式帧指针会导致使用更多内存操作。生成的代码速度较慢，因为帧指针必须位于寄存器中。具有显式帧指针可能会限制编译器可以生成的代码，因为编译器可能不会将函数序言和尾声代码与函数体混合。

编译器的目标是尽可能生成快速代码，因此编译器通常会从生成的代码中省略帧指针。正如 Phoronix 的基准测试 所示，保留帧指针会显着降低性能。不过省略帧指针也有缺点，查找前一个调用函数的激活帧和返回地址不再是相对于帧指针的简单偏移。

调用帧信息

为了帮助生成函数回溯，编译器包含 DWARF 调用帧信息（CFI）来重建帧指针并查找返回地址。此补充信息存储在执行的 .eh_frame 部分中。与传统的函数和行位置信息的 debuginfo 不同，即使生成的可执行文件没有调试信息，或者调试信息已从文件中删除，.eh_frame 部分也位于可执行文件中。 调用帧信息对于 C++ 中的 throw-catch 等语言结构的操作至关重要。

CFI 的每个功能都有一个帧描述条目（FDE）。作为其步骤之一，回溯生成过程为当前正在检查的激活帧找到适当的 FDE。将 FDE 视为一张表，每一行代表一个或多个指令，并具有以下列：

• 规范帧地址（CFA），帧指针指向的位置
• 返回地址
• 有关其他寄存器的信息

FDE 的编码旨在最大限度地减少所需的空间量。FDE 描述了行之间的变化，而不是完全指定每一行。为了进一步压缩数据，多个 FDE 共有的起始信息被分解出来并放置在通用信息条目（CIE）中。 这使得 FDE 更加紧凑，但也需要更多的工作来计算实际的 CFA 并找到返回地址位置。该工具必须从未初始化状态启动。它逐步遍历 CIE 中的条目以获取函数条目的初始状态，然后从 FDE 的第一个条目开始继续处理 FDE，并处理操作，直到到达覆盖当前正在分析的指令指针的行。

调用帧信息使用实例

从一个简单的示例开始，其中包含将华氏温度转换为摄氏度的函数。 内联函数在 CFI 中没有条目，因此 f2c 函数的 __attribute__((noinline)) 确保编译器将 f2c 保留为真实函数。

#include <stdio.h>

int __attribute__ ((noinline)) f2c(int f)
{
    int c;
    printf("converting\n");
    c = (f-32.0) * 5.0 /9.0;
    return c;
}

int main (int argc, char *argv[])
{
    int f;
    scanf("%d", &f);
    printf ("%d Fahrenheit = %d Celsius\n",
            f, f2c(f));
    return 0;
}

编译代码：

$ gcc -O2 -g -o f2c f2c.c

.eh_frame 部分展示如下:

$ eu-readelf -S f2c |grep eh_frame
[17] .eh_frame_hdr  PROGBITS   0000000000402058 00002058 00000034  0 A  0   0  4
[18] .eh_frame      PROGBITS   0000000000402090 00002090 000000a0  0 A  0   0  8

我们可以通过以下方式获取 CFI 信息：

$ readelf --debug-dump=frames  f2c > f2c.cfi

生成 f2c 可执行文件的反汇编代码，这样你可以查找 f2c 和 main 函数：

$ objdump -d f2c > f2c.dis

在 f2c.dis 中找到以下信息来看看 f2c 和 main 函数的执行位置：

0000000000401060 <main>:
0000000000401190 <f2c>:

在许多情况下，二进制文件中的所有函数在执行函数的第一条指令之前都使用相同的 CIE 来定义初始条件。 在此示例中， f2c 和 main 都使用以下 CIE：

00000000 0000000000000014 00000000 CIE
  Version:                   1
  Augmentation:              "zR"
  Code alignment factor: 1
  Data alignment factor: -8
  Return address column: 16
  Augmentation data:         1b
  DW_CFA_def_cfa: r7 (rsp) ofs 8
  DW_CFA_offset: r16 (rip) at cfa-8
  DW_CFA_nop
  DW_CFA_nop

本示例中，不必担心增强或增强数据条目。由于 x86\_64 处理器具有 1 到 15 字节大小的可变长度指令，因此 “代码对齐因子” 设置为 1。在只有 32 位（4 字节指令）的处理器上，“代码对齐因子” 设置为 4，并且允许对一行状态信息适用的字节数进行更紧凑的编码。类似地，还有 “数据对齐因子” 来使 CFA 所在位置的调整更加紧凑。在 x86\_64 上，堆栈槽的大小为 8 个字节。

虚拟表中保存返回地址的列是 16。这在 CIE 尾部的指令中使用。 有四个 DW_CFA 指令。第一条指令 DW_CFA_def_cfa 描述了如果代码具有帧指针，如何计算帧指针将指向的规范帧地址（CFA）。 在这种情况下，CFA 是根据 r7 (rsp) 和 CFA=rsp+8 计算的。

第二条指令 DW_CFA_offset 定义从哪里获取返回地址 CFA-8 。在这种情况下，返回地址当前由堆栈指针 (rsp+8)-8 指向。CFA 从堆栈返回地址的正上方开始。

CIE 末尾的 DW_CFA_nop 进行填充以保持 DWARF 信息的对齐。 FDE 还可以在末尾添加填充以进行对齐。

在 f2c.cfi 中找到 main 的 FDE，它涵盖了从 0x40160 到（但不包括）0x401097 的 main 函数：

00000084 0000000000000014 00000088 FDE cie=00000000 pc=0000000000401060..0000000000401097
  DW_CFA_advance_loc: 4 to 0000000000401064
  DW_CFA_def_cfa_offset: 32
  DW_CFA_advance_loc: 50 to 0000000000401096
  DW_CFA_def_cfa_offset: 8
  DW_CFA_nop

在执行函数中的第一条指令之前，CIE 描述调用帧状态。然而，当处理器执行函数中的指令时，细节将会改变。 首先，指令 DW_CFA_advance_loc 和 DW_CFA_def_cfa_offset 与 main 中 401060 处的第一条指令匹配。 这会将堆栈指针向下调整 0x18（24 个字节）。 CFA 没有改变位置，但堆栈指针改变了，因此 CFA 在 401064 处的正确计算是 rsp+32。 这就是这段代码中序言指令的范围。 以下是 main 中的前几条指令：

0000000000401060 <main>:
  401060:    48 83 ec 18      sub        $0x18,%rsp
  401064:    bf 1b 20 40 00   mov        $0x40201b,%edi

DW_CFA_advance_loc 使当前行应用于函数中接下来的 50 个字节的代码，直到 401096。CFA 位于 rsp+32，直到 401092 处的堆栈调整指令完成执行。DW_CFA_def_cfa_offset 将 CFA 的计算更新为与函数入口相同。这是预期之中的，因为 401096 处的下一条指令是返回指令 ret，并将返回值从堆栈中弹出。

  401090:    31 c0        xor        %eax,%eax
  401092:    48 83 c4 18  add        $0x18,%rsp
  401096:    c3           ret

f2c 函数的 FDE 使用与 main 函数相同的 CIE，并覆盖 0x41190 到 0x4011c3 的范围：

00000068 0000000000000018 0000006c FDE cie=00000000 pc=0000000000401190..00000000004011c3
  DW_CFA_advance_loc: 1 to 0000000000401191
  DW_CFA_def_cfa_offset: 16
  DW_CFA_offset: r3 (rbx) at cfa-16
  DW_CFA_advance_loc: 29 to 00000000004011ae
  DW_CFA_def_cfa_offset: 8
  DW_CFA_nop
  DW_CFA_nop
  DW_CFA_nop

可执行文件中 f2c 函数的 objdump 输出：

0000000000401190 <f2c>:
  401190:    53                       push   %rbx
  401191:    89 fb                    mov    %edi,%ebx
  401193:    bf 10 20 40 00           mov    $0x402010,%edi
  401198:    e8 93 fe ff ff           call   401030 <puts@plt>
  40119d:    66 0f ef c0              pxor   %xmm0,%xmm0
  4011a1:    f2 0f 2a c3              cvtsi2sd %ebx,%xmm0
  4011a5:    f2 0f 5c 05 93 0e 00     subsd  0xe93(%rip),%xmm0        # 402040 <__dso_handle+0x38>
  4011ac:    00 
  4011ad:    5b                       pop    %rbx
  4011ae:    f2 0f 59 05 92 0e 00     mulsd  0xe92(%rip),%xmm0        # 402048 <__dso_handle+0x40>
  4011b5:    00 
  4011b6:    f2 0f 5e 05 92 0e 00     divsd  0xe92(%rip),%xmm0        # 402050 <__dso_handle+0x48>
  4011bd:    00 
  4011be:    f2 0f 2c c0              cvttsd2si %xmm0,%eax
  4011c2:    c3                       ret

在 f2c 的 FDE 中，函数开头有一个带有 DW_CFA_advance_loc 的单字节指令。在高级操作之后，还有两个附加操作。DW_CFA_def_cfa_offset 将 CFA 更改为 %rsp+16，DW_CFA_offset 表示 %rbx 中的初始值现在位于 CFA-16（堆栈顶部）。

查看这个 fc2 反汇编代码，可以看到 push 用于将 %rbx 保存到堆栈中。 在代码生成中省略帧指针的优点之一是可以使用 push 和 pop 等紧凑指令在堆栈中存储和检索值。 在这种情况下，保存 %rbx 是因为 %rbx 用于向 printf 函数传递参数（实际上转换为 puts 调用），但需要保存传递到函数中的 f 初始值以供后面的计算使用。4011ae 的 DW_CFA_advance_loc 29字节显示了 pop %rbx 之后的下一个状态变化，它恢复了 %rbx 的原始值。 DW_CFA_def_cfa_offset 指出 pop 将 CFA 更改为 %rsp+8。

GDB 使用调用帧信息

有了 CFI 信息，GNU 调试器（GDB） 和其他工具就可以生成准确的回溯。如果没有 CFI 信息，GDB 将很难找到返回地址。如果在 f2c.c 的第 7 行设置断点，可以看到 GDB 使用此信息。GDB在 f2c 函数中的 pop %rbx 完成且返回值不在栈顶之前放置了断点。

GDB 能够展开堆栈，并且作为额外收获还能够获取当前保存在堆栈上的参数 f：

$ gdb f2c
[...]
(gdb) break f2c.c:7
Breakpoint 1 at 0x40119d: file f2c.c, line 7.
(gdb) run
Starting program: /home/wcohen/present/202207youarehere/f2c
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib64/libthread_db.so.1".
98
converting

Breakpoint 1, f2c (f=98) at f2c.c:8
8            return c;
(gdb) where
#0  f2c (f=98) at f2c.c:8
#1  0x000000000040107e in main (argc=<optimized out>, argv=<optimized out>)
        at f2c.c:15

调用帧信息

DWARF 调用帧信息为编译器提供了一种灵活的方式来包含用于准确展开堆栈的信息。这使得可以确定当前活动的函数调用。我在本文中提供了简要介绍，但有关 DWARF 如何实现此机制的更多详细信息，请参阅 DWARF 规范。

（题图：MJ/4004d7c7-8407-40bd-8aa8-92404601dba0）

via: https://opensource.com/article/23/3/gdb-debugger-call-frame-active-function-calls

作者：Will Cohen 选题：lkxed 译者：jrglinux 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

通过编写函数来减少代码的冗余和维护。

在编程时，实际上是在定义要由计算机执行的 过程 procedure 或 例程 routine 。一个简单的类比是将计算机编程与烤面包进行比较：你一次列出了要组建工作环境的配料，然后列出了烤面包所必须采取的步骤。在编程和烘烤中，必须以不同的间隔重复执行某些步骤。例如，在烤面包中，这可能是酵母培养的过程：

STIR=100
SNOOZE=86400

function feed_culture {
  remove_from(pantry)
  add(flour, water)
  stir($STIR)
  sleep($SNOOZE)
}

然后，揉面和醒发面团：

KNEAD=600
SNOOZE=7200

function process_dough {
  remove_from(proofing_drawer)
  knead($KNEAD)
  return_to_drawer($SNOOZE)
}

在编程中，这些 子例程 subroutines 可以表示为 函数 function 。函数对程序员很重要，因为它们有助于减少代码中的冗余，从而减少了所需的维护量。例如，在以编程方式烤制面包的假想场景中，如果你需要更改面团醒发的用时，只要你之前使用函数，那么你只需更改一次用时，或使用变量（在示例代码中为 SNOOZE）或直接在处理面团的子程序中更改用时。这样可以节省你很多时间，因为你不必通过你的代码库遍历每个可能正在醒发的面团，更不用说担心错过一个。许多 bug 是由未更改的缺失的值或执行不正确的 sed 命令引起的，它们希望捕获所有可能而不必手动寻找。

在 Bash 中，无论是在编写的脚本或在独立的文件中，定义函数和使用它们一样简单。如果将函数保存到独立的文件中。那么可以将它 source 到脚本中，就像 include C 语言或 C++ 中的库或将模块 import 到 Python 中一样。要创建一个 Bash 函数，请使用关键字 function：

function foo {
# code here
}

这是一个如何在函数中使用参数的例子（有些人为设计，因此可能会更简单）：

#!/usr/bin/env bash
ARG=$1

function mimic {
  if [[ -z $ARG ]]; then
    ARG='world'
  fi
  echo "hello $ARG"
}

mimic $ARG

结果如下：

$ ./mimic
hello world
$ ./mimic everybody
hello everybody

请注意脚本的最后一行，它会执行该函数。对于编写脚本的新手来说，这是一个普遍的困惑点：函数不会自动执行。它们作为潜在的例程存在，直到被调用。

如果没有调用该函数，那么函数只是被定义，并且永远不会运行。

如果你刚接触 Bash，请尝试在包含最后一行的情况下执行示例脚本一次，然后在注释掉最后一行的情况下再次执行示例脚本。

使用函数

即使对于简单的脚本，函数也是很重要的编程概念。你越适应函数，在面对一个不仅需要声明性的命令行，还需要更多动态的复杂问题时，你就会越容易。将通用函数保存在单独的文件中还可以节省一些工作，因为它将帮助你建立常用的程序，以便你可以在项目间重用它们。看看你的脚本习惯，看是否适合使用函数。

via: https://opensource.com/article/20/6/bash-functions

作者：Seth Kenlon 选题：lujun9972 译者：geekpi 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

函数是一段可复用的代码。我们通常把重复的代码放进函数中并且在不同的地方去调用它。库是函数的集合。我们可以在库中定义经常使用的函数，这样其它脚本便可以不再重复代码而使用这些函数。

本文我们将讨论诸多关于函数的内容和一些使用技巧。为了方便演示，我将在 Ubuntu 系统上使用 Bourne Again SHell (Bash)。

调用函数

在 Shell 中调用函数和调用其它命令是一模一样的。例如，如果你的函数名称为 my_func，你可以在命令行中像下面这样执行它：

$ my_func

如果你的函数接收多个参数，那么可以像下面这样写（类似命令行参数的使用）：

$ my_func arg1 arg2 arg3

定义函数

我们可以用下面的语法去定义一个函数：

function function_name {
    Body of function
}

函数的主体可以包含任何有效的命令、循环语句和其它函数或脚本。现在让我们创建一个简单的函数，它向屏幕上显示一些消息（注：直接在命令行里写）。

function print_msg {
    echo "Hello, World"
}

现在，让我们执行这个函数：

$ print_msg
Hello, World

不出所料，这个函数在屏幕上显示了一些消息。

在上面的例子中，我们直接在终端里创建了一个函数。这个函数也可以保存到文件中。如下面的例子所示。

#!/bin/bash
function print_msg {
    echo "Hello, World"
}
print_msg

我们已经在 function.sh 文件中定义了这个函数。现在让我们执行这个脚本：

$ chmod +x function.sh
$ ./function.sh
Hello, World

你可以看到，上面的输出和之前的是一模一样的。

更多函数用法

在上一小节中我们定义了一个非常简单的函数。然而在软件开发的过程中，我们需要更多高级的函数，它可以接收多个参数并且带有返回值。在这一小节中，我们将讨论这种函数。

向函数传递参数

我们可以像调用其它命令那样给函数提供参数。我们可以在函数里使用美元 $ 符号访问到这些参数。例如，$1 表示第一个参数，$2 代表第二个参数，以此类推。

让我们修改下之前的函数，让它以参数的形式接收信息。修改后的函数就像这样：

function print_msg {
    echo "Hello $1"
}

在上面的函数中我们使用 $1 符号访问第一个参数。让我们执行这个函数：

$ print_msg "LinuxTechi"

执行完后，生成如下信息：

Hello LinuxTechi

从函数中返回数值

跟其它编程语言一样，Bash 提供了返回语句让我们可以向调用者返回一些数值。让我们举例说明：

function func_return_value {
    return 10
}

上面的函数向调用者返回 10。让我们执行这个函数：

$ func_return_value
$ echo "Value returned by function is: $?"

当你执行完，将会产生如下的输出结果：

Value returned by function is: 10

提示：在 Bash 中使用 $? 去获取函数的返回值。

函数技巧

目前我们已经对 Bash 中的函数有了一些了解。现在让我们创建一些非常有用的 Bash 函数，它们可以让我们的生活变得更加轻松。

Logger

让我们创建一个 logger 函数，它可以输出带有日期和时间的 log 信息。

function log_msg {
    echo "[`date '+ %F %T'` ]: $@"
}

执行这个函数：

$ log_msg "This is sample log message"

执行完，就会生成如下信息：

[ 2018-08-16 19:56:34 ]: This is sample log message

显示系统信息

让我们创建一个显示 GNU/Linux 信息的函数

function system_info {
    echo "### OS information ###"
    lsb_release -a

    echo
    echo "### Processor information ###"
    processor=`grep -wc "processor" /proc/cpuinfo`
    model=`grep -w "model name" /proc/cpuinfo  | awk -F: '{print $2}'`
    echo "Processor = $processor"
    echo "Model     = $model"

    echo
    echo "### Memory information ###"
    total=`grep -w "MemTotal" /proc/meminfo | awk '{print $2}'`
    free=`grep -w "MemFree" /proc/meminfo | awk '{print $2}'`
    echo "Total memory: $total kB"
    echo "Free memory : $free kB"
}

执行完后会生成以下信息：

### OS information ###
No LSB modules are available.
Distributor ID:           Ubuntu
Description:   Ubuntu 18.04.1 LTS
Release:         18.04
Codename:    bionic

### Processor information ###
Processor = 1
Model     =  Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz

### Memory information ###
Total memory: 4015648 kB
Free memory : 2915428 kB

在当前目录下查找文件或者目录

下面的函数从当前目录下查找文件或者目录：

function search {
    find . -name $1
}

让我们使用下面的命令查找 dir4 这个目录：

$ search dir4

当你执行完命令后，将会产生如下输出：

./dir1/dir2/dir3/dir4

数字时钟

下面的函数在终端里创建了一个简单的数字时钟：

function digital_clock {
    clear
    while [ 1 ]
    do
        date +'%T'
        sleep 1
        clear
    done
}

函数库

库是函数的集合。将函数定义在文件里并在当前环境中导入那个文件，这样可以创建函数库。

假设我们已经在 utils.sh 中定义好了所有函数，接着在当前的环境下使用下面的命令导入函数：

$ source utils.sh

之后你就可以像调用其它 Bash 命令那样执行库中任何的函数了。

总结

本文我们讨论了诸多可以提升效率的实用技巧。我希望这篇文章能够启发你去创造自己的技巧。

via: https://www.linuxtechi.com/define-use-functions-linux-shell-script/

作者：Pradeep Kumar 选题：lujun9972 译者：LuuMing 校对：pityonline

本文由 LCTT 原创编译，Linux中国 荣誉推出

早些时候，我们探索了 “内存中的程序之秘”，我们欣赏了在一台电脑中是如何运行我们的程序的。今天，我们去探索栈的调用，它在大多数编程语言和虚拟机中都默默地存在。在此过程中，我们将接触到一些平时很难见到的东西，像 闭包 closure 、递归、以及缓冲溢出等等。但是，我们首先要作的事情是，描绘出栈是如何运作的。

栈非常重要，因为它追踪着一个程序中运行的函数，而函数又是一个软件的重要组成部分。事实上，程序的内部操作都是非常简单的。它大部分是由函数向栈中推入数据或者从栈中弹出数据的相互调用组成的，而在堆上为数据分配内存才能在跨函数的调用中保持数据。不论是低级的 C 软件还是像 JavaScript 和 C# 这样的基于虚拟机的语言，它们都是这样的。而对这些行为的深刻理解，对排错、性能调优以及大概了解究竟发生了什么是非常重要的。

当一个函数被调用时，将会创建一个 栈帧 stack frame 去支持函数的运行。这个栈帧包含函数的局部变量和调用者传递给它的参数。这个栈帧也包含了允许被调用的函数（callee）安全返回给其调用者的内部事务信息。栈帧的精确内容和结构因处理器架构和函数调用规则而不同。在本文中我们以 Intel x86 架构和使用 C 风格的函数调用（cdecl）的栈为例。下图是一个处于栈顶部的一个单个栈帧：

在图上的场景中，有三个 CPU 寄存器进入栈。 栈指针 stack pointer esp（LCTT 译注：扩展栈指针寄存器） 指向到栈的顶部。栈的顶部总是被最后一个推入到栈且还没有弹出的东西所占据，就像现实世界中堆在一起的一叠盘子或者 100 美元大钞一样。

保存在 esp 中的地址始终在变化着，因为栈中的东西不停被推入和弹出，而它总是指向栈中的最后一个推入的东西。许多 CPU 指令的一个副作用就是自动更新 esp，离开寄存器而使用栈是行不通的。

在 Intel 的架构中，绝大多数情况下，栈的增长是向着低位内存地址的方向。因此，这个“顶部” 在包含数据的栈中是处于低位的内存地址（在这种情况下，包含的数据是 local_buffer）。注意，关于从 esp 到 local_buffer 的箭头不是随意连接的。这个箭头代表着事务：它专门指向到由 local_buffer 所拥有的第一个字节，因为，那是一个保存在 esp 中的精确地址。

第二个寄存器跟踪的栈是 ebp（LCTT 译注：扩展基址指针寄存器），它包含一个 基指针 base pointer 或者称为 帧指针 frame pointer 。它指向到一个当前运行的函数的栈帧内的固定位置，并且它为参数和局部变量的访问提供一个稳定的参考点（基址）。仅当开始或者结束调用一个函数时，ebp 的内容才会发生变化。因此，我们可以很容易地处理在栈中的从 ebp 开始偏移后的每个东西。如图所示。

不像 esp， ebp 大多数情况下是在程序代码中通过花费很少的 CPU 来进行维护的。有时候，完成抛弃 ebp 有一些性能优势，可以通过 编译标志 来做到这一点。Linux 内核就是一个这样做的示例。

最后，eax（LCTT 译注：扩展的 32 位通用数据寄存器）寄存器惯例被用来转换大多数 C 数据类型返回值给调用者。

现在，我们来看一下在我们的栈帧中的数据。下图清晰地按字节展示了字节的内容，就像你在一个调试器中所看到的内容一样，内存是从左到右、从顶部至底部增长的，如下图所示：

局部变量 local_buffer 是一个字节数组，包含一个由 null 终止的 ASCII 字符串，这是 C 程序中的一个基本元素。这个字符串可以读取自任意地方，例如，从键盘输入或者来自一个文件，它只有 7 个字节的长度。因为，local_buffer 只能保存 8 字节，所以还剩下 1 个未使用的字节。这个字节的内容是未知的，因为栈不断地推入和弹出，除了你写入的之外，你根本不会知道内存中保存了什么。这是因为 C 编译器并不为栈帧初始化内存，所以它的内容是未知的并且是随机的 —— 除非是你自己写入。这使得一些人对此很困惑。

再往上走，local1 是一个 4 字节的整数，并且你可以看到每个字节的内容。它似乎是一个很大的数字，在8 后面跟着的都是零，在这里可能会误导你。

Intel 处理器是 小端 little endian 机器，这表示在内存中的数字也是首先从小的一端开始的。因此，在一个多字节数字中，较小的部分在内存中处于最低端的地址。因为一般情况下是从左边开始显示的，这背离了我们通常的数字表示方式。我们讨论的这种从小到大的机制，使我想起《格里佛游记》：就像小人国的人们吃鸡蛋是从小头开始的一样，Intel 处理器处理它们的数字也是从字节的小端开始的。

因此，local1 事实上只保存了一个数字 8，和章鱼的腿数量一样。然而，param1 在第二个字节的位置有一个值 2，因此，它的数学上的值是 2 * 256 = 512（我们与 256 相乘是因为，每个位置值的范围都是从 0 到 255）。同时，param2 承载的数量是 1 * 256 * 256 = 65536。

这个栈帧的内部数据是由两个重要的部分组成：前一个栈帧的地址（保存的 ebp 值）和函数退出才会运行的指令的地址（返回地址）。它们一起确保了函数能够正常返回，从而使程序可以继续正常运行。

现在，我们来看一下栈帧是如何产生的，以及去建立一个它们如何共同工作的内部蓝图。首先，栈的增长是非常令人困惑的，因为它与你你预期的方式相反。例如，在栈上分配一个 8 字节，就要从 esp 减去 8，去，而减法是与增长不同的奇怪方式。

我们来看一个简单的 C 程序：

Simple Add Program - add.c

int add(int a, int b)
{
    int result = a + b;
    return result;
}

int main(int argc)
{
    int answer;
    answer = add(40, 2);
}

简单的加法程序 - add.c

假设我们在 Linux 中不使用命令行参数去运行它。当你运行一个 C 程序时，实际运行的第一行代码是在 C 运行时库里，由它来调用我们的 main 函数。下图展示了程序运行时每一步都发生了什么。每个图链接的 GDB 输出展示了内存和寄存器的状态。你也可以看到所使用的 GDB 命令，以及整个 GDB 输出。如下：

第 2 步和第 3 步，以及下面的第 4 步，都只是函数的 序言 prologue ，几乎所有的函数都是这样的：ebp 的当前值被保存到了栈的顶部，然后，将 esp 的内容拷贝到 ebp，以建立一个新的栈帧。main 的序言和其它函数一样，但是，不同之处在于，当程序启动时 ebp 被清零。

如果你去检查栈下方（右边）的整形变量（argc），你将找到更多的数据，包括指向到程序名和命令行参数（传统的 C 的 argv）、以及指向 Unix 环境变量以及它们真实的内容的指针。但是，在这里这些并不是重点，因此，继续向前调用 add()：

在 main 从 esp 减去 12 之后得到它所需的栈空间，它为 a 和 b 设置值。在内存中的值展示为十六进制，并且是小端格式，与你从调试器中看到的一样。一旦设置了参数值，main 将调用 add，并且开始运行：

现在，有一点小激动！我们进入了另一个函数序言，但这次你可以明确看到栈帧是如何从 ebp 到栈建立一个链表。这就是调试器和高级语言中的 Exception 对象如何对它们的栈进行跟踪的。当一个新帧产生时，你也可以看到更多这种典型的从 ebp 到 esp 的捕获。我们再次从 esp 中做减法得到更多的栈空间。

当 ebp 寄存器的值拷贝到内存时，这里也有一个稍微有些怪异的字节逆转。在这里发生的奇怪事情是，寄存器其实并没有字节顺序：因为对于内存，没有像寄存器那样的“增长的地址”。因此，惯例上调试器以对人类来说最自然的格式展示了寄存器的值：数位从最重要的到最不重要。因此，这个在小端机器中的副本的结果，与内存中常用的从左到右的标记法正好相反。我想用图去展示你将会看到的东西，因此有了下面的图。

在比较难懂的部分，我们增加了注释：

这是一个临时寄存器，用于帮你做加法，因此没有什么警报或者惊喜。对于加法这样的作业，栈的动作正好相反，我们留到下次再讲。

对于任何读到这里的人都应该有一个小礼物，因此，我做了一个大的图表展示了 组合到一起的所有步骤。

一旦把它们全部布置好了，看上起似乎很乏味。这些小方框给我们提供了很多帮助。事实上，在计算机科学中，这些小方框是主要的展示工具。我希望这些图片和寄存器的移动能够提供一种更直观的构想图，将栈的增长和内存的内容整合到一起。从软件的底层运作来看，我们的软件与一个简单的图灵机器差不多。

这就是我们栈探秘的第一部分，再讲一些内容之后，我们将看到构建在这个基础上的高级编程的概念。下周见！

via:https://manybutfinite.com/post/journey-to-the-stack/

作者：Gustavo Duarte 译者：qhwdw 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

在 Linux 系统下，Shell 脚本可以在各种不同的情形下帮到我们，例如展示信息，甚至 自动执行特定的系统管理任务，创建简单的命令行工具等等。

在本指南中，我们将向 Linux 新手展示如何可靠地存储自定义的 shell 脚本，解释如何编写 shell 函数和函数库，以及如何在其它的脚本中使用函数库中的函数。

Shell 脚本要存储在何处

为了在执行你自己的脚本时不必输入脚本所在位置的完整或绝对路径，脚本必须被存储在 $PATH 环境变量所定义的路径里的其中一个。

使用下面的命令可以查看你系统中的 $PATH 环境变量：

$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games

通常来说，如果在用户的家目录下存在名为 bin 的目录，你就可以将 shell 脚本存储在那个目录下，因为那个目录会自动地被包含在用户的 $PATH 环境变量中（LCTT 译注：在 Centos 6/7 下是这样的，在 Debian 8 下不是这样的，在 Ubuntu 16.04 下又是这样的)。

因此，在你的主目录下创建 bin 目录吧（当然这里也可以用来存储 Perl、Awk 或 Python 的脚本，或者其它程序）：

$ mkdir ~/bin

接着，建立一个名为 lib（libraries 的简写）的目录来存放你自己的函数库。你也可以在其中存放其它编程语言的函数库，如 C ，Python 等语言。在 lib 目录下建立另一个名为 sh 的目录，这个目录将被用来存放你的 shell 函数库：

$ mkdir -p ~/lib/sh 

创建你自己的 Shell 函数和函数库

一个 shell 函数 就是在脚本中能够完成特定任务的一组命令。它们的工作原理与其他编程语言中的过程（LCTT 译注：可能指的是类似 SQL 中的存储过程之类的吧）、子例程、函数类似。

编写一个函数的语法如下：

函数名() { 一系列的命令 } 

( LCTT 校注：在函数名前可以加上 function 关键字，但也可省略不写）

例如，你可以像下面那样在一个脚本中写一个用来显示日期的函数：

showDATE() {date;}

每当你需要显示日期时，只需调用该函数的函数名即可：

$ showDATE

简单来说 shell 函数库也是一个 shell 脚本，不过你可以在一个函数库中仅存储其它 shell 脚本中需要调用的函数。

下面展示的是在我的 ~/lib/sh 目录下一个名为 libMYFUNCS.sh 的库函数：

#!/bin/bash 
### Function to clearly list directories in PATH 
showPATH() { 
  oldifs="$IFS"   ### store old internal field separator
  IFS=:              ### specify a new internal field separator
  for DIR in $PATH<br>  do<br>     echo $DIR<br>  done
  IFS="$oldifs"    ### restore old internal field separator
}
### Function to show logged user
showUSERS() {
  echo -e “Below are the user logged on the system:\n”
  w
}
### Print a user’s details 
printUSERDETS() {
  oldifs="$IFS"    ### store old internal field separator
  IFS=:                 ### specify a new internal field separator
  read -p "Enter user name to be searched:" uname   ### read username
  echo ""
  ### read and store from a here string values into variables
  ### using : as  a  field delimiter
  read -r username pass uid gid comments homedir shell <<< "$(cat /etc/passwd | grep   "^$uname")"
  ### print out captured values
  echo -e "Username is            : $username\n"
  echo -e "User's ID                 : $uid\n"
  echo -e "User's GID              : $gid\n"
  echo -e "User's Comments    : $comments\n"
  echo -e "User's Home Dir     : $homedir\n"
  echo -e "User's Shell             : $shell\n"
  IFS="$oldifs"         ### store old internal field separator
}

保存文件并且给脚本添加执行权限。

如何从函数库中调用函数

要使用某个 lib 目录下的函数，首先你需要按照下面的形式 将包含该函数的函数库导入到需要执行的 shell 脚本中：

$ . /path/to/lib 
或
$ source /path/to/lib

（LCTT 译注：第一行的 . 和路径间必须是有空格的）

这样你就可以像下面演示的那样，在其它的脚本中使用来自 ~/lib/sh/libMYFUNCS.sh 的 printUSERDETS 函数了。

在下面的脚本中，如果要打印出某个特定用户的详细信息，你不必再一一编写代码，而只需要简单地调用已存在的函数即可。

创建一个名为 test.sh 的新文件：

#!/bin/bash 
### include lib
.  ~/lib/sh/libMYFUNCS.sh
### use function from lib
printUSERDETS
### exit script
exit 0

保存这个文件，并使得这个脚本可被执行，然后运行它：

$ chmod 755 test.sh
$ ./test.sh 

编写 shell 函数

在本文中，我们介绍了在哪里可靠地存储 shell 脚本，如何编写自己的 shell 函数和函数库，以及如何在一个普通的 shell 脚本中从函数库中调用库中的某些函数。

在之后，我们还会介绍一种相当简单直接的方式来将 Vim 配置为一个编写 Bash 脚本的 IDE（集成开发环境）。在那之前，记得要经常关注我们 ，如果能和我们分享你对这份指南的想法就更好了。

作者简介：Aaron Kili 是一名 Linux 和 F.O.S.S 爱好者、一名未来的 Linux 系统管理员、web 开发者，目前是一名 TecMint 上的内容创造者，他喜欢计算机相关的工作，并且坚信知识的分享。

via: http://www.tecmint.com/write-custom-shell-functions-and-libraries-in-linux/

作者：Aaron Kili 译者：wcnnbdk1 校对：FSSlc

本文由 LCTT 原创编译，Linux中国 荣誉推出