?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* config/tc-hppa.c (CHECK_FIELD_WHERE): Define.
[binutils.git] / bfd / elf32-openrisc.c
blob54fd69c69995d094070aebf0d005e14957bca817
1 /* OpenRISC-specific support for 32-bit ELF.
2 Copyright (C) 2001 Free Software Foundation, Inc.
3 Contributed by Johan Rydberg, jrydberg@opencores.org
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program 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 2 of the License, or
10 (at your option) any later version.
11
12 This program 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 this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20
21 #include "bfd.h"
22 #include "sysdep.h"
23 #include "libbfd.h"
24 #include "elf-bfd.h"
25 #include "elf/openrisc.h"
26 #include "libiberty.h"
27
28 /* Forward declarations. */
29
30 static reloc_howto_type *openrisc_reloc_type_lookup
31 PARAMS ((bfd * , bfd_reloc_code_real_type));
32 static void openrisc_info_to_howto_rela
33 PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
34 static boolean openrisc_elf_relocate_section
35 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
36 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
37 static bfd_reloc_status_type openrisc_final_link_relocate
38 PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *,
39 Elf_Internal_Rela *, bfd_vma));
40 static boolean openrisc_elf_gc_sweep_hook
41 PARAMS ((bfd *, struct bfd_link_info *, asection *,
42 const Elf_Internal_Rela *));
43 static asection *openrisc_elf_gc_mark_hook
44 PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *,
45 struct elf_link_hash_entry *, Elf_Internal_Sym *));
46
47
48 static reloc_howto_type openrisc_elf_howto_table[] =
49 {
50 /* This reloc does nothing. */
51 HOWTO (R_OPENRISC_NONE, /* type */
52 0, /* rightshift */
53 2, /* size (0 = byte, 1 = short, 2 = long) */
54 32, /* bitsize */
55 false, /* pc_relative */
56 0, /* bitpos */
57 complain_overflow_bitfield, /* complain_on_overflow */
58 bfd_elf_generic_reloc, /* special_function */
59 "R_OPENRISC_NONE", /* name */
60 false, /* partial_inplace */
61 0, /* src_mask */
62 0, /* dst_mask */
63 false), /* pcrel_offset */
64
65 /* A PC relative 26 bit relocation, right shifted by 2. */
66 HOWTO (R_OPENRISC_INSN_REL_26, /* type */
67 2, /* rightshift */
68 2, /* size (0 = byte, 1 = short, 2 = long) */
69 26, /* bitsize */
70 true, /* pc_relative */
71 0, /* bitpos */
72 complain_overflow_signed, /* complain_on_overflow */
73 bfd_elf_generic_reloc, /* special_function */
74 "R_OPENRISC_INSN_REL_26", /* name */
75 false, /* partial_inplace */
76 0x00000000, /* src_mask */
77 0x03ffffff, /* dst_mask */
78 false), /* pcrel_offset */
79
80 /* A absolute 26 bit relocation, right shifted by 2. */
81 HOWTO (R_OPENRISC_INSN_ABS_26, /* type */
82 2, /* rightshift */
83 2, /* size (0 = byte, 1 = short, 2 = long) */
84 26, /* bitsize */
85 false, /* pc_relative */
86 0, /* bitpos */
87 complain_overflow_signed, /* complain_on_overflow */
88 bfd_elf_generic_reloc, /* special_function */
89 "R_OPENRISC_INSN_ABS_26", /* name */
90 false, /* partial_inplace */
91 0x00000000, /* src_mask */
92 0x03ffffff, /* dst_mask */
93 false), /* pcrel_offset */
94
95 HOWTO (R_OPENRISC_LO_16_IN_INSN, /* type */
96 0, /* rightshift */
97 1, /* size (0 = byte, 1 = short, 2 = long) */
98 16, /* bitsize */
99 false, /* pc_relative */
100 0, /* bitpos */
101 complain_overflow_dont, /* complain_on_overflow */
102 bfd_elf_generic_reloc, /* special_function */
103 "R_OPENRISC_LO_16_IN_INSN", /* name */
104 false, /* partial_inplace */
105 0, /* src_mask */
106 0x0000ffff, /* dst_mask */
107 false), /* pcrel_offset */
108
109 HOWTO (R_OPENRISC_HI_16_IN_INSN, /* type */
110 16, /* rightshift */
111 1, /* size (0 = byte, 1 = short, 2 = long) */
112 16, /* bitsize */
113 false, /* pc_relative */
114 0, /* bitpos */
115 complain_overflow_dont, /* complain_on_overflow */
116 bfd_elf_generic_reloc, /* special_function */
117 "R_OPENRISC_HI_16_IN_INSN", /* name */
118 false, /* partial_inplace */
119 0, /* src_mask */
120 0x0000ffff, /* dst_mask */
121 false), /* pcrel_offset */
122
123 /* An 8 bit absolute relocation. */
124 HOWTO (R_OPENRISC_8, /* type */
125 0, /* rightshift */
126 0, /* size (0 = byte, 1 = short, 2 = long) */
127 8, /* bitsize */
128 false, /* pc_relative */
129 0, /* bitpos */
130 complain_overflow_bitfield, /* complain_on_overflow */
131 bfd_elf_generic_reloc, /* special_function */
132 "R_OPENRISC_8", /* name */
133 true, /* partial_inplace */
134 0x0000, /* src_mask */
135 0x00ff, /* dst_mask */
136 false), /* pcrel_offset */
137
138 /* A 16 bit absolute relocation. */
139 HOWTO (R_OPENRISC_16, /* type */
140 0, /* rightshift */
141 1, /* size (0 = byte, 1 = short, 2 = long) */
142 16, /* bitsize */
143 false, /* pc_relative */
144 0, /* bitpos */
145 complain_overflow_bitfield, /* complain_on_overflow */
146 bfd_elf_generic_reloc, /* special_function */
147 "R_OPENRISC_16", /* name */
148 true, /* partial_inplace */
149 0x00000000, /* src_mask */
150 0x0000ffff, /* dst_mask */
151 false), /* pcrel_offset */
152
153 /* A 32 bit absolute relocation. */
154 HOWTO (R_OPENRISC_32, /* type */
155 0, /* rightshift */
156 2, /* size (0 = byte, 1 = short, 2 = long) */
157 32, /* bitsize */
158 false, /* pc_relative */
159 0, /* bitpos */
160 complain_overflow_bitfield, /* complain_on_overflow */
161 bfd_elf_generic_reloc, /* special_function */
162 "R_OPENRISC_32", /* name */
163 true, /* partial_inplace */
164 0x00000000, /* src_mask */
165 0xffffffff, /* dst_mask */
166 false), /* pcrel_offset */
167
168 /* GNU extension to record C++ vtable hierarchy */
169 HOWTO (R_OPENRISC_GNU_VTINHERIT, /* type */
170 0, /* rightshift */
171 2, /* size (0 = byte, 1 = short, 2 = long) */
172 0, /* bitsize */
173 false, /* pc_relative */
174 0, /* bitpos */
175 complain_overflow_dont, /* complain_on_overflow */
176 NULL, /* special_function */
177 "R_OPENRISC_GNU_VTINHERIT", /* name */
178 false, /* partial_inplace */
179 0, /* src_mask */
180 0, /* dst_mask */
181 false), /* pcrel_offset */
182
183 /* GNU extension to record C++ vtable member usage */
184 HOWTO (R_OPENRISC_GNU_VTENTRY, /* type */
185 0, /* rightshift */
186 2, /* size (0 = byte, 1 = short, 2 = long) */
187 0, /* bitsize */
188 false, /* pc_relative */
189 0, /* bitpos */
190 complain_overflow_dont, /* complain_on_overflow */
191 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
192 "R_OPENRISC_GNU_VTENTRY", /* name */
193 false, /* partial_inplace */
194 0, /* src_mask */
195 0, /* dst_mask */
196 false), /* pcrel_offset */
197 };
198
199 /* Map BFD reloc types to OpenRISC ELF reloc types. */
200
201 struct openrisc_reloc_map
202 {
203 bfd_reloc_code_real_type bfd_reloc_val;
204 unsigned int openrisc_reloc_val;
205 };
206
207 static const struct openrisc_reloc_map openrisc_reloc_map[] =
208 {
209 { BFD_RELOC_NONE, R_OPENRISC_NONE },
210 { BFD_RELOC_32, R_OPENRISC_32 },
211 { BFD_RELOC_16, R_OPENRISC_16 },
212 { BFD_RELOC_8, R_OPENRISC_8 },
213 { BFD_RELOC_OPENRISC_REL_26,R_OPENRISC_INSN_REL_26 },
214 { BFD_RELOC_OPENRISC_ABS_26,R_OPENRISC_INSN_ABS_26 },
215 { BFD_RELOC_HI16, R_OPENRISC_HI_16_IN_INSN },
216 { BFD_RELOC_LO16, R_OPENRISC_LO_16_IN_INSN },
217 { BFD_RELOC_VTABLE_INHERIT, R_OPENRISC_GNU_VTINHERIT },
218 { BFD_RELOC_VTABLE_ENTRY, R_OPENRISC_GNU_VTENTRY }
219 };
220
221 static reloc_howto_type *
222 openrisc_reloc_type_lookup (abfd, code)
223 bfd * abfd ATTRIBUTE_UNUSED;
224 bfd_reloc_code_real_type code;
225 {
226 unsigned int i;
227
228 for (i = ARRAY_SIZE (openrisc_reloc_map); --i;)
229 if (openrisc_reloc_map[i].bfd_reloc_val == code)
230 return & openrisc_elf_howto_table[openrisc_reloc_map[i].
231 openrisc_reloc_val];
232
233 return NULL;
234 }
235
236 /* Set the howto pointer for an OpenRISC ELF reloc. */
237
238 static void
239 openrisc_info_to_howto_rela (abfd, cache_ptr, dst)
240 bfd * abfd ATTRIBUTE_UNUSED;
241 arelent * cache_ptr;
242 Elf32_Internal_Rela * dst;
243 {
244 unsigned int r_type;
245
246 r_type = ELF32_R_TYPE (dst->r_info);
247 BFD_ASSERT (r_type < (unsigned int) R_OPENRISC_max);
248 cache_ptr->howto = & openrisc_elf_howto_table[r_type];
249 }
250
251 /* Perform a single relocation. By default we use the standard BFD
252 routines, but a few relocs, we have to do them ourselves. */
253
254 static bfd_reloc_status_type
255 openrisc_final_link_relocate (howto, input_bfd, input_section, contents, rel,
256 relocation)
257 reloc_howto_type *howto;
258 bfd *input_bfd;
259 asection *input_section;
260 bfd_byte *contents;
261 Elf_Internal_Rela *rel;
262 bfd_vma relocation;
263 {
264 bfd_reloc_status_type r = bfd_reloc_ok;
265
266 switch (howto->type)
267 {
268 case R_OPENRISC_LO_16_IN_INSN:
269 relocation &= 0xffff;
270 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
271 contents, rel->r_offset,
272 relocation, rel->r_addend);
273 break;
274
275 default:
276 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
277 contents, rel->r_offset,
278 relocation, rel->r_addend);
279 }
280
281 return r;
282 }
283
284 /* Relocate an OpenRISC ELF section.
285 There is some attempt to make this function usable for many architectures,
286 both USE_REL and USE_RELA ['twould be nice if such a critter existed],
287 if only to serve as a learning tool.
288
289 The RELOCATE_SECTION function is called by the new ELF backend linker
290 to handle the relocations for a section.
291
292 The relocs are always passed as Rela structures; if the section
293 actually uses Rel structures, the r_addend field will always be
294 zero.
295
296 This function is responsible for adjusting the section contents as
297 necessary, and (if using Rela relocs and generating a relocateable
298 output file) adjusting the reloc addend as necessary.
299
300 This function does not have to worry about setting the reloc
301 address or the reloc symbol index.
302
303 LOCAL_SYMS is a pointer to the swapped in local symbols.
304
305 LOCAL_SECTIONS is an array giving the section in the input file
306 corresponding to the st_shndx field of each local symbol.
307
308 The global hash table entry for the global symbols can be found
309 via elf_sym_hashes (input_bfd).
310
311 When generating relocateable output, this function must handle
312 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
313 going to be the section symbol corresponding to the output
314 section, which means that the addend must be adjusted
315 accordingly. */
316
317 static boolean
318 openrisc_elf_relocate_section (output_bfd, info, input_bfd, input_section,
319 contents, relocs, local_syms, local_sections)
320 bfd *output_bfd ATTRIBUTE_UNUSED;
321 struct bfd_link_info *info;
322 bfd *input_bfd;
323 asection *input_section;
324 bfd_byte *contents;
325 Elf_Internal_Rela *relocs;
326 Elf_Internal_Sym *local_syms;
327 asection **local_sections;
328 {
329 Elf_Internal_Shdr *symtab_hdr;
330 struct elf_link_hash_entry **sym_hashes;
331 Elf_Internal_Rela *rel;
332 Elf_Internal_Rela *relend;
333
334 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
335 sym_hashes = elf_sym_hashes (input_bfd);
336 relend = relocs + input_section->reloc_count;
337
338 for (rel = relocs; rel < relend; rel++)
339 {
340 reloc_howto_type *howto;
341 unsigned long r_symndx;
342 Elf_Internal_Sym *sym;
343 asection *sec;
344 struct elf_link_hash_entry *h;
345 bfd_vma relocation;
346 bfd_reloc_status_type r;
347 const char *name = NULL;
348 int r_type;
349
350 r_type = ELF32_R_TYPE (rel->r_info);
351 r_symndx = ELF32_R_SYM (rel->r_info);
352
353 if (r_type == R_OPENRISC_GNU_VTINHERIT
354 || r_type == R_OPENRISC_GNU_VTENTRY)
355 continue;
356
357 if (info->relocateable)
358 {
359 /* This is a relocateable link. We don't have to change
360 anything, unless the reloc is against a section symbol,
361 in which case we have to adjust according to where the
362 section symbol winds up in the output section. */
363 if (r_symndx < symtab_hdr->sh_info)
364 {
365 sym = local_syms + r_symndx;
366
367 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
368 {
369 sec = local_sections[r_symndx];
370 rel->r_addend += sec->output_offset + sym->st_value;
371 }
372 }
373 continue;
374 }
375
376 if ((unsigned int) r_type >
377 (sizeof openrisc_elf_howto_table / sizeof (reloc_howto_type)))
378 abort ();
379
380 /* This is a final link. */
381 howto = openrisc_elf_howto_table + ELF32_R_TYPE (rel->r_info);
382 h = NULL;
383 sym = NULL;
384 sec = NULL;
385
386 if (r_symndx < symtab_hdr->sh_info)
387 {
388 sym = local_syms + r_symndx;
389 sec = local_sections[r_symndx];
390 relocation = (sec->output_section->vma
391 + sec->output_offset + sym->st_value);
392
393 name = bfd_elf_string_from_elf_section
394 (input_bfd, symtab_hdr->sh_link, sym->st_name);
395 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
396 }
397 else
398 {
399 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
400
401 while (h->root.type == bfd_link_hash_indirect
402 || h->root.type == bfd_link_hash_warning)
403 h = (struct elf_link_hash_entry *) h->root.u.i.link;
404
405 name = h->root.root.string;
406
407 if (h->root.type == bfd_link_hash_defined
408 || h->root.type == bfd_link_hash_defweak)
409 {
410 sec = h->root.u.def.section;
411 relocation = (h->root.u.def.value
412 + sec->output_section->vma + sec->output_offset);
413 }
414 else if (h->root.type == bfd_link_hash_undefweak)
415 {
416 relocation = 0;
417 }
418 else
419 {
420 if (!((*info->callbacks->undefined_symbol)
421 (info, h->root.root.string, input_bfd,
422 input_section, rel->r_offset, true)))
423 return false;
424 relocation = 0;
425 }
426 }
427
428 r = openrisc_final_link_relocate (howto, input_bfd, input_section,
429 contents, rel, relocation);
430
431 if (r != bfd_reloc_ok)
432 {
433 const char *msg = (const char *) NULL;
434
435 switch (r)
436 {
437 case bfd_reloc_overflow:
438 r = info->callbacks->reloc_overflow
439 (info, name, howto->name, (bfd_vma) 0,
440 input_bfd, input_section, rel->r_offset);
441 break;
442
443 case bfd_reloc_undefined:
444 r = info->callbacks->undefined_symbol
445 (info, name, input_bfd, input_section, rel->r_offset, true);
446 break;
447
448 case bfd_reloc_outofrange:
449 msg = _("internal error: out of range error");
450 break;
451
452 case bfd_reloc_notsupported:
453 msg = _("internal error: unsupported relocation error");
454 break;
455
456 case bfd_reloc_dangerous:
457 msg = _("internal error: dangerous relocation");
458 break;
459
460 default:
461 msg = _("internal error: unknown error");
462 break;
463 }
464
465 if (msg)
466 r = info->callbacks->warning
467 (info, msg, name, input_bfd, input_section, rel->r_offset);
468
469 if (!r)
470 return false;
471 }
472 }
473
474 return true;
475 }
476
477 /* Return the section that should be marked against GC for a given
478 relocation. */
479
480 static asection *
481 openrisc_elf_gc_mark_hook (abfd, info, rel, h, sym)
482 bfd *abfd ATTRIBUTE_UNUSED;
483 struct bfd_link_info *info ATTRIBUTE_UNUSED;
484 Elf_Internal_Rela *rel ATTRIBUTE_UNUSED;
485 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED;
486 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED;
487 {
488 if (h != NULL)
489 {
490 switch (ELF32_R_TYPE (rel->r_info))
491 {
492 case R_OPENRISC_GNU_VTINHERIT:
493 case R_OPENRISC_GNU_VTENTRY:
494 break;
495
496 default:
497 switch (h->root.type)
498 {
499 case bfd_link_hash_defined:
500 case bfd_link_hash_defweak:
501 return h->root.u.def.section;
502
503 case bfd_link_hash_common:
504 return h->root.u.c.p->section;
505
506 default:
507 break;
508 }
509 }
510 }
511 else
512 {
513 if (!(elf_bad_symtab (abfd)
514 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
515 && !((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
516 && sym->st_shndx != SHN_COMMON))
517 {
518 return bfd_section_from_elf_index (abfd, sym->st_shndx);
519 }
520 }
521
522 return NULL;
523 }
524
525 /* Update the got entry reference counts for the section being removed. */
526
527 static boolean
528 openrisc_elf_gc_sweep_hook (abfd, info, sec, relocs)
529 bfd *abfd ATTRIBUTE_UNUSED;
530 struct bfd_link_info *info ATTRIBUTE_UNUSED;
531 asection *sec ATTRIBUTE_UNUSED;
532 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
533 {
534 return true;
535 }
536
537 /* Look through the relocs for a section during the first phase.
538 Since we don't do .gots or .plts, we just need to consider the
539 virtual table relocs for gc. */
540
541 static boolean
542 openrisc_elf_check_relocs (abfd, info, sec, relocs)
543 bfd *abfd;
544 struct bfd_link_info *info;
545 asection *sec;
546 const Elf_Internal_Rela *relocs;
547 {
548 Elf_Internal_Shdr *symtab_hdr;
549 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
550 const Elf_Internal_Rela *rel;
551 const Elf_Internal_Rela *rel_end;
552
553 if (info->relocateable)
554 return true;
555
556 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
557 sym_hashes = elf_sym_hashes (abfd);
558 sym_hashes_end =
559 sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
560 if (!elf_bad_symtab (abfd))
561 sym_hashes_end -= symtab_hdr->sh_info;
562
563 rel_end = relocs + sec->reloc_count;
564 for (rel = relocs; rel < rel_end; rel++)
565 {
566 struct elf_link_hash_entry *h;
567 unsigned long r_symndx;
568
569 r_symndx = ELF32_R_SYM (rel->r_info);
570 if (r_symndx < symtab_hdr->sh_info)
571 h = NULL;
572 else
573 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
574
575 switch (ELF32_R_TYPE (rel->r_info))
576 {
577 /* This relocation describes the C++ object vtable hierarchy.
578 Reconstruct it for later use during GC. */
579 case R_OPENRISC_GNU_VTINHERIT:
580 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
581 return false;
582 break;
583
584 /* This relocation describes which C++ vtable entries are actually
585 used. Record for later use during GC. */
586 case R_OPENRISC_GNU_VTENTRY:
587 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
588 return false;
589 break;
590 }
591 }
592
593 return true;
594 }
595
596 /* Set the right machine number. */
597
598 static boolean
599 openrisc_elf_object_p (abfd)
600 bfd *abfd;
601 {
602 switch (elf_elfheader (abfd)->e_flags & 0xf)
603 {
604 default:
605 (void) bfd_default_set_arch_mach (abfd, bfd_arch_openrisc, 0);
606 break;
607 }
608 return true;
609 }
610
611 /* Store the machine number in the flags field. */
612
613 static void
614 openrisc_elf_final_write_processing (abfd, linker)
615 bfd *abfd;
616 boolean linker ATTRIBUTE_UNUSED;
617 {
618 unsigned long val;
619
620 switch (bfd_get_mach (abfd))
621 {
622 default:
623 val = 0;
624 break;
625 }
626
627 elf_elfheader (abfd)->e_flags &= ~0xf;
628 elf_elfheader (abfd)->e_flags |= val;
629 }
630
631
632 #define ELF_ARCH bfd_arch_openrisc
633 #define ELF_MACHINE_CODE EM_OPENRISC
634 #define ELF_MAXPAGESIZE 0x1000
635
636 #define TARGET_BIG_SYM bfd_elf32_openrisc_vec
637 #define TARGET_BIG_NAME "elf32-openrisc"
638
639 #define elf_info_to_howto_rel NULL
640 #define elf_info_to_howto openrisc_info_to_howto_rela
641 #define elf_backend_relocate_section openrisc_elf_relocate_section
642 #define elf_backend_gc_mark_hook openrisc_elf_gc_mark_hook
643 #define elf_backend_gc_sweep_hook openrisc_elf_gc_sweep_hook
644 #define elf_backend_check_relocs openrisc_elf_check_relocs
645
646 #define elf_backend_can_gc_sections 1
647
648 #define bfd_elf32_bfd_reloc_type_lookup openrisc_reloc_type_lookup
649
650 #define elf_backend_object_p openrisc_elf_object_p
651 #define elf_backend_final_write_processing openrisc_elf_final_write_processing
652
653 #include "elf32-target.h"
git-cvsimport of binutils cvsroot