tools/objtool/orc_gen.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright (C) 2017 Josh Poimboeuf <jpoimboe@redhat.com>
   4  */
   5
   6 #include <stdlib.h>
   7 #include <string.h>
   8
   9 #include "orc.h"
  10 #include "check.h"
  11 #include "warn.h"
  12
  13 int create_orc(struct objtool_file *file)
  14 {
  15         struct instruction *insn;
  16
  17         for_each_insn(file, insn) {
  18                 struct orc_entry *orc = &insn->orc;
  19                 struct cfi_reg *cfa = &insn->state.cfa;
  20                 struct cfi_reg *bp = &insn->state.regs[CFI_BP];
  21
  22                 orc->end = insn->state.end;
  23
  24                 if (cfa->base == CFI_UNDEFINED) {
  25                         orc->sp_reg = ORC_REG_UNDEFINED;
  26                         continue;
  27                 }
  28
  29                 switch (cfa->base) {
  30                 case CFI_SP:
  31                         orc->sp_reg = ORC_REG_SP;
  32                         break;
  33                 case CFI_SP_INDIRECT:
  34                         orc->sp_reg = ORC_REG_SP_INDIRECT;
  35                         break;
  36                 case CFI_BP:
  37                         orc->sp_reg = ORC_REG_BP;
  38                         break;
  39                 case CFI_BP_INDIRECT:
  40                         orc->sp_reg = ORC_REG_BP_INDIRECT;
  41                         break;
  42                 case CFI_R10:
  43                         orc->sp_reg = ORC_REG_R10;
  44                         break;
  45                 case CFI_R13:
  46                         orc->sp_reg = ORC_REG_R13;
  47                         break;
  48                 case CFI_DI:
  49                         orc->sp_reg = ORC_REG_DI;
  50                         break;
  51                 case CFI_DX:
  52                         orc->sp_reg = ORC_REG_DX;
  53                         break;
  54                 default:
  55                         WARN_FUNC("unknown CFA base reg %d",
  56                                   insn->sec, insn->offset, cfa->base);
  57                         return -1;
  58                 }
  59
  60                 switch(bp->base) {
  61                 case CFI_UNDEFINED:
  62                         orc->bp_reg = ORC_REG_UNDEFINED;
  63                         break;
  64                 case CFI_CFA:
  65                         orc->bp_reg = ORC_REG_PREV_SP;
  66                         break;
  67                 case CFI_BP:
  68                         orc->bp_reg = ORC_REG_BP;
  69                         break;
  70                 default:
  71                         WARN_FUNC("unknown BP base reg %d",
  72                                   insn->sec, insn->offset, bp->base);
  73                         return -1;
  74                 }
  75
  76                 orc->sp_offset = cfa->offset;
  77                 orc->bp_offset = bp->offset;
  78                 orc->type = insn->state.type;
  79         }
  80
  81         return 0;
  82 }
  83
  84 static int create_orc_entry(struct elf *elf, struct section *u_sec, struct section *ip_relasec,
  85                                 unsigned int idx, struct section *insn_sec,
  86                                 unsigned long insn_off, struct orc_entry *o)
  87 {
  88         struct orc_entry *orc;
  89         struct rela *rela;
  90
  91         if (!insn_sec->sym) {
  92                 WARN("missing symbol for section %s", insn_sec->name);
  93                 return -1;
  94         }
  95
  96         /* populate ORC data */
  97         orc = (struct orc_entry *)u_sec->data->d_buf + idx;
  98         memcpy(orc, o, sizeof(*orc));
  99
 100         /* populate rela for ip */
 101         rela = malloc(sizeof(*rela));
 102         if (!rela) {
 103                 perror("malloc");
 104                 return -1;
 105         }
 106         memset(rela, 0, sizeof(*rela));
 107
 108         rela->sym = insn_sec->sym;
 109         rela->addend = insn_off;
 110         rela->type = R_X86_64_PC32;
 111         rela->offset = idx * sizeof(int);
 112         rela->sec = ip_relasec;
 113
 114         list_add_tail(&rela->list, &ip_relasec->rela_list);
 115         hash_add(elf->rela_hash, &rela->hash, rela_hash(rela));
 116
 117         return 0;
 118 }
 119
 120 int create_orc_sections(struct objtool_file *file)
 121 {
 122         struct instruction *insn, *prev_insn;
 123         struct section *sec, *u_sec, *ip_relasec;
 124         unsigned int idx;
 125
 126         struct orc_entry empty = {
 127                 .sp_reg = ORC_REG_UNDEFINED,
 128                 .bp_reg  = ORC_REG_UNDEFINED,
 129                 .type    = ORC_TYPE_CALL,
 130         };
 131
 132         sec = find_section_by_name(file->elf, ".orc_unwind");
 133         if (sec) {
 134                 WARN("file already has .orc_unwind section, skipping");
 135                 return -1;
 136         }
 137
 138         /* count the number of needed orcs */
 139         idx = 0;
 140         for_each_sec(file, sec) {
 141                 if (!sec->text)
 142                         continue;
 143
 144                 prev_insn = NULL;
 145                 sec_for_each_insn(file, sec, insn) {
 146                         if (!prev_insn ||
 147                             memcmp(&insn->orc, &prev_insn->orc,
 148                                    sizeof(struct orc_entry))) {
 149                                 idx++;
 150                         }
 151                         prev_insn = insn;
 152                 }
 153
 154                 /* section terminator */
 155                 if (prev_insn)
 156                         idx++;
 157         }
 158         if (!idx)
 159                 return -1;
 160
 161
 162         /* create .orc_unwind_ip and .rela.orc_unwind_ip sections */
 163         sec = elf_create_section(file->elf, ".orc_unwind_ip", sizeof(int), idx);
 164         if (!sec)
 165                 return -1;
 166
 167         ip_relasec = elf_create_rela_section(file->elf, sec);
 168         if (!ip_relasec)
 169                 return -1;
 170
 171         /* create .orc_unwind section */
 172         u_sec = elf_create_section(file->elf, ".orc_unwind",
 173                                    sizeof(struct orc_entry), idx);
 174
 175         /* populate sections */
 176         idx = 0;
 177         for_each_sec(file, sec) {
 178                 if (!sec->text)
 179                         continue;
 180
 181                 prev_insn = NULL;
 182                 sec_for_each_insn(file, sec, insn) {
 183                         if (!prev_insn || memcmp(&insn->orc, &prev_insn->orc,
 184                                                  sizeof(struct orc_entry))) {
 185
 186                                 if (create_orc_entry(file->elf, u_sec, ip_relasec, idx,
 187                                                      insn->sec, insn->offset,
 188                                                      &insn->orc))
 189                                         return -1;
 190
 191                                 idx++;
 192                         }
 193                         prev_insn = insn;
 194                 }
 195
 196                 /* section terminator */
 197                 if (prev_insn) {
 198                         if (create_orc_entry(file->elf, u_sec, ip_relasec, idx,
 199                                              prev_insn->sec,
 200                                              prev_insn->offset + prev_insn->len,
 201                                              &empty))
 202                                 return -1;
 203
 204                         idx++;
 205                 }
 206         }
 207
 208         if (elf_rebuild_rela_section(ip_relasec))
 209                 return -1;
 210
 211         return 0;
 212 }