gas/config/tc-bpf.c

   1 /* tc-bpf.c -- Assembler for the Linux eBPF.
   2    Copyright (C) 2019 Free Software Foundation, Inc.
   3    Contributed by Oracle, Inc.
   4
   5    This file is part of GAS, the GNU Assembler.
   6
   7    GAS is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3, or (at your option)
  10    any later version.
  11
  12    GAS is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GAS; see the file COPYING.  If not, write to
  19    the Free Software Foundation, 51 Franklin Street - Fifth Floor,
  20    Boston, MA 02110-1301, USA.  */
  21
  22 #include "as.h"
  23 #include "subsegs.h"
  24 #include "symcat.h"
  25 #include "opcodes/bpf-desc.h"
  26 #include "opcodes/bpf-opc.h"
  27 #include "cgen.h"
  28 #include "elf/common.h"
  29 #include "elf/bpf.h"
  30 #include "dwarf2dbg.h"
  31
  32 const char comment_chars[]        = ";";
  33 const char line_comment_chars[] = "#";
  34 const char line_separator_chars[] = "`";
  35 const char EXP_CHARS[]            = "eE";
  36 const char FLT_CHARS[]            = "fFdD";
  37
  38 /* The target specific pseudo-ops which we support.  */
  39 const pseudo_typeS md_pseudo_table[] =
  40 {
  41     { NULL,         NULL,             0 }
  42 };
  43
  44 /* ISA handling.  */
  45 static CGEN_BITSET *bpf_isa;
  46
  47 \f
  48
  49 /* Command-line options processing.  */
  50
  51 enum options
  52 {
  53   OPTION_LITTLE_ENDIAN = OPTION_MD_BASE,
  54   OPTION_BIG_ENDIAN
  55 };
  56
  57 struct option md_longopts[] =
  58 {
  59   { "EL", no_argument, NULL, OPTION_LITTLE_ENDIAN },
  60   { "EB", no_argument, NULL, OPTION_BIG_ENDIAN },
  61   { NULL,          no_argument, NULL, 0 },
  62 };
  63
  64 size_t md_longopts_size = sizeof (md_longopts);
  65
  66 const char * md_shortopts = "";
  67
  68 extern int target_big_endian;
  69
  70 /* Whether target_big_endian has been set while parsing command-line
  71    arguments.  */
  72 static int set_target_endian = 0;
  73
  74 int
  75 md_parse_option (int c, const char * arg ATTRIBUTE_UNUSED)
  76 {
  77   switch (c)
  78     {
  79     case OPTION_BIG_ENDIAN:
  80       set_target_endian = 1;
  81       target_big_endian = 1;
  82       break;
  83     case OPTION_LITTLE_ENDIAN:
  84       set_target_endian = 1;
  85       target_big_endian = 0;
  86       break;
  87     default:
  88       return 0;
  89     }
  90
  91   return 1;
  92 }
  93
  94 void
  95 md_show_usage (FILE * stream)
  96 {
  97   fprintf (stream, _("\nBPF options:\n"));
  98   fprintf (stream, _("\
  99   --EL                  generate code for a little endian machine\n\
 100   --EB                  generate code for a big endian machine\n"));
 101 }
 102
 103 \f
 104 void
 105 md_begin (void)
 106 {
 107   /* Initialize the `cgen' interface.  */
 108
 109   /* If not specified in the command line, use the host
 110      endianness.  */
 111   if (!set_target_endian)
 112     {
 113 #ifdef WORDS_BIGENDIAN
 114       target_big_endian = 1;
 115 #else
 116       target_big_endian = 0;
 117 #endif
 118     }
 119
 120   /* Set the ISA, which depends on the target endianness. */
 121   bpf_isa = cgen_bitset_create (ISA_MAX);
 122   if (target_big_endian)
 123     cgen_bitset_set (bpf_isa, ISA_EBPFBE);
 124   else
 125     cgen_bitset_set (bpf_isa, ISA_EBPFLE);
 126
 127   /* Set the machine number and endian.  */
 128   gas_cgen_cpu_desc = bpf_cgen_cpu_open (CGEN_CPU_OPEN_ENDIAN,
 129                                          target_big_endian ?
 130                                          CGEN_ENDIAN_BIG : CGEN_ENDIAN_LITTLE,
 131                                          CGEN_CPU_OPEN_ISAS,
 132                                          bpf_isa,
 133                                          CGEN_CPU_OPEN_END);
 134   bpf_cgen_init_asm (gas_cgen_cpu_desc);
 135
 136   /* This is a callback from cgen to gas to parse operands.  */
 137   cgen_set_parse_operand_fn (gas_cgen_cpu_desc, gas_cgen_parse_operand);
 138
 139   /* Set the machine type. */
 140   bfd_default_set_arch_mach (stdoutput, bfd_arch_bpf, bfd_mach_bpf);
 141 }
 142
 143 valueT
 144 md_section_align (segT segment, valueT size)
 145 {
 146   int align = bfd_get_section_alignment (stdoutput, segment);
 147
 148   return ((size + (1 << align) - 1) & -(1 << align));
 149 }
 150
 151 \f
 152 /* Functions concerning relocs.  */
 153
 154 /* The location from which a PC relative jump should be calculated,
 155    given a PC relative reloc.  */
 156
 157 long
 158 md_pcrel_from_section (fixS *fixP, segT sec)
 159 {
 160   if (fixP->fx_addsy != (symbolS *) NULL
 161       && (! S_IS_DEFINED (fixP->fx_addsy)
 162           || (S_GET_SEGMENT (fixP->fx_addsy) != sec)
 163           || S_IS_EXTERNAL (fixP->fx_addsy)
 164           || S_IS_WEAK (fixP->fx_addsy)))
 165     {
 166         /* The symbol is undefined (or is defined but not in this section).
 167          Let the linker figure it out.  */
 168       return 0;
 169     }
 170
 171   return fixP->fx_where + fixP->fx_frag->fr_address;
 172 }
 173
 174 /* Write a value out to the object file, using the appropriate endianness.  */
 175
 176 void
 177 md_number_to_chars (char * buf, valueT val, int n)
 178 {
 179   if (target_big_endian)
 180     number_to_chars_bigendian (buf, val, n);
 181   else
 182     number_to_chars_littleendian (buf, val, n);
 183 }
 184
 185 arelent *
 186 tc_gen_reloc (asection *sec, fixS *fix)
 187 {
 188   return gas_cgen_tc_gen_reloc (sec, fix);
 189 }
 190
 191 /* Return the bfd reloc type for OPERAND of INSN at fixup FIXP.  This
 192    is called when the operand is an expression that couldn't be fully
 193    resolved.  Returns BFD_RELOC_NONE if no reloc type can be found.
 194    *FIXP may be modified if desired.  */
 195
 196 bfd_reloc_code_real_type
 197 md_cgen_lookup_reloc (const CGEN_INSN *insn ATTRIBUTE_UNUSED,
 198                       const CGEN_OPERAND *operand,
 199                       fixS *fixP)
 200 {
 201   switch (operand->type)
 202     {
 203     case BPF_OPERAND_OFFSET16:
 204       return BFD_RELOC_BPF_16;
 205     case BPF_OPERAND_IMM32:
 206       return BFD_RELOC_BPF_32;
 207     case BPF_OPERAND_IMM64:
 208       return BFD_RELOC_BPF_64;
 209     case BPF_OPERAND_DISP16:
 210       fixP->fx_pcrel = 1;
 211       return BFD_RELOC_BPF_DISP16;
 212     case BPF_OPERAND_DISP32:
 213       fixP->fx_pcrel = 1;
 214       return BFD_RELOC_BPF_DISP32;
 215     default:
 216       break;
 217     }
 218   return BFD_RELOC_NONE;
 219 }
 220 \f
 221 /* *FRAGP has been relaxed to its final size, and now needs to have
 222    the bytes inside it modified to conform to the new size.
 223
 224    Called after relaxation is finished.
 225    fragP->fr_type == rs_machine_dependent.
 226    fragP->fr_subtype is the subtype of what the address relaxed to.  */
 227
 228 void
 229 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
 230                  segT sec ATTRIBUTE_UNUSED,
 231                  fragS *fragP ATTRIBUTE_UNUSED)
 232 {
 233   as_fatal (_("convert_frag called"));
 234 }
 235
 236 int
 237 md_estimate_size_before_relax (fragS *fragP ATTRIBUTE_UNUSED,
 238                                segT segment ATTRIBUTE_UNUSED)
 239 {
 240   as_fatal (_("estimate_size_before_relax called"));
 241   return 0;
 242 }
 243
 244 \f
 245 void
 246 md_apply_fix (fixS *fixP, valueT *valP, segT seg)
 247 {
 248   /* Some fixups for instructions require special attention.  This is
 249      handled in the code block below.  */
 250   if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
 251     {
 252       int opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
 253       const CGEN_OPERAND *operand = cgen_operand_lookup_by_num (gas_cgen_cpu_desc,
 254                                                                 opindex);
 255       char *where;
 256
 257       switch (operand->type)
 258         {
 259         case BPF_OPERAND_DISP32:
 260           /* eBPF supports two kind of CALL instructions: the so
 261              called pseudo calls ("bpf to bpf") and external calls
 262              ("bpf to kernel").
 263
 264              Both kind of calls use the same instruction (CALL).
 265              However, external calls are constructed by passing a
 266              constant argument to the instruction, whereas pseudo
 267              calls result from expressions involving symbols.  In
 268              practice, instructions requiring a fixup are interpreted
 269              as pseudo-calls.  If we are executing this code, this is
 270              a pseudo call.
 271
 272              The kernel expects for pseudo-calls to be annotated by
 273              having BPF_PSEUDO_CALL in the SRC field of the
 274              instruction.  But beware the infamous nibble-swapping of
 275              eBPF and take endianness into account here.
 276
 277              Note that the CALL instruction has only one operand, so
 278              this code is executed only once per instruction.  */
 279           where = fixP->fx_frag->fr_literal + fixP->fx_where;
 280           cgen_put_insn_value (gas_cgen_cpu_desc, (unsigned char *) where + 1, 8,
 281                                target_big_endian ? 0x01 : 0x10);
 282           /* Fallthrough.  */
 283         case BPF_OPERAND_DISP16:
 284           /* The PC-relative displacement fields in jump instructions
 285              shouldn't be in bytes.  Instead, they hold the number of
 286              64-bit words to the target, _minus one_.  */
 287           *valP = (((long) (*valP)) - 8) / 8;
 288           break;
 289         default:
 290           break;
 291         }
 292     }
 293
 294   /* And now invoke CGEN's handler, which will eventually install
 295      *valP into the corresponding operand.  */
 296   gas_cgen_md_apply_fix (fixP, valP, seg);
 297 }
 298
 299 void
 300 md_assemble (char *str)
 301 {
 302   const CGEN_INSN *insn;
 303   char *errmsg;
 304   CGEN_FIELDS fields;
 305
 306 #if CGEN_INT_INSN_P
 307   CGEN_INSN_INT buffer[CGEN_MAX_INSN_SIZE / sizeof (CGEN_INT_INSN_P)];
 308 #else
 309   unsigned char buffer[CGEN_MAX_INSN_SIZE];
 310   memset (buffer, 0, CGEN_MAX_INSN_SIZE); /* XXX to remove when CGEN
 311                                              is fixed to handle
 312                                              opcodes-in-words
 313                                              properly.  */
 314 #endif
 315
 316   gas_cgen_init_parse ();
 317   insn = bpf_cgen_assemble_insn (gas_cgen_cpu_desc, str, &fields,
 318                                   buffer, &errmsg);
 319
 320   if (insn == NULL)
 321     {
 322       as_bad ("%s", errmsg);
 323       return;
 324     }
 325
 326   gas_cgen_finish_insn (insn, buffer, CGEN_FIELDS_BITSIZE (&fields),
 327                         0, /* zero to ban relaxable insns.  */
 328                         NULL); /* NULL so results not returned here.  */
 329 }
 330
 331 void
 332 md_operand (expressionS *expressionP)
 333 {
 334   gas_cgen_md_operand (expressionP);
 335 }
 336
 337
 338 symbolS *
 339 md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
 340 {
 341   return NULL;
 342 }
 343
 344 \f
 345 /* Turn a string in input_line_pointer into a floating point constant
 346    of type TYPE, and store the appropriate bytes in *LITP.  The number
 347    of LITTLENUMS emitted is stored in *SIZEP.  An error message is
 348    returned, or NULL on OK.  */
 349
 350 const char *
 351 md_atof (int type, char *litP, int *sizeP)
 352 {
 353   return ieee_md_atof (type, litP, sizeP, FALSE);
 354 }