kernel: start working on 3.18 support
authorRafał Miłecki <zajec5@gmail.com>
Mon, 27 Oct 2014 18:14:39 +0000 (18:14 +0000)
committerRafał Miłecki <zajec5@gmail.com>
Mon, 27 Oct 2014 18:14:39 +0000 (18:14 +0000)
This commit:
1) Copies 3.14 patches
2) Drops mainlined stuff
3) Modifies some patches to apply

Signed-off-by: Rafał Miłecki <zajec5@gmail.com>
SVN-Revision: 43093

169 files changed:
target/linux/generic/patches-3.18/000-keep_initrafs_the_default.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/102-ehci_hcd_ignore_oc.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/120-bridge_allow_receiption_on_disabled_port.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/132-mips_inline_dma_ops.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/200-fix_localversion.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/201-extra_optimization.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/202-reduce_module_size.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/203-kallsyms_uncompressed.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/204-module_strip.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/210-darwin_scripts_include.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/212-byteshift_portability.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/220-gc_sections.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/221-module_exports.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/230-openwrt_lzma_options.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/250-netfilter_depends.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/251-sound_kconfig.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/252-mv_cesa_depends.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/253-ssb_b43_default_on.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/254-textsearch_kconfig_hacks.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/255-lib80211_kconfig_hacks.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/256-crypto_add_kconfig_prompts.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/257-wireless_ext_kconfig_hack.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/258-netfilter_netlink_kconfig_hack.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/259-regmap_dynamic.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/260-crypto_test_dependencies.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/261-move_bcm963xx_tag.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/262-compressor_kconfig_hack.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/300-mips_expose_boot_raw.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/301-mips_image_cmdline_hack.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/302-mips_no_branch_likely.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/304-mips_disable_fpu.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/305-mips_module_reloc.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/306-mips_mem_functions_performance.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/309-mips_fuse_workaround.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/310-arm_module_unresolved_weak_sym.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/320-ppc4xx_optimization.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/321-powerpc_crtsavres_prereq.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/400-mtd-add-rootfs-split-support.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/401-mtd-add-support-for-different-partition-parser-types.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/402-mtd-use-typed-mtd-parsers-for-rootfs-and-firmware-split.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/403-mtd-hook-mtdsplit-to-Kbuild.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/405-mtd-add-more-helper-functions.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/406-mtd-hook-mtdsplit-into-Kbuild.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/408-mtd-old-rootfs-squashfs-splitter.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/410-mtd-move-forward-declaration-of-struct-mtd_info.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/411-mtd-partial_eraseblock_write.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/412-mtd-partial_eraseblock_unlock.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/420-mtd-redboot_space.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/430-mtd-add-myloader-partition-parser.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/431-mtd-bcm47xxpart-support-TRX-data-partition-being-UBI.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/440-block2mtd_init.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/441-block2mtd_probe.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/450-mtd-nand-allow-to-use-platform-specific-chip-fixup.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/451-mtd-nand-fix-return-code-of-nand_correct_data-function.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/460-mtd-cfi_cmdset_0002-no-erase_suspend.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/461-mtd-cfi_cmdset_0002-add-buffer-write-cmd-timeout.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/472-mtd-m25p80-add-support-for-Winbond-W25X05-flash.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/480-mtd-set-rootfs-to-be-root-dev.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/490-ubi-auto-attach-mtd-device-named-ubi-or-data-on-boot.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/491-ubi-auto-create-ubiblock-device-for-rootfs.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/492-try-auto-mounting-ubi0-rootfs-in-init-do_mounts.c.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/493-ubi-set-ROOT_DEV-to-ubiblock-rootfs-if-unset.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/500-yaffs-Kbuild-integration.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/501-yaffs-3.5-convert-to-use-kuid_t-kgid_t.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/502-yaffs-3.10-disable-proc-entry.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/503-yaffs-3.12-convert-readdir-to-iterate.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/503-yaffs-add-tags-9bytes-mount-option.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/504-yaffs-fix-compat-tags-handling.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/520-squashfs_update_xz_comp_opts.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/530-jffs2_make_lzma_available.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/531-debloat_lzma.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/532-jffs2_eofdetect.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/540-crypto-xz-decompression-support.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/541-ubifs-xz-decompression-support.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/550-ubifs-symlink-xattr-support.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/551-ubifs-fix-default-compression-selection.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/552-ubifs-respect-silent-mount-flag.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/600-netfilter_layer7_2.22.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/601-netfilter_layer7_pktmatch.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/602-netfilter_layer7_match.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/603-netfilter_layer7_2.6.36_fix.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/604-netfilter_conntrack_flush.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/610-netfilter_match_bypass_default_checks.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/611-netfilter_match_bypass_default_table.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/612-netfilter_match_reduce_memory_access.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/613-netfilter_optional_tcp_window_check.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/615-netfilter_add_xt_id_match.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/616-net_optimize_xfrm_calls.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/617-netfilter_skip_filter_sysctl.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/620-sched_esfq.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/621-sched_act_connmark.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/630-packet_socket_type.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/640-bridge_no_eap_forward.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/641-bridge_always_accept_eap.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/642-bridge_port_isolate.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/643-bridge_remove_ipv6_dependency.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/644-bridge_optimize_netfilter_hooks.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/645-bridge_multicast_to_unicast.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/650-pppoe_header_pad.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/651-wireless_mesh_header.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/652-atm_header_changes.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/653-disable_netlink_trim.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/655-increase_skb_pad.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/656-skb_reduce_truesize-helper.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/657-qdisc_reduce_truesize.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/660-fq_codel_defaults.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/661-fq_codel_keep_dropped_stats.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/662-use_fq_codel_by_default.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/663-remove_pfifo_fast.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/664-codel_fix_3_12.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/666-Add-support-for-MAP-E-FMRs-mesh-mode.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/670-ipv6-allow-rejecting-with-source-address-failed-policy.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/671-net-provide-defines-for-_POLICY_FAILED-until-all-cod.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/700-swconfig.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/701-phy_extension.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/702-phy_add_aneg_done_function.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/703-phy-add-detach-callback-to-struct-phy_driver.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/710-phy-add-mdio_register_board_info.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/720-phy_adm6996.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/721-phy_packets.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/722-phy_mvswitch.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/723-phy_ip175c.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/724-phy_ar8216.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/725-phy_rtl8306.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/726-phy_rtl8366.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/727-phy-rtl8367.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/728-phy-micrel.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/729-phy-rtl8367b.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/729-phy-tantos.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/730-phy_b53.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/731-phy_mvswitch_3.10_compilation.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/750-hostap_txpower.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/773-bgmac-add-srab-switch.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/775-bgmac-check-length-of-received-frame.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/780-igb-Fix-Null-pointer-dereference-in-igb_reset_q_vect.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/785-hso-support-0af0-9300.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/810-pci_disable_common_quirks.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/811-pci_disable_usb_common_quirks.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/820-usb_add_usb_find_device_by_name.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/830-ledtrig_morse.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/831-ledtrig_netdev.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/832-ledtrig_usbdev.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/840-rtc7301.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/841-rtc_pt7c4338.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/861-04_spi_gpio_implement_spi_delay.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/862-gpio_spi_driver.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/863-gpiommc.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/864-gpiommc_configfs_locking.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/870-hifn795x_byteswap.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/880-gateworks_system_controller.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/890-8250_optional_sysrq.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/900-slab_maxsize.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/901-debloat_sock_diag.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/902-debloat_proc.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/903-debloat_direct_io.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/910-kobject_uevent.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/911-kobject_add_broadcast_uevent.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/921-use_preinit_as_init.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/922-always-create-console-node-in-initramfs.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/930-crashlog.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/940-ocf_kbuild_integration.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/941-ocf_20120127.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/950-vm_exports.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/960-decompress_unlzo_fix.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/970-remove-unsane-filenames-from-deps_initramfs-list.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/980-arm_openwrt_machtypes.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/990-gpio_wdt.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/997-device_tree_cmdline.patch [new file with mode: 0644]
target/linux/generic/patches-3.18/998-enable_wilink_platform_without_drivers.patch [new file with mode: 0644]

diff --git a/target/linux/generic/patches-3.18/000-keep_initrafs_the_default.patch b/target/linux/generic/patches-3.18/000-keep_initrafs_the_default.patch
new file mode 100644 (file)
index 0000000..d4164ca
--- /dev/null
@@ -0,0 +1,25 @@
+Upstream changed the default rootfs to tmpfs when none has been passed
+to the kernel - this doesn't fit our purposes, so change it back.
+
+Signed-off-by: Imre Kaloz <kaloz@openwrt.org>
+
+--- a/init/do_mounts.c
++++ b/init/do_mounts.c
+@@ -623,6 +623,7 @@ int __init init_rootfs(void)
+       if (err)
+               return err;
++#if 0
+       if (IS_ENABLED(CONFIG_TMPFS) && !saved_root_name[0] &&
+               (!root_fs_names || strstr(root_fs_names, "tmpfs"))) {
+               err = shmem_init();
+@@ -630,6 +631,9 @@ int __init init_rootfs(void)
+       } else {
+               err = init_ramfs_fs();
+       }
++#else
++      err = init_ramfs_fs();
++#endif
+       if (err)
+               unregister_filesystem(&rootfs_fs_type);
diff --git a/target/linux/generic/patches-3.18/102-ehci_hcd_ignore_oc.patch b/target/linux/generic/patches-3.18/102-ehci_hcd_ignore_oc.patch
new file mode 100644 (file)
index 0000000..de087d5
--- /dev/null
@@ -0,0 +1,81 @@
+From 1e311820ec3055e3f08e687de6564692a7cec675 Mon Sep 17 00:00:00 2001
+From: Florian Fainelli <florian@openwrt.org>
+Date: Mon, 28 Jan 2013 20:06:29 +0100
+Subject: [PATCH 11/12] USB: EHCI: add ignore_oc flag to disable overcurrent
+ checking
+
+This patch adds an ignore_oc flag which can be set by EHCI controller
+not supporting or wanting to disable overcurrent checking. The EHCI
+platform data in include/linux/usb/ehci_pdriver.h is also augmented to
+take advantage of this new flag.
+
+Signed-off-by: Florian Fainelli <florian@openwrt.org>
+---
+ drivers/usb/host/ehci-hcd.c      |    2 +-
+ drivers/usb/host/ehci-hub.c      |    4 ++--
+ drivers/usb/host/ehci-platform.c |    1 +
+ drivers/usb/host/ehci.h          |    1 +
+ include/linux/usb/ehci_pdriver.h |    1 +
+ 5 files changed, 6 insertions(+), 3 deletions(-)
+
+--- a/drivers/usb/host/ehci-hcd.c
++++ b/drivers/usb/host/ehci-hcd.c
+@@ -633,7 +633,7 @@ static int ehci_run (struct usb_hcd *hcd
+               "USB %x.%x started, EHCI %x.%02x%s\n",
+               ((ehci->sbrn & 0xf0)>>4), (ehci->sbrn & 0x0f),
+               temp >> 8, temp & 0xff,
+-              ignore_oc ? ", overcurrent ignored" : "");
++              (ignore_oc || ehci->ignore_oc) ? ", overcurrent ignored" : "");
+       ehci_writel(ehci, INTR_MASK,
+                   &ehci->regs->intr_enable); /* Turn On Interrupts */
+--- a/drivers/usb/host/ehci-hub.c
++++ b/drivers/usb/host/ehci-hub.c
+@@ -632,7 +632,7 @@ ehci_hub_status_data (struct usb_hcd *hc
+        * always set, seem to clear PORT_OCC and PORT_CSC when writing to
+        * PORT_POWER; that's surprising, but maybe within-spec.
+        */
+-      if (!ignore_oc)
++      if (!ignore_oc && !ehci->ignore_oc)
+               mask = PORT_CSC | PORT_PEC | PORT_OCC;
+       else
+               mask = PORT_CSC | PORT_PEC;
+@@ -992,7 +992,7 @@ int ehci_hub_control(
+               if (temp & PORT_PEC)
+                       status |= USB_PORT_STAT_C_ENABLE << 16;
+-              if ((temp & PORT_OCC) && !ignore_oc){
++              if ((temp & PORT_OCC) && (!ignore_oc && !ehci->ignore_oc)){
+                       status |= USB_PORT_STAT_C_OVERCURRENT << 16;
+                       /*
+--- a/drivers/usb/host/ehci-platform.c
++++ b/drivers/usb/host/ehci-platform.c
+@@ -57,6 +57,7 @@ static int ehci_platform_reset(struct us
+       hcd->has_tt = pdata->has_tt;
+       ehci->has_synopsys_hc_bug = pdata->has_synopsys_hc_bug;
++      ehci->ignore_oc = pdata->ignore_oc;
+       if (pdata->pre_setup) {
+               retval = pdata->pre_setup(hcd);
+--- a/drivers/usb/host/ehci.h
++++ b/drivers/usb/host/ehci.h
+@@ -226,6 +226,7 @@ struct ehci_hcd {                  /* one per controlle
+       unsigned                frame_index_bug:1; /* MosChip (AKA NetMos) */
+       unsigned                need_oc_pp_cycle:1; /* MPC834X port power */
+       unsigned                imx28_write_fix:1; /* For Freescale i.MX28 */
++      unsigned                ignore_oc:1;
+       /* required for usb32 quirk */
+       #define OHCI_CTRL_HCFS          (3 << 6)
+--- a/include/linux/usb/ehci_pdriver.h
++++ b/include/linux/usb/ehci_pdriver.h
+@@ -45,6 +45,7 @@ struct usb_ehci_pdata {
+       unsigned        big_endian_desc:1;
+       unsigned        big_endian_mmio:1;
+       unsigned        no_io_watchdog:1;
++      unsigned        ignore_oc:1;
+       /* Turn on all power and clocks */
+       int (*power_on)(struct platform_device *pdev);
diff --git a/target/linux/generic/patches-3.18/120-bridge_allow_receiption_on_disabled_port.patch b/target/linux/generic/patches-3.18/120-bridge_allow_receiption_on_disabled_port.patch
new file mode 100644 (file)
index 0000000..d80ef18
--- /dev/null
@@ -0,0 +1,54 @@
+From: Stephen Hemminger <stephen@networkplumber.org>
+Subject: bridge: allow receiption on disabled port
+
+When an ethernet device is enslaved to a bridge, and the bridge STP
+detects loss of carrier (or operational state down), then normally
+packet receiption is blocked.
+
+This breaks control applications like WPA which maybe expecting to
+receive packets to negotiate to bring link up. The bridge needs to
+block forwarding packets from these disabled ports, but there is no
+hard requirement to not allow local packet delivery.
+
+Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
+Signed-off-by: Felix Fietkau <nbd@openwrt.org>
+
+--- a/net/bridge/br_input.c
++++ b/net/bridge/br_input.c
+@@ -146,11 +146,13 @@ EXPORT_SYMBOL_GPL(br_handle_frame_finish
+ static int br_handle_local_finish(struct sk_buff *skb)
+ {
+       struct net_bridge_port *p = br_port_get_rcu(skb->dev);
+-      u16 vid = 0;
++      if (p->state != BR_STATE_DISABLED) {
++              u16 vid = 0;
+-      /* check if vlan is allowed, to avoid spoofing */
+-      if (p->flags & BR_LEARNING && br_should_learn(p, skb, &vid))
+-              br_fdb_update(p->br, p, eth_hdr(skb)->h_source, vid, false);
++              /* check if vlan is allowed, to avoid spoofing */
++              if (p->flags & BR_LEARNING && br_should_learn(p, skb, &vid))
++                      br_fdb_update(p->br, p, eth_hdr(skb)->h_source, vid, false);
++      }
+       return 0;        /* process further */
+ }
+@@ -224,6 +226,18 @@ rx_handler_result_t br_handle_frame(stru
+ forward:
+       switch (p->state) {
++      case BR_STATE_DISABLED:
++              if (ether_addr_equal(p->br->dev->dev_addr, dest))
++                      skb->pkt_type = PACKET_HOST;
++
++              if (NF_HOOK(NFPROTO_BRIDGE, NF_BR_PRE_ROUTING, skb, skb->dev, NULL,
++                      br_handle_local_finish))
++                      break;
++
++              BR_INPUT_SKB_CB(skb)->brdev = p->br->dev;
++              br_pass_frame_up(skb);
++              break;
++
+       case BR_STATE_FORWARDING:
+               rhook = rcu_dereference(br_should_route_hook);
+               if (rhook) {
diff --git a/target/linux/generic/patches-3.18/132-mips_inline_dma_ops.patch b/target/linux/generic/patches-3.18/132-mips_inline_dma_ops.patch
new file mode 100644 (file)
index 0000000..f603db7
--- /dev/null
@@ -0,0 +1,660 @@
+--- a/arch/mips/Kconfig
++++ b/arch/mips/Kconfig
+@@ -1705,6 +1705,9 @@ config MIPS_MALTA_PM
+       bool
+       default y
++config SYS_HAS_DMA_OPS
++      bool
++
+ #
+ # CPU may reorder R->R, R->W, W->R, W->W
+ # Reordering beyond LL and SC is handled in WEAK_REORDERING_BEYOND_LLSC
+--- a/arch/mips/include/asm/dma-mapping.h
++++ b/arch/mips/include/asm/dma-mapping.h
+@@ -1,9 +1,16 @@
+ #ifndef _ASM_DMA_MAPPING_H
+ #define _ASM_DMA_MAPPING_H
++#include <linux/kmemcheck.h>
++#include <linux/bug.h>
++#include <linux/scatterlist.h>
++#include <linux/dma-debug.h>
++#include <linux/dma-attrs.h>
++
+ #include <asm/scatterlist.h>
+ #include <asm/dma-coherence.h>
+ #include <asm/cache.h>
++#include <asm/cpu-type.h>
+ #include <asm-generic/dma-coherent.h>
+ #ifndef CONFIG_SGI_IP27 /* Kludge to fix 2.6.39 build for IP27 */
+@@ -12,12 +19,48 @@
+ extern struct dma_map_ops *mips_dma_map_ops;
++void __dma_sync(struct page *page, unsigned long offset, size_t size,
++              enum dma_data_direction direction);
++void *mips_dma_alloc_coherent(struct device *dev, size_t size,
++                            dma_addr_t *dma_handle, gfp_t gfp,
++                            struct dma_attrs *attrs);
++void mips_dma_free_coherent(struct device *dev, size_t size, void *vaddr,
++                          dma_addr_t dma_handle, struct dma_attrs *attrs);
++
+ static inline struct dma_map_ops *get_dma_ops(struct device *dev)
+ {
++#ifdef CONFIG_SYS_HAS_DMA_OPS
+       if (dev && dev->archdata.dma_ops)
+               return dev->archdata.dma_ops;
+       else
+               return mips_dma_map_ops;
++#else
++      return NULL;
++#endif
++}
++
++/*
++ * Warning on the terminology - Linux calls an uncached area coherent;
++ * MIPS terminology calls memory areas with hardware maintained coherency
++ * coherent.
++ */
++
++static inline int cpu_needs_post_dma_flush(struct device *dev)
++{
++#ifndef CONFIG_SYS_HAS_CPU_R10000
++      return 0;
++#endif
++      return !plat_device_is_coherent(dev) &&
++             (boot_cpu_type() == CPU_R10000 ||
++              boot_cpu_type() == CPU_R12000 ||
++              boot_cpu_type() == CPU_BMIPS5000);
++}
++
++static inline struct page *dma_addr_to_page(struct device *dev,
++      dma_addr_t dma_addr)
++{
++      return pfn_to_page(
++              plat_dma_addr_to_phys(dev, dma_addr) >> PAGE_SHIFT);
+ }
+ static inline bool dma_capable(struct device *dev, dma_addr_t addr, size_t size)
+@@ -30,12 +73,312 @@ static inline bool dma_capable(struct de
+ static inline void dma_mark_clean(void *addr, size_t size) {}
+-#include <asm-generic/dma-mapping-common.h>
++static inline dma_addr_t dma_map_single_attrs(struct device *dev, void *ptr,
++                                            size_t size,
++                                            enum dma_data_direction dir,
++                                            struct dma_attrs *attrs)
++{
++      struct dma_map_ops *ops = get_dma_ops(dev);
++      unsigned long offset = (unsigned long)ptr & ~PAGE_MASK;
++      struct page *page = virt_to_page(ptr);
++      dma_addr_t addr;
++
++      kmemcheck_mark_initialized(ptr, size);
++      BUG_ON(!valid_dma_direction(dir));
++      if (ops) {
++              addr = ops->map_page(dev, page, offset, size, dir, attrs);
++      } else {
++              if (!plat_device_is_coherent(dev))
++                      __dma_sync(page, offset, size, dir);
++
++              addr = plat_map_dma_mem_page(dev, page) + offset;
++      }
++      debug_dma_map_page(dev, page, offset, size, dir, addr, true);
++      return addr;
++}
++
++static inline void dma_unmap_single_attrs(struct device *dev, dma_addr_t addr,
++                                        size_t size,
++                                        enum dma_data_direction dir,
++                                        struct dma_attrs *attrs)
++{
++      struct dma_map_ops *ops = get_dma_ops(dev);
++
++      BUG_ON(!valid_dma_direction(dir));
++      if (ops) {
++              ops->unmap_page(dev, addr, size, dir, attrs);
++      } else {
++              if (cpu_needs_post_dma_flush(dev))
++                      __dma_sync(dma_addr_to_page(dev, addr),
++                                 addr & ~PAGE_MASK, size, dir);
++
++              plat_unmap_dma_mem(dev, addr, size, dir);
++      }
++      debug_dma_unmap_page(dev, addr, size, dir, true);
++}
++
++static inline int dma_map_sg_attrs(struct device *dev, struct scatterlist *sg,
++                                 int nents, enum dma_data_direction dir,
++                                 struct dma_attrs *attrs)
++{
++      struct dma_map_ops *ops = get_dma_ops(dev);
++      int i, ents;
++      struct scatterlist *s;
++
++      for_each_sg(sg, s, nents, i)
++              kmemcheck_mark_initialized(sg_virt(s), s->length);
++      BUG_ON(!valid_dma_direction(dir));
++      if (ops) {
++              ents = ops->map_sg(dev, sg, nents, dir, attrs);
++      } else {
++              for_each_sg(sg, s, nents, i) {
++                      struct page *page = sg_page(s);
++
++                      if (!plat_device_is_coherent(dev))
++                              __dma_sync(page, s->offset, s->length, dir);
++#ifdef CONFIG_NEED_SG_DMA_LENGTH
++                      s->dma_length = s->length;
++#endif
++                      s->dma_address =
++                              plat_map_dma_mem_page(dev, page) + s->offset;
++              }
++              ents = nents;
++      }
++      debug_dma_map_sg(dev, sg, nents, ents, dir);
++
++      return ents;
++}
++
++static inline void dma_unmap_sg_attrs(struct device *dev, struct scatterlist *sg,
++                                    int nents, enum dma_data_direction dir,
++                                    struct dma_attrs *attrs)
++{
++      struct dma_map_ops *ops = get_dma_ops(dev);
++      struct scatterlist *s;
++      int i;
++
++      BUG_ON(!valid_dma_direction(dir));
++      debug_dma_unmap_sg(dev, sg, nents, dir);
++      if (ops) {
++              ops->unmap_sg(dev, sg, nents, dir, attrs);
++              return;
++      }
++
++      for_each_sg(sg, s, nents, i) {
++              if (!plat_device_is_coherent(dev) && dir != DMA_TO_DEVICE)
++                      __dma_sync(sg_page(s), s->offset, s->length, dir);
++              plat_unmap_dma_mem(dev, s->dma_address, s->length, dir);
++      }
++}
++
++static inline dma_addr_t dma_map_page(struct device *dev, struct page *page,
++                                    size_t offset, size_t size,
++                                    enum dma_data_direction dir)
++{
++      struct dma_map_ops *ops = get_dma_ops(dev);
++      dma_addr_t addr;
++
++      kmemcheck_mark_initialized(page_address(page) + offset, size);
++      BUG_ON(!valid_dma_direction(dir));
++      if (ops) {
++              addr = ops->map_page(dev, page, offset, size, dir, NULL);
++      } else {
++              if (!plat_device_is_coherent(dev))
++                      __dma_sync(page, offset, size, dir);
++
++              addr = plat_map_dma_mem_page(dev, page) + offset;
++      }
++      debug_dma_map_page(dev, page, offset, size, dir, addr, false);
++
++      return addr;
++}
++
++static inline void dma_unmap_page(struct device *dev, dma_addr_t addr,
++                                size_t size, enum dma_data_direction dir)
++{
++      struct dma_map_ops *ops = get_dma_ops(dev);
++
++      BUG_ON(!valid_dma_direction(dir));
++      if (ops) {
++              ops->unmap_page(dev, addr, size, dir, NULL);
++      } else {
++              if (cpu_needs_post_dma_flush(dev))
++                      __dma_sync(dma_addr_to_page(dev, addr),
++                                 addr & ~PAGE_MASK, size, dir);
++
++              plat_unmap_dma_mem(dev, addr, size, dir);
++      }
++      debug_dma_unmap_page(dev, addr, size, dir, false);
++}
++
++static inline void dma_sync_single_for_cpu(struct device *dev, dma_addr_t addr,
++                                         size_t size,
++                                         enum dma_data_direction dir)
++{
++      struct dma_map_ops *ops = get_dma_ops(dev);
++
++      BUG_ON(!valid_dma_direction(dir));
++      if (ops)
++              ops->sync_single_for_cpu(dev, addr, size, dir);
++      else if (cpu_needs_post_dma_flush(dev))
++              __dma_sync(dma_addr_to_page(dev, addr),
++                         addr & ~PAGE_MASK, size, dir);
++      debug_dma_sync_single_for_cpu(dev, addr, size, dir);
++}
++
++static inline void dma_sync_single_for_device(struct device *dev,
++                                            dma_addr_t addr, size_t size,
++                                            enum dma_data_direction dir)
++{
++      struct dma_map_ops *ops = get_dma_ops(dev);
++
++      BUG_ON(!valid_dma_direction(dir));
++      if (ops)
++              ops->sync_single_for_device(dev, addr, size, dir);
++      else if (!plat_device_is_coherent(dev))
++              __dma_sync(dma_addr_to_page(dev, addr),
++                         addr & ~PAGE_MASK, size, dir);
++      debug_dma_sync_single_for_device(dev, addr, size, dir);
++}
++
++static inline void dma_sync_single_range_for_cpu(struct device *dev,
++                                               dma_addr_t addr,
++                                               unsigned long offset,
++                                               size_t size,
++                                               enum dma_data_direction dir)
++{
++      const struct dma_map_ops *ops = get_dma_ops(dev);
++
++      BUG_ON(!valid_dma_direction(dir));
++      if (ops)
++              ops->sync_single_for_cpu(dev, addr + offset, size, dir);
++      else if (cpu_needs_post_dma_flush(dev))
++              __dma_sync(dma_addr_to_page(dev, addr + offset),
++                         (addr + offset) & ~PAGE_MASK, size, dir);
++      debug_dma_sync_single_range_for_cpu(dev, addr, offset, size, dir);
++}
++
++static inline void dma_sync_single_range_for_device(struct device *dev,
++                                                  dma_addr_t addr,
++                                                  unsigned long offset,
++                                                  size_t size,
++                                                  enum dma_data_direction dir)
++{
++      const struct dma_map_ops *ops = get_dma_ops(dev);
++
++      BUG_ON(!valid_dma_direction(dir));
++      if (ops)
++              ops->sync_single_for_device(dev, addr + offset, size, dir);
++      else if (!plat_device_is_coherent(dev))
++              __dma_sync(dma_addr_to_page(dev, addr + offset),
++                         (addr + offset) & ~PAGE_MASK, size, dir);
++      debug_dma_sync_single_range_for_device(dev, addr, offset, size, dir);
++}
++
++static inline void
++dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,
++                  int nelems, enum dma_data_direction dir)
++{
++      struct dma_map_ops *ops = get_dma_ops(dev);
++      struct scatterlist *s;
++      int i;
++
++      BUG_ON(!valid_dma_direction(dir));
++      if (ops)
++              ops->sync_sg_for_cpu(dev, sg, nelems, dir);
++      else if (cpu_needs_post_dma_flush(dev)) {
++              for_each_sg(sg, s, nelems, i)
++                      __dma_sync(sg_page(s), s->offset, s->length, dir);
++      }
++      debug_dma_sync_sg_for_cpu(dev, sg, nelems, dir);
++}
++
++static inline void
++dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg,
++                     int nelems, enum dma_data_direction dir)
++{
++      struct dma_map_ops *ops = get_dma_ops(dev);
++      struct scatterlist *s;
++      int i;
++
++      BUG_ON(!valid_dma_direction(dir));
++      if (ops)
++              ops->sync_sg_for_device(dev, sg, nelems, dir);
++      else if (!plat_device_is_coherent(dev)) {
++              for_each_sg(sg, s, nelems, i)
++                      __dma_sync(sg_page(s), s->offset, s->length, dir);
++      }
++      debug_dma_sync_sg_for_device(dev, sg, nelems, dir);
++
++}
++
++#define dma_map_single(d, a, s, r) dma_map_single_attrs(d, a, s, r, NULL)
++#define dma_unmap_single(d, a, s, r) dma_unmap_single_attrs(d, a, s, r, NULL)
++#define dma_map_sg(d, s, n, r) dma_map_sg_attrs(d, s, n, r, NULL)
++#define dma_unmap_sg(d, s, n, r) dma_unmap_sg_attrs(d, s, n, r, NULL)
++
++extern int dma_common_mmap(struct device *dev, struct vm_area_struct *vma,
++                         void *cpu_addr, dma_addr_t dma_addr, size_t size);
++
++/**
++ * dma_mmap_attrs - map a coherent DMA allocation into user space
++ * @dev: valid struct device pointer, or NULL for ISA and EISA-like devices
++ * @vma: vm_area_struct describing requested user mapping
++ * @cpu_addr: kernel CPU-view address returned from dma_alloc_attrs
++ * @handle: device-view address returned from dma_alloc_attrs
++ * @size: size of memory originally requested in dma_alloc_attrs
++ * @attrs: attributes of mapping properties requested in dma_alloc_attrs
++ *
++ * Map a coherent DMA buffer previously allocated by dma_alloc_attrs
++ * into user space.  The coherent DMA buffer must not be freed by the
++ * driver until the user space mapping has been released.
++ */
++static inline int
++dma_mmap_attrs(struct device *dev, struct vm_area_struct *vma, void *cpu_addr,
++             dma_addr_t dma_addr, size_t size, struct dma_attrs *attrs)
++{
++      struct dma_map_ops *ops = get_dma_ops(dev);
++      BUG_ON(!ops);
++      if (ops && ops->mmap)
++              return ops->mmap(dev, vma, cpu_addr, dma_addr, size, attrs);
++      return dma_common_mmap(dev, vma, cpu_addr, dma_addr, size);
++}
++
++#define dma_mmap_coherent(d, v, c, h, s) dma_mmap_attrs(d, v, c, h, s, NULL)
++
++static inline int dma_mmap_writecombine(struct device *dev, struct vm_area_struct *vma,
++                    void *cpu_addr, dma_addr_t dma_addr, size_t size)
++{
++      DEFINE_DMA_ATTRS(attrs);
++      dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs);
++      return dma_mmap_attrs(dev, vma, cpu_addr, dma_addr, size, &attrs);
++}
++
++int
++dma_common_get_sgtable(struct device *dev, struct sg_table *sgt,
++                     void *cpu_addr, dma_addr_t dma_addr, size_t size);
++
++static inline int
++dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt, void *cpu_addr,
++                    dma_addr_t dma_addr, size_t size, struct dma_attrs *attrs)
++{
++      struct dma_map_ops *ops = get_dma_ops(dev);
++      BUG_ON(!ops);
++      if (ops && ops->get_sgtable)
++              return ops->get_sgtable(dev, sgt, cpu_addr, dma_addr, size,
++                                      attrs);
++      return dma_common_get_sgtable(dev, sgt, cpu_addr, dma_addr, size);
++}
++
++#define dma_get_sgtable(d, t, v, h, s) dma_get_sgtable_attrs(d, t, v, h, s, NULL)
++
+ static inline int dma_supported(struct device *dev, u64 mask)
+ {
+       struct dma_map_ops *ops = get_dma_ops(dev);
+-      return ops->dma_supported(dev, mask);
++      if (ops)
++              return ops->dma_supported(dev, mask);
++      return plat_dma_supported(dev, mask);
+ }
+ static inline int dma_mapping_error(struct device *dev, u64 mask)
+@@ -43,7 +386,9 @@ static inline int dma_mapping_error(stru
+       struct dma_map_ops *ops = get_dma_ops(dev);
+       debug_dma_mapping_error(dev, mask);
+-      return ops->mapping_error(dev, mask);
++      if (ops)
++              return ops->mapping_error(dev, mask);
++      return 0;
+ }
+ static inline int
+@@ -74,7 +419,11 @@ static inline void *dma_alloc_attrs(stru
+       void *ret;
+       struct dma_map_ops *ops = get_dma_ops(dev);
+-      ret = ops->alloc(dev, size, dma_handle, gfp, attrs);
++      if (ops)
++              ret = ops->alloc(dev, size, dma_handle, gfp, attrs);
++      else
++              ret = mips_dma_alloc_coherent(dev, size, dma_handle, gfp,
++                                            attrs);
+       debug_dma_alloc_coherent(dev, size, *dma_handle, ret);
+@@ -89,7 +438,10 @@ static inline void dma_free_attrs(struct
+ {
+       struct dma_map_ops *ops = get_dma_ops(dev);
+-      ops->free(dev, size, vaddr, dma_handle, attrs);
++      if (ops)
++              ops->free(dev, size, vaddr, dma_handle, attrs);
++      else
++              mips_dma_free_coherent(dev, size, vaddr, dma_handle, attrs);
+       debug_dma_free_coherent(dev, size, vaddr, dma_handle);
+ }
+--- a/arch/mips/mm/dma-default.c
++++ b/arch/mips/mm/dma-default.c
+@@ -26,7 +26,7 @@
+ #ifdef CONFIG_DMA_MAYBE_COHERENT
+ int coherentio = 0;   /* User defined DMA coherency from command line. */
+-EXPORT_SYMBOL_GPL(coherentio);
++EXPORT_SYMBOL(coherentio);
+ int hw_coherentio = 0;        /* Actual hardware supported DMA coherency setting. */
+ static int __init setcoherentio(char *str)
+@@ -46,30 +46,6 @@ static int __init setnocoherentio(char *
+ early_param("nocoherentio", setnocoherentio);
+ #endif
+-static inline struct page *dma_addr_to_page(struct device *dev,
+-      dma_addr_t dma_addr)
+-{
+-      return pfn_to_page(
+-              plat_dma_addr_to_phys(dev, dma_addr) >> PAGE_SHIFT);
+-}
+-
+-/*
+- * The affected CPUs below in 'cpu_needs_post_dma_flush()' can
+- * speculatively fill random cachelines with stale data at any time,
+- * requiring an extra flush post-DMA.
+- *
+- * Warning on the terminology - Linux calls an uncached area coherent;
+- * MIPS terminology calls memory areas with hardware maintained coherency
+- * coherent.
+- */
+-static inline int cpu_needs_post_dma_flush(struct device *dev)
+-{
+-      return !plat_device_is_coherent(dev) &&
+-             (boot_cpu_type() == CPU_R10000 ||
+-              boot_cpu_type() == CPU_R12000 ||
+-              boot_cpu_type() == CPU_BMIPS5000);
+-}
+-
+ static gfp_t massage_gfp_flags(const struct device *dev, gfp_t gfp)
+ {
+       gfp_t dma_flag;
+@@ -125,8 +101,9 @@ void *dma_alloc_noncoherent(struct devic
+ }
+ EXPORT_SYMBOL(dma_alloc_noncoherent);
+-static void *mips_dma_alloc_coherent(struct device *dev, size_t size,
+-      dma_addr_t * dma_handle, gfp_t gfp, struct dma_attrs *attrs)
++void *mips_dma_alloc_coherent(struct device *dev, size_t size,
++                            dma_addr_t *dma_handle, gfp_t gfp,
++                            struct dma_attrs *attrs)
+ {
+       void *ret;
+       struct page *page = NULL;
+@@ -157,6 +134,7 @@ static void *mips_dma_alloc_coherent(str
+       return ret;
+ }
++EXPORT_SYMBOL(mips_dma_alloc_coherent);
+ void dma_free_noncoherent(struct device *dev, size_t size, void *vaddr,
+@@ -167,8 +145,8 @@ void dma_free_noncoherent(struct device
+ }
+ EXPORT_SYMBOL(dma_free_noncoherent);
+-static void mips_dma_free_coherent(struct device *dev, size_t size, void *vaddr,
+-      dma_addr_t dma_handle, struct dma_attrs *attrs)
++void mips_dma_free_coherent(struct device *dev, size_t size, void *vaddr,
++                          dma_addr_t dma_handle, struct dma_attrs *attrs)
+ {
+       unsigned long addr = (unsigned long) vaddr;
+       int order = get_order(size);
+@@ -188,6 +166,7 @@ static void mips_dma_free_coherent(struc
+       if (!dma_release_from_contiguous(dev, page, count))
+               __free_pages(page, get_order(size));
+ }
++EXPORT_SYMBOL(mips_dma_free_coherent);
+ static inline void __dma_sync_virtual(void *addr, size_t size,
+       enum dma_data_direction direction)
+@@ -216,8 +195,8 @@ static inline void __dma_sync_virtual(vo
+  * If highmem is not configured then the bulk of this loop gets
+  * optimized out.
+  */
+-static inline void __dma_sync(struct page *page,
+-      unsigned long offset, size_t size, enum dma_data_direction direction)
++void __dma_sync(struct page *page, unsigned long offset, size_t size,
++              enum dma_data_direction direction)
+ {
+       size_t left = size;
+@@ -246,108 +225,7 @@ static inline void __dma_sync(struct pag
+               left -= len;
+       } while (left);
+ }
+-
+-static void mips_dma_unmap_page(struct device *dev, dma_addr_t dma_addr,
+-      size_t size, enum dma_data_direction direction, struct dma_attrs *attrs)
+-{
+-      if (cpu_needs_post_dma_flush(dev))
+-              __dma_sync(dma_addr_to_page(dev, dma_addr),
+-                         dma_addr & ~PAGE_MASK, size, direction);
+-
+-      plat_unmap_dma_mem(dev, dma_addr, size, direction);
+-}
+-
+-static int mips_dma_map_sg(struct device *dev, struct scatterlist *sg,
+-      int nents, enum dma_data_direction direction, struct dma_attrs *attrs)
+-{
+-      int i;
+-
+-      for (i = 0; i < nents; i++, sg++) {
+-              if (!plat_device_is_coherent(dev))
+-                      __dma_sync(sg_page(sg), sg->offset, sg->length,
+-                                 direction);
+-#ifdef CONFIG_NEED_SG_DMA_LENGTH
+-              sg->dma_length = sg->length;
+-#endif
+-              sg->dma_address = plat_map_dma_mem_page(dev, sg_page(sg)) +
+-                                sg->offset;
+-      }
+-
+-      return nents;
+-}
+-
+-static dma_addr_t mips_dma_map_page(struct device *dev, struct page *page,
+-      unsigned long offset, size_t size, enum dma_data_direction direction,
+-      struct dma_attrs *attrs)
+-{
+-      if (!plat_device_is_coherent(dev))
+-              __dma_sync(page, offset, size, direction);
+-
+-      return plat_map_dma_mem_page(dev, page) + offset;
+-}
+-
+-static void mips_dma_unmap_sg(struct device *dev, struct scatterlist *sg,
+-      int nhwentries, enum dma_data_direction direction,
+-      struct dma_attrs *attrs)
+-{
+-      int i;
+-
+-      for (i = 0; i < nhwentries; i++, sg++) {
+-              if (!plat_device_is_coherent(dev) &&
+-                  direction != DMA_TO_DEVICE)
+-                      __dma_sync(sg_page(sg), sg->offset, sg->length,
+-                                 direction);
+-              plat_unmap_dma_mem(dev, sg->dma_address, sg->length, direction);
+-      }
+-}
+-
+-static void mips_dma_sync_single_for_cpu(struct device *dev,
+-      dma_addr_t dma_handle, size_t size, enum dma_data_direction direction)
+-{
+-      if (cpu_needs_post_dma_flush(dev))
+-              __dma_sync(dma_addr_to_page(dev, dma_handle),
+-                         dma_handle & ~PAGE_MASK, size, direction);
+-}
+-
+-static void mips_dma_sync_single_for_device(struct device *dev,
+-      dma_addr_t dma_handle, size_t size, enum dma_data_direction direction)
+-{
+-      if (!plat_device_is_coherent(dev))
+-              __dma_sync(dma_addr_to_page(dev, dma_handle),
+-                         dma_handle & ~PAGE_MASK, size, direction);
+-}
+-
+-static void mips_dma_sync_sg_for_cpu(struct device *dev,
+-      struct scatterlist *sg, int nelems, enum dma_data_direction direction)
+-{
+-      int i;
+-
+-      if (cpu_needs_post_dma_flush(dev))
+-              for (i = 0; i < nelems; i++, sg++)
+-                      __dma_sync(sg_page(sg), sg->offset, sg->length,
+-                                 direction);
+-}
+-
+-static void mips_dma_sync_sg_for_device(struct device *dev,
+-      struct scatterlist *sg, int nelems, enum dma_data_direction direction)
+-{
+-      int i;
+-
+-      if (!plat_device_is_coherent(dev))
+-              for (i = 0; i < nelems; i++, sg++)
+-                      __dma_sync(sg_page(sg), sg->offset, sg->length,
+-                                 direction);
+-}
+-
+-int mips_dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
+-{
+-      return 0;
+-}
+-
+-int mips_dma_supported(struct device *dev, u64 mask)
+-{
+-      return plat_dma_supported(dev, mask);
+-}
++EXPORT_SYMBOL(__dma_sync);
+ void dma_cache_sync(struct device *dev, void *vaddr, size_t size,
+                        enum dma_data_direction direction)
+@@ -360,23 +238,10 @@ void dma_cache_sync(struct device *dev,
+ EXPORT_SYMBOL(dma_cache_sync);
+-static struct dma_map_ops mips_default_dma_map_ops = {
+-      .alloc = mips_dma_alloc_coherent,
+-      .free = mips_dma_free_coherent,
+-      .map_page = mips_dma_map_page,
+-      .unmap_page = mips_dma_unmap_page,
+-      .map_sg = mips_dma_map_sg,
+-      .unmap_sg = mips_dma_unmap_sg,
+-      .sync_single_for_cpu = mips_dma_sync_single_for_cpu,
+-      .sync_single_for_device = mips_dma_sync_single_for_device,
+-      .sync_sg_for_cpu = mips_dma_sync_sg_for_cpu,
+-      .sync_sg_for_device = mips_dma_sync_sg_for_device,
+-      .mapping_error = mips_dma_mapping_error,
+-      .dma_supported = mips_dma_supported
+-};
+-
+-struct dma_map_ops *mips_dma_map_ops = &mips_default_dma_map_ops;
++#ifdef CONFIG_SYS_HAS_DMA_OPS
++struct dma_map_ops *mips_dma_map_ops = NULL;
+ EXPORT_SYMBOL(mips_dma_map_ops);
++#endif
+ #define PREALLOC_DMA_DEBUG_ENTRIES (1 << 16)
diff --git a/target/linux/generic/patches-3.18/200-fix_localversion.patch b/target/linux/generic/patches-3.18/200-fix_localversion.patch
new file mode 100644 (file)
index 0000000..70228bb
--- /dev/null
@@ -0,0 +1,11 @@
+--- a/scripts/setlocalversion
++++ b/scripts/setlocalversion
+@@ -165,7 +165,7 @@ else
+       # annotated or signed tagged state (as git describe only
+       # looks at signed or annotated tags - git tag -a/-s) and
+       # LOCALVERSION= is not specified
+-      if test "${LOCALVERSION+set}" != "set"; then
++      if test "${CONFIG_LOCALVERSION+set}" != "set"; then
+               scm=$(scm_version --short)
+               res="$res${scm:++}"
+       fi
diff --git a/target/linux/generic/patches-3.18/201-extra_optimization.patch b/target/linux/generic/patches-3.18/201-extra_optimization.patch
new file mode 100644 (file)
index 0000000..ee231a6
--- /dev/null
@@ -0,0 +1,14 @@
+--- a/Makefile
++++ b/Makefile
+@@ -611,9 +611,9 @@ include $(srctree)/arch/$(SRCARCH)/Makef
+ KBUILD_CFLAGS += $(call cc-option,-fno-delete-null-pointer-checks,)
+ ifdef CONFIG_CC_OPTIMIZE_FOR_SIZE
+-KBUILD_CFLAGS += -Os $(call cc-disable-warning,maybe-uninitialized,)
++KBUILD_CFLAGS += -Os $(EXTRA_OPTIMIZATION) $(call cc-disable-warning,maybe-uninitialized,)
+ else
+-KBUILD_CFLAGS += -O2
++KBUILD_CFLAGS += -O2 -fno-reorder-blocks -fno-tree-ch $(EXTRA_OPTIMIZATION)
+ endif
+ # Tell gcc to never replace conditional load with a non-conditional one
diff --git a/target/linux/generic/patches-3.18/202-reduce_module_size.patch b/target/linux/generic/patches-3.18/202-reduce_module_size.patch
new file mode 100644 (file)
index 0000000..60ea5c2
--- /dev/null
@@ -0,0 +1,11 @@
+--- a/Makefile
++++ b/Makefile
+@@ -408,7 +408,7 @@ KBUILD_CFLAGS_KERNEL :=
+ KBUILD_AFLAGS   := -D__ASSEMBLY__
+ KBUILD_AFLAGS_MODULE  := -DMODULE
+ KBUILD_CFLAGS_MODULE  := -DMODULE
+-KBUILD_LDFLAGS_MODULE := -T $(srctree)/scripts/module-common.lds
++KBUILD_LDFLAGS_MODULE = -T $(srctree)/scripts/module-common.lds $(if $(CONFIG_PROFILING),,-s)
+ # Read KERNELRELEASE from include/config/kernel.release (if it exists)
+ KERNELRELEASE = $(shell cat include/config/kernel.release 2> /dev/null)
diff --git a/target/linux/generic/patches-3.18/203-kallsyms_uncompressed.patch b/target/linux/generic/patches-3.18/203-kallsyms_uncompressed.patch
new file mode 100644 (file)
index 0000000..53229f0
--- /dev/null
@@ -0,0 +1,108 @@
+--- a/scripts/kallsyms.c
++++ b/scripts/kallsyms.c
+@@ -59,6 +59,7 @@ static struct sym_entry *table;
+ static unsigned int table_size, table_cnt;
+ static int all_symbols = 0;
+ static int absolute_percpu = 0;
++static int uncompressed = 0;
+ static char symbol_prefix_char = '\0';
+ static unsigned long long kernel_start_addr = 0;
+@@ -392,6 +393,9 @@ static void write_src(void)
+       free(markers);
++      if (uncompressed)
++              return;
++
+       output_label("kallsyms_token_table");
+       off = 0;
+       for (i = 0; i < 256; i++) {
+@@ -450,6 +454,9 @@ static void *find_token(unsigned char *s
+ {
+       int i;
++      if (uncompressed)
++              return NULL;
++
+       for (i = 0; i < len - 1; i++) {
+               if (str[i] == token[0] && str[i+1] == token[1])
+                       return &str[i];
+@@ -522,6 +529,9 @@ static void optimize_result(void)
+ {
+       int i, best;
++      if (uncompressed)
++              return;
++
+       /* using the '\0' symbol last allows compress_symbols to use standard
+        * fast string functions */
+       for (i = 255; i >= 0; i--) {
+@@ -692,7 +702,9 @@ int main(int argc, char **argv)
+                       } else if (strncmp(argv[i], "--page-offset=", 14) == 0) {
+                               const char *p = &argv[i][14];
+                               kernel_start_addr = strtoull(p, NULL, 16);
+-                      } else
++                      } else if (strcmp(argv[i], "--uncompressed") == 0)
++                              uncompressed = 1;
++                      else
+                               usage();
+               }
+       } else if (argc != 1)
+--- a/init/Kconfig
++++ b/init/Kconfig
+@@ -1338,6 +1338,17 @@ config SYSCTL_ARCH_UNALIGN_ALLOW
+         the unaligned access emulation.
+         see arch/parisc/kernel/unaligned.c for reference
++config KALLSYMS_UNCOMPRESSED
++      bool "Keep kallsyms uncompressed"
++      depends on KALLSYMS
++      help
++              Normally kallsyms contains compressed symbols (using a token table),
++              reducing the uncompressed kernel image size. Keeping the symbol table
++              uncompressed significantly improves the size of this part in compressed
++              kernel images.
++
++              Say N unless you need compressed kernel images to be small.
++
+ config HAVE_PCSPKR_PLATFORM
+       bool
+--- a/scripts/link-vmlinux.sh
++++ b/scripts/link-vmlinux.sh
+@@ -90,6 +90,10 @@ kallsyms()
+               kallsymopt="${kallsymopt} --absolute-percpu"
+       fi
++      if [ -n "${CONFIG_KALLSYMS_UNCOMPRESSED}" ]; then
++              kallsymopt="${kallsymopt} --uncompressed"
++      fi
++
+       local aflags="${KBUILD_AFLAGS} ${KBUILD_AFLAGS_KERNEL}               \
+                     ${NOSTDINC_FLAGS} ${LINUXINCLUDE} ${KBUILD_CPPFLAGS}"
+--- a/kernel/kallsyms.c
++++ b/kernel/kallsyms.c
+@@ -109,6 +109,11 @@ static unsigned int kallsyms_expand_symb
+        * For every byte on the compressed symbol data, copy the table
+        * entry for that byte.
+        */
++#ifdef CONFIG_KALLSYMS_UNCOMPRESSED
++      memcpy(result, data + 1, len - 1);
++      result += len - 1;
++      len = 0;
++#endif
+       while (len) {
+               tptr = &kallsyms_token_table[kallsyms_token_index[*data]];
+               data++;
+@@ -141,6 +146,9 @@ tail:
+  */
+ static char kallsyms_get_symbol_type(unsigned int off)
+ {
++#ifdef CONFIG_KALLSYMS_UNCOMPRESSED
++      return kallsyms_names[off + 1];
++#endif
+       /*
+        * Get just the first code, look it up in the token table,
+        * and return the first char from this token.
diff --git a/target/linux/generic/patches-3.18/204-module_strip.patch b/target/linux/generic/patches-3.18/204-module_strip.patch
new file mode 100644 (file)
index 0000000..e63ef15
--- /dev/null
@@ -0,0 +1,194 @@
+From: Felix Fietkau <nbd@openwrt.org>
+Subject: [PATCH] build: add a hack for removing non-essential module info
+
+Signed-off-by: Felix Fietkau <nbd@openwrt.org>
+---
+--- a/include/linux/module.h
++++ b/include/linux/module.h
+@@ -84,9 +84,10 @@ void trim_init_extable(struct module *m)
+ /* Generic info of form tag = "info" */
+ #define MODULE_INFO(tag, info) __MODULE_INFO(tag, tag, info)
++#define MODULE_INFO_STRIP(tag, info) __MODULE_INFO_STRIP(tag, tag, info)
+ /* For userspace: you can also call me... */
+-#define MODULE_ALIAS(_alias) MODULE_INFO(alias, _alias)
++#define MODULE_ALIAS(_alias) MODULE_INFO_STRIP(alias, _alias)
+ /* Soft module dependencies. See man modprobe.d for details.
+  * Example: MODULE_SOFTDEP("pre: module-foo module-bar post: module-baz")
+@@ -127,12 +128,12 @@ void trim_init_extable(struct module *m)
+  * Author(s), use "Name <email>" or just "Name", for multiple
+  * authors use multiple MODULE_AUTHOR() statements/lines.
+  */
+-#define MODULE_AUTHOR(_author) MODULE_INFO(author, _author)
++#define MODULE_AUTHOR(_author) MODULE_INFO_STRIP(author, _author)
+ /* What your module does. */
+-#define MODULE_DESCRIPTION(_description) MODULE_INFO(description, _description)
++#define MODULE_DESCRIPTION(_description) MODULE_INFO_STRIP(description, _description)
+-#ifdef MODULE
++#if defined(MODULE) && !defined(CONFIG_MODULE_STRIPPED)
+ /* Creates an alias so file2alias.c can find device table. */
+ #define MODULE_DEVICE_TABLE(type, name)                                       \
+   extern const struct type##_device_id __mod_##type##__##name##_device_table \
+@@ -159,7 +160,9 @@ void trim_init_extable(struct module *m)
+  */
+ #if defined(MODULE) || !defined(CONFIG_SYSFS)
+-#define MODULE_VERSION(_version) MODULE_INFO(version, _version)
++#define MODULE_VERSION(_version) MODULE_INFO_STRIP(version, _version)
++#elif defined(CONFIG_MODULE_STRIPPED)
++#define MODULE_VERSION(_version) __MODULE_INFO_DISABLED(version)
+ #else
+ #define MODULE_VERSION(_version)                                      \
+       static struct module_version_attribute ___modver_attr = {       \
+@@ -181,7 +184,7 @@ void trim_init_extable(struct module *m)
+ /* Optional firmware file (or files) needed by the module
+  * format is simply firmware file name.  Multiple firmware
+  * files require multiple MODULE_FIRMWARE() specifiers */
+-#define MODULE_FIRMWARE(_firmware) MODULE_INFO(firmware, _firmware)
++#define MODULE_FIRMWARE(_firmware) MODULE_INFO_STRIP(firmware, _firmware)
+ /* Given an address, look for it in the exception tables */
+ const struct exception_table_entry *search_exception_tables(unsigned long add);
+--- a/include/linux/moduleparam.h
++++ b/include/linux/moduleparam.h
+@@ -16,6 +16,16 @@
+ /* Chosen so that structs with an unsigned long line up. */
+ #define MAX_PARAM_PREFIX_LEN (64 - sizeof(unsigned long))
++/* This struct is here for syntactic coherency, it is not used */
++#define __MODULE_INFO_DISABLED(name)                                    \
++  struct __UNIQUE_ID(name) {}
++
++#ifdef CONFIG_MODULE_STRIPPED
++#define __MODULE_INFO_STRIP(tag, name, info) __MODULE_INFO_DISABLED(name)
++#else
++#define __MODULE_INFO_STRIP(tag, name, info) __MODULE_INFO(tag, name, info)
++#endif
++
+ #ifdef MODULE
+ #define __MODULE_INFO(tag, name, info)                                          \
+ static const char __UNIQUE_ID(name)[]                                   \
+@@ -23,8 +33,7 @@ static const char __UNIQUE_ID(name)[]
+   = __stringify(tag) "=" info
+ #else  /* !MODULE */
+ /* This struct is here for syntactic coherency, it is not used */
+-#define __MODULE_INFO(tag, name, info)                                          \
+-  struct __UNIQUE_ID(name) {}
++#define __MODULE_INFO(tag, name, info) __MODULE_INFO_DISABLED(name)
+ #endif
+ #define __MODULE_PARM_TYPE(name, _type)                                         \
+   __MODULE_INFO(parmtype, name##type, #name ":" _type)
+@@ -32,7 +41,7 @@ static const char __UNIQUE_ID(name)[]
+ /* One for each parameter, describing how to use it.  Some files do
+    multiple of these per line, so can't just use MODULE_INFO. */
+ #define MODULE_PARM_DESC(_parm, desc) \
+-      __MODULE_INFO(parm, _parm, #_parm ":" desc)
++      __MODULE_INFO_STRIP(parm, _parm, #_parm ":" desc)
+ struct kernel_param;
+--- a/init/Kconfig
++++ b/init/Kconfig
+@@ -1973,6 +1973,13 @@ config MODULE_COMPRESS_XZ
+ endchoice
++config MODULE_STRIPPED
++      bool "Reduce module size"
++      depends on MODULES
++      help
++        Remove module parameter descriptions, author info, version, aliases,
++        device tables, etc.
++
+ endif # MODULES
+ config INIT_ALL_POSSIBLE
+--- a/kernel/module.c
++++ b/kernel/module.c
+@@ -2665,6 +2665,7 @@ static struct module *setup_load_info(st
+ static int check_modinfo(struct module *mod, struct load_info *info, int flags)
+ {
++#ifndef CONFIG_MODULE_STRIPPED
+       const char *modmagic = get_modinfo(info, "vermagic");
+       int err;
+@@ -2690,6 +2691,7 @@ static int check_modinfo(struct module *
+               pr_warn("%s: module is from the staging directory, the quality "
+                       "is unknown, you have been warned.\n", mod->name);
+       }
++#endif
+       /* Set up license info based on the info section */
+       set_license(mod, get_modinfo(info, "license"));
+--- a/scripts/mod/modpost.c
++++ b/scripts/mod/modpost.c
+@@ -1726,7 +1726,9 @@ static void read_symbols(char *modname)
+               symname = remove_dot(info.strtab + sym->st_name);
+               handle_modversions(mod, &info, sym, symname);
++#ifndef CONFIG_MODULE_STRIPPED
+               handle_moddevtable(mod, &info, sym, symname);
++#endif
+       }
+       if (!is_vmlinux(modname) ||
+            (is_vmlinux(modname) && vmlinux_section_warnings))
+@@ -1870,7 +1872,9 @@ static void add_header(struct buffer *b,
+       buf_printf(b, "#include <linux/vermagic.h>\n");
+       buf_printf(b, "#include <linux/compiler.h>\n");
+       buf_printf(b, "\n");
++#ifndef CONFIG_MODULE_STRIPPED
+       buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n");
++#endif
+       buf_printf(b, "\n");
+       buf_printf(b, "__visible struct module __this_module\n");
+       buf_printf(b, "__attribute__((section(\".gnu.linkonce.this_module\"))) = {\n");
+@@ -1887,16 +1891,20 @@ static void add_header(struct buffer *b,
+ static void add_intree_flag(struct buffer *b, int is_intree)
+ {
++#ifndef CONFIG_MODULE_STRIPPED
+       if (is_intree)
+               buf_printf(b, "\nMODULE_INFO(intree, \"Y\");\n");
++#endif
+ }
+ static void add_staging_flag(struct buffer *b, const char *name)
+ {
++#ifndef CONFIG_MODULE_STRIPPED
+       static const char *staging_dir = "drivers/staging";
+       if (strncmp(staging_dir, name, strlen(staging_dir)) == 0)
+               buf_printf(b, "\nMODULE_INFO(staging, \"Y\");\n");
++#endif
+ }
+ /**
+@@ -1989,11 +1997,13 @@ static void add_depends(struct buffer *b
+ static void add_srcversion(struct buffer *b, struct module *mod)
+ {
++#ifndef CONFIG_MODULE_STRIPPED
+       if (mod->srcversion[0]) {
+               buf_printf(b, "\n");
+               buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n",
+                          mod->srcversion);
+       }
++#endif
+ }
+ static void write_if_changed(struct buffer *b, const char *fname)
+@@ -2224,7 +2234,9 @@ int main(int argc, char **argv)
+               add_staging_flag(&buf, mod->name);
+               err |= add_versions(&buf, mod);
+               add_depends(&buf, mod, modules);
++#ifndef CONFIG_MODULE_STRIPPED
+               add_moddevtable(&buf, mod);
++#endif
+               add_srcversion(&buf, mod);
+               sprintf(fname, "%s.mod.c", mod->name);
diff --git a/target/linux/generic/patches-3.18/210-darwin_scripts_include.patch b/target/linux/generic/patches-3.18/210-darwin_scripts_include.patch
new file mode 100644 (file)
index 0000000..dc554de
--- /dev/null
@@ -0,0 +1,3088 @@
+--- a/scripts/kallsyms.c
++++ b/scripts/kallsyms.c
+@@ -22,6 +22,35 @@
+ #include <stdlib.h>
+ #include <string.h>
+ #include <ctype.h>
++#ifdef __APPLE__
++/* Darwin has no memmem implementation, this one is ripped of the uClibc-0.9.28 source */
++void *memmem (const void *haystack, size_t haystack_len,
++                          const void *needle,  size_t needle_len)
++{
++  const char *begin;
++  const char *const last_possible
++    = (const char *) haystack + haystack_len - needle_len;
++
++  if (needle_len == 0)
++    /* The first occurrence of the empty string is deemed to occur at
++       the beginning of the string.  */
++    return (void *) haystack;
++
++  /* Sanity check, otherwise the loop might search through the whole
++     memory.  */
++  if (__builtin_expect (haystack_len < needle_len, 0))
++    return NULL;
++
++  for (begin = (const char *) haystack; begin <= last_possible; ++begin)
++    if (begin[0] == ((const char *) needle)[0] &&
++        !memcmp ((const void *) &begin[1],
++                 (const void *) ((const char *) needle + 1),
++                 needle_len - 1))
++      return (void *) begin;
++
++  return NULL;
++}
++#endif
+ #ifndef ARRAY_SIZE
+ #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof(arr[0]))
+--- a/scripts/kconfig/Makefile
++++ b/scripts/kconfig/Makefile
+@@ -151,6 +151,9 @@ check-lxdialog  := $(srctree)/$(src)/lxd
+ # we really need to do so. (Do not call gcc as part of make mrproper)
+ HOST_EXTRACFLAGS += $(shell $(CONFIG_SHELL) $(check-lxdialog) -ccflags) \
+                     -DLOCALE
++ifeq ($(shell uname -s),Darwin)
++HOST_LOADLIBES  += -lncurses
++endif
+ # ===========================================================================
+ # Shared Makefile for the various kconfig executables:
+--- a/scripts/mod/mk_elfconfig.c
++++ b/scripts/mod/mk_elfconfig.c
+@@ -1,7 +1,11 @@
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <string.h>
++#ifndef __APPLE__
+ #include <elf.h>
++#else
++#include "elf.h"
++#endif
+ int
+ main(int argc, char **argv)
+--- a/scripts/mod/modpost.h
++++ b/scripts/mod/modpost.h
+@@ -7,7 +7,11 @@
+ #include <sys/mman.h>
+ #include <fcntl.h>
+ #include <unistd.h>
++#if !(defined(__APPLE__) || defined(__CYGWIN__))
+ #include <elf.h>
++#else
++#include "elf.h"
++#endif
+ #include "elfconfig.h"
+--- /dev/null
++++ b/scripts/mod/elf.h
+@@ -0,0 +1,3007 @@
++/* This file defines standard ELF types, structures, and macros.
++   Copyright (C) 1995-2012 Free Software Foundation, Inc.
++   This file is part of the GNU C Library.
++
++   The GNU C Library is free software; you can redistribute it and/or
++   modify it under the terms of the GNU Lesser General Public
++   License as published by the Free Software Foundation; either
++   version 2.1 of the License, or (at your option) any later version.
++
++   The GNU C Library is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++   Lesser General Public License for more details.
++
++   You should have received a copy of the GNU Lesser General Public
++   License along with the GNU C Library; if not, see
++   <http://www.gnu.org/licenses/>.  */
++
++#ifndef _ELF_H
++#define       _ELF_H 1
++
++/* Standard ELF types.  */
++
++#include <stdint.h>
++
++/* Type for a 16-bit quantity.  */
++typedef uint16_t Elf32_Half;
++typedef uint16_t Elf64_Half;
++
++/* Types for signed and unsigned 32-bit quantities.  */
++typedef uint32_t Elf32_Word;
++typedef       int32_t  Elf32_Sword;
++typedef uint32_t Elf64_Word;
++typedef       int32_t  Elf64_Sword;
++
++/* Types for signed and unsigned 64-bit quantities.  */
++typedef uint64_t Elf32_Xword;
++typedef       int64_t  Elf32_Sxword;
++typedef uint64_t Elf64_Xword;
++typedef       int64_t  Elf64_Sxword;
++
++/* Type of addresses.  */
++typedef uint32_t Elf32_Addr;
++typedef uint64_t Elf64_Addr;
++
++/* Type of file offsets.  */
++typedef uint32_t Elf32_Off;
++typedef uint64_t Elf64_Off;
++
++/* Type for section indices, which are 16-bit quantities.  */
++typedef uint16_t Elf32_Section;
++typedef uint16_t Elf64_Section;
++
++/* Type for version symbol information.  */
++typedef Elf32_Half Elf32_Versym;
++typedef Elf64_Half Elf64_Versym;
++
++
++/* The ELF file header.  This appears at the start of every ELF file.  */
++
++#define EI_NIDENT (16)
++
++typedef struct
++{
++  unsigned char       e_ident[EI_NIDENT];     /* Magic number and other info */
++  Elf32_Half  e_type;                 /* Object file type */
++  Elf32_Half  e_machine;              /* Architecture */
++  Elf32_Word  e_version;              /* Object file version */
++  Elf32_Addr  e_entry;                /* Entry point virtual address */
++  Elf32_Off   e_phoff;                /* Program header table file offset */
++  Elf32_Off   e_shoff;                /* Section header table file offset */
++  Elf32_Word  e_flags;                /* Processor-specific flags */
++  Elf32_Half  e_ehsize;               /* ELF header size in bytes */
++  Elf32_Half  e_phentsize;            /* Program header table entry size */
++  Elf32_Half  e_phnum;                /* Program header table entry count */
++  Elf32_Half  e_shentsize;            /* Section header table entry size */
++  Elf32_Half  e_shnum;                /* Section header table entry count */
++  Elf32_Half  e_shstrndx;             /* Section header string table index */
++} Elf32_Ehdr;
++
++typedef struct
++{
++  unsigned char       e_ident[EI_NIDENT];     /* Magic number and other info */
++  Elf64_Half  e_type;                 /* Object file type */
++  Elf64_Half  e_machine;              /* Architecture */
++  Elf64_Word  e_version;              /* Object file version */
++  Elf64_Addr  e_entry;                /* Entry point virtual address */
++  Elf64_Off   e_phoff;                /* Program header table file offset */
++  Elf64_Off   e_shoff;                /* Section header table file offset */
++  Elf64_Word  e_flags;                /* Processor-specific flags */
++  Elf64_Half  e_ehsize;               /* ELF header size in bytes */
++  Elf64_Half  e_phentsize;            /* Program header table entry size */
++  Elf64_Half  e_phnum;                /* Program header table entry count */
++  Elf64_Half  e_shentsize;            /* Section header table entry size */
++  Elf64_Half  e_shnum;                /* Section header table entry count */
++  Elf64_Half  e_shstrndx;             /* Section header string table index */
++} Elf64_Ehdr;
++
++/* Fields in the e_ident array.  The EI_* macros are indices into the
++   array.  The macros under each EI_* macro are the values the byte
++   may have.  */
++
++#define EI_MAG0               0               /* File identification byte 0 index */
++#define ELFMAG0               0x7f            /* Magic number byte 0 */
++
++#define EI_MAG1               1               /* File identification byte 1 index */
++#define ELFMAG1               'E'             /* Magic number byte 1 */
++
++#define EI_MAG2               2               /* File identification byte 2 index */
++#define ELFMAG2               'L'             /* Magic number byte 2 */
++
++#define EI_MAG3               3               /* File identification byte 3 index */
++#define ELFMAG3               'F'             /* Magic number byte 3 */
++
++/* Conglomeration of the identification bytes, for easy testing as a word.  */
++#define       ELFMAG          "\177ELF"
++#define       SELFMAG         4
++
++#define EI_CLASS      4               /* File class byte index */
++#define ELFCLASSNONE  0               /* Invalid class */
++#define ELFCLASS32    1               /* 32-bit objects */
++#define ELFCLASS64    2               /* 64-bit objects */
++#define ELFCLASSNUM   3
++
++#define EI_DATA               5               /* Data encoding byte index */
++#define ELFDATANONE   0               /* Invalid data encoding */
++#define ELFDATA2LSB   1               /* 2's complement, little endian */
++#define ELFDATA2MSB   2               /* 2's complement, big endian */
++#define ELFDATANUM    3
++
++#define EI_VERSION    6               /* File version byte index */
++                                      /* Value must be EV_CURRENT */
++
++#define EI_OSABI      7               /* OS ABI identification */
++#define ELFOSABI_NONE         0       /* UNIX System V ABI */
++#define ELFOSABI_SYSV         0       /* Alias.  */
++#define ELFOSABI_HPUX         1       /* HP-UX */
++#define ELFOSABI_NETBSD               2       /* NetBSD.  */
++#define ELFOSABI_GNU          3       /* Object uses GNU ELF extensions.  */
++#define ELFOSABI_LINUX                ELFOSABI_GNU /* Compatibility alias.  */
++#define ELFOSABI_SOLARIS      6       /* Sun Solaris.  */
++#define ELFOSABI_AIX          7       /* IBM AIX.  */
++#define ELFOSABI_IRIX         8       /* SGI Irix.  */
++#define ELFOSABI_FREEBSD      9       /* FreeBSD.  */
++#define ELFOSABI_TRU64                10      /* Compaq TRU64 UNIX.  */
++#define ELFOSABI_MODESTO      11      /* Novell Modesto.  */
++#define ELFOSABI_OPENBSD      12      /* OpenBSD.  */
++#define ELFOSABI_ARM_AEABI    64      /* ARM EABI */
++#define ELFOSABI_ARM          97      /* ARM */
++#define ELFOSABI_STANDALONE   255     /* Standalone (embedded) application */
++
++#define EI_ABIVERSION 8               /* ABI version */
++
++#define EI_PAD                9               /* Byte index of padding bytes */
++
++/* Legal values for e_type (object file type).  */
++
++#define ET_NONE               0               /* No file type */
++#define ET_REL                1               /* Relocatable file */
++#define ET_EXEC               2               /* Executable file */
++#define ET_DYN                3               /* Shared object file */
++#define ET_CORE               4               /* Core file */
++#define       ET_NUM          5               /* Number of defined types */
++#define ET_LOOS               0xfe00          /* OS-specific range start */
++#define ET_HIOS               0xfeff          /* OS-specific range end */
++#define ET_LOPROC     0xff00          /* Processor-specific range start */
++#define ET_HIPROC     0xffff          /* Processor-specific range end */
++
++/* Legal values for e_machine (architecture).  */
++
++#define EM_NONE                0              /* No machine */
++#define EM_M32                 1              /* AT&T WE 32100 */
++#define EM_SPARC       2              /* SUN SPARC */
++#define EM_386                 3              /* Intel 80386 */
++#define EM_68K                 4              /* Motorola m68k family */
++#define EM_88K                 5              /* Motorola m88k family */
++#define EM_860                 7              /* Intel 80860 */
++#define EM_MIPS                8              /* MIPS R3000 big-endian */
++#define EM_S370                9              /* IBM System/370 */
++#define EM_MIPS_RS3_LE        10              /* MIPS R3000 little-endian */
++
++#define EM_PARISC     15              /* HPPA */
++#define EM_VPP500     17              /* Fujitsu VPP500 */
++#define EM_SPARC32PLUS        18              /* Sun's "v8plus" */
++#define EM_960                19              /* Intel 80960 */
++#define EM_PPC                20              /* PowerPC */
++#define EM_PPC64      21              /* PowerPC 64-bit */
++#define EM_S390               22              /* IBM S390 */
++
++#define EM_V800               36              /* NEC V800 series */
++#define EM_FR20               37              /* Fujitsu FR20 */
++#define EM_RH32               38              /* TRW RH-32 */
++#define EM_RCE                39              /* Motorola RCE */
++#define EM_ARM                40              /* ARM */
++#define EM_FAKE_ALPHA 41              /* Digital Alpha */
++#define EM_SH         42              /* Hitachi SH */
++#define EM_SPARCV9    43              /* SPARC v9 64-bit */
++#define EM_TRICORE    44              /* Siemens Tricore */
++#define EM_ARC                45              /* Argonaut RISC Core */
++#define EM_H8_300     46              /* Hitachi H8/300 */
++#define EM_H8_300H    47              /* Hitachi H8/300H */
++#define EM_H8S                48              /* Hitachi H8S */
++#define EM_H8_500     49              /* Hitachi H8/500 */
++#define EM_IA_64      50              /* Intel Merced */
++#define EM_MIPS_X     51              /* Stanford MIPS-X */
++#define EM_COLDFIRE   52              /* Motorola Coldfire */
++#define EM_68HC12     53              /* Motorola M68HC12 */
++#define EM_MMA                54              /* Fujitsu MMA Multimedia Accelerator*/
++#define EM_PCP                55              /* Siemens PCP */
++#define EM_NCPU               56              /* Sony nCPU embeeded RISC */
++#define EM_NDR1               57              /* Denso NDR1 microprocessor */
++#define EM_STARCORE   58              /* Motorola Start*Core processor */
++#define EM_ME16               59              /* Toyota ME16 processor */
++#define EM_ST100      60              /* STMicroelectronic ST100 processor */
++#define EM_TINYJ      61              /* Advanced Logic Corp. Tinyj emb.fam*/
++#define EM_X86_64     62              /* AMD x86-64 architecture */
++#define EM_PDSP               63              /* Sony DSP Processor */
++
++#define EM_FX66               66              /* Siemens FX66 microcontroller */
++#define EM_ST9PLUS    67              /* STMicroelectronics ST9+ 8/16 mc */
++#define EM_ST7                68              /* STmicroelectronics ST7 8 bit mc */
++#define EM_68HC16     69              /* Motorola MC68HC16 microcontroller */
++#define EM_68HC11     70              /* Motorola MC68HC11 microcontroller */
++#define EM_68HC08     71              /* Motorola MC68HC08 microcontroller */
++#define EM_68HC05     72              /* Motorola MC68HC05 microcontroller */
++#define EM_SVX                73              /* Silicon Graphics SVx */
++#define EM_ST19               74              /* STMicroelectronics ST19 8 bit mc */
++#define EM_VAX                75              /* Digital VAX */
++#define EM_CRIS               76              /* Axis Communications 32-bit embedded processor */
++#define EM_JAVELIN    77              /* Infineon Technologies 32-bit embedded processor */
++#define EM_FIREPATH   78              /* Element 14 64-bit DSP Processor */
++#define EM_ZSP                79              /* LSI Logic 16-bit DSP Processor */
++#define EM_MMIX               80              /* Donald Knuth's educational 64-bit processor */
++#define EM_HUANY      81              /* Harvard University machine-independent object files */
++#define EM_PRISM      82              /* SiTera Prism */
++#define EM_AVR                83              /* Atmel AVR 8-bit microcontroller */
++#define EM_FR30               84              /* Fujitsu FR30 */
++#define EM_D10V               85              /* Mitsubishi D10V */
++#define EM_D30V               86              /* Mitsubishi D30V */
++#define EM_V850               87              /* NEC v850 */
++#define EM_M32R               88              /* Mitsubishi M32R */
++#define EM_MN10300    89              /* Matsushita MN10300 */
++#define EM_MN10200    90              /* Matsushita MN10200 */
++#define EM_PJ         91              /* picoJava */
++#define EM_OPENRISC   92              /* OpenRISC 32-bit embedded processor */
++#define EM_ARC_A5     93              /* ARC Cores Tangent-A5 */
++#define EM_XTENSA     94              /* Tensilica Xtensa Architecture */
++#define EM_TILEPRO    188             /* Tilera TILEPro */
++#define EM_TILEGX     191             /* Tilera TILE-Gx */
++#define EM_NUM                192
++
++/* If it is necessary to assign new unofficial EM_* values, please
++   pick large random numbers (0x8523, 0xa7f2, etc.) to minimize the
++   chances of collision with official or non-GNU unofficial values.  */
++
++#define EM_ALPHA      0x9026
++
++/* Legal values for e_version (version).  */
++
++#define EV_NONE               0               /* Invalid ELF version */
++#define EV_CURRENT    1               /* Current version */
++#define EV_NUM                2
++
++/* Section header.  */
++
++typedef struct
++{
++  Elf32_Word  sh_name;                /* Section name (string tbl index) */
++  Elf32_Word  sh_type;                /* Section type */
++  Elf32_Word  sh_flags;               /* Section flags */
++  Elf32_Addr  sh_addr;                /* Section virtual addr at execution */
++  Elf32_Off   sh_offset;              /* Section file offset */
++  Elf32_Word  sh_size;                /* Section size in bytes */
++  Elf32_Word  sh_link;                /* Link to another section */
++  Elf32_Word  sh_info;                /* Additional section information */
++  Elf32_Word  sh_addralign;           /* Section alignment */
++  Elf32_Word  sh_entsize;             /* Entry size if section holds table */
++} Elf32_Shdr;
++
++typedef struct
++{
++  Elf64_Word  sh_name;                /* Section name (string tbl index) */
++  Elf64_Word  sh_type;                /* Section type */
++  Elf64_Xword sh_flags;               /* Section flags */
++  Elf64_Addr  sh_addr;                /* Section virtual addr at execution */
++  Elf64_Off   sh_offset;              /* Section file offset */
++  Elf64_Xword sh_size;                /* Section size in bytes */
++  Elf64_Word  sh_link;                /* Link to another section */
++  Elf64_Word  sh_info;                /* Additional section information */
++  Elf64_Xword sh_addralign;           /* Section alignment */
++  Elf64_Xword sh_entsize;             /* Entry size if section holds table */
++} Elf64_Shdr;
++
++/* Special section indices.  */
++
++#define SHN_UNDEF     0               /* Undefined section */
++#define SHN_LORESERVE 0xff00          /* Start of reserved indices */
++#define SHN_LOPROC    0xff00          /* Start of processor-specific */
++#define SHN_BEFORE    0xff00          /* Order section before all others
++                                         (Solaris).  */
++#define SHN_AFTER     0xff01          /* Order section after all others
++                                         (Solaris).  */
++#define SHN_HIPROC    0xff1f          /* End of processor-specific */
++#define SHN_LOOS      0xff20          /* Start of OS-specific */
++#define SHN_HIOS      0xff3f          /* End of OS-specific */
++#define SHN_ABS               0xfff1          /* Associated symbol is absolute */
++#define SHN_COMMON    0xfff2          /* Associated symbol is common */
++#define SHN_XINDEX    0xffff          /* Index is in extra table.  */
++#define SHN_HIRESERVE 0xffff          /* End of reserved indices */
++
++/* Legal values for sh_type (section type).  */
++
++#define SHT_NULL        0             /* Section header table entry unused */
++#define SHT_PROGBITS    1             /* Program data */
++#define SHT_SYMTAB      2             /* Symbol table */
++#define SHT_STRTAB      3             /* String table */
++#define SHT_RELA        4             /* Relocation entries with addends */
++#define SHT_HASH        5             /* Symbol hash table */
++#define SHT_DYNAMIC     6             /* Dynamic linking information */
++#define SHT_NOTE        7             /* Notes */
++#define SHT_NOBITS      8             /* Program space with no data (bss) */
++#define SHT_REL                 9             /* Relocation entries, no addends */
++#define SHT_SHLIB       10            /* Reserved */
++#define SHT_DYNSYM      11            /* Dynamic linker symbol table */
++#define SHT_INIT_ARRAY          14            /* Array of constructors */
++#define SHT_FINI_ARRAY          15            /* Array of destructors */
++#define SHT_PREINIT_ARRAY 16          /* Array of pre-constructors */
++#define SHT_GROUP       17            /* Section group */
++#define SHT_SYMTAB_SHNDX  18          /* Extended section indeces */
++#define       SHT_NUM           19            /* Number of defined types.  */
++#define SHT_LOOS        0x60000000    /* Start OS-specific.  */
++#define SHT_GNU_ATTRIBUTES 0x6ffffff5 /* Object attributes.  */
++#define SHT_GNU_HASH    0x6ffffff6    /* GNU-style hash table.  */
++#define SHT_GNU_LIBLIST         0x6ffffff7    /* Prelink library list */
++#define SHT_CHECKSUM    0x6ffffff8    /* Checksum for DSO content.  */
++#define SHT_LOSUNW      0x6ffffffa    /* Sun-specific low bound.  */
++#define SHT_SUNW_move   0x6ffffffa
++#define SHT_SUNW_COMDAT   0x6ffffffb
++#define SHT_SUNW_syminfo  0x6ffffffc
++#define SHT_GNU_verdef          0x6ffffffd    /* Version definition section.  */
++#define SHT_GNU_verneed         0x6ffffffe    /* Version needs section.  */
++#define SHT_GNU_versym          0x6fffffff    /* Version symbol table.  */
++#define SHT_HISUNW      0x6fffffff    /* Sun-specific high bound.  */
++#define SHT_HIOS        0x6fffffff    /* End OS-specific type */
++#define SHT_LOPROC      0x70000000    /* Start of processor-specific */
++#define SHT_HIPROC      0x7fffffff    /* End of processor-specific */
++#define SHT_LOUSER      0x80000000    /* Start of application-specific */
++#define SHT_HIUSER      0x8fffffff    /* End of application-specific */
++
++/* Legal values for sh_flags (section flags).  */
++
++#define SHF_WRITE          (1 << 0)   /* Writable */
++#define SHF_ALLOC          (1 << 1)   /* Occupies memory during execution */
++#define SHF_EXECINSTR      (1 << 2)   /* Executable */
++#define SHF_MERGE          (1 << 4)   /* Might be merged */
++#define SHF_STRINGS        (1 << 5)   /* Contains nul-terminated strings */
++#define SHF_INFO_LINK      (1 << 6)   /* `sh_info' contains SHT index */
++#define SHF_LINK_ORDER             (1 << 7)   /* Preserve order after combining */
++#define SHF_OS_NONCONFORMING (1 << 8) /* Non-standard OS specific handling
++                                         required */
++#define SHF_GROUP          (1 << 9)   /* Section is member of a group.  */
++#define SHF_TLS                    (1 << 10)  /* Section hold thread-local data.  */
++#define SHF_MASKOS         0x0ff00000 /* OS-specific.  */
++#define SHF_MASKPROC       0xf0000000 /* Processor-specific */
++#define SHF_ORDERED        (1 << 30)  /* Special ordering requirement
++                                         (Solaris).  */
++#define SHF_EXCLUDE        (1 << 31)  /* Section is excluded unless
++                                         referenced or allocated (Solaris).*/
++
++/* Section group handling.  */
++#define GRP_COMDAT    0x1             /* Mark group as COMDAT.  */
++
++/* Symbol table entry.  */
++
++typedef struct
++{
++  Elf32_Word  st_name;                /* Symbol name (string tbl index) */
++  Elf32_Addr  st_value;               /* Symbol value */
++  Elf32_Word  st_size;                /* Symbol size */
++  unsigned char       st_info;                /* Symbol type and binding */
++  unsigned char       st_other;               /* Symbol visibility */
++  Elf32_Section       st_shndx;               /* Section index */
++} Elf32_Sym;
++
++typedef struct
++{
++  Elf64_Word  st_name;                /* Symbol name (string tbl index) */
++  unsigned char       st_info;                /* Symbol type and binding */
++  unsigned char st_other;             /* Symbol visibility */
++  Elf64_Section       st_shndx;               /* Section index */
++  Elf64_Addr  st_value;               /* Symbol value */
++  Elf64_Xword st_size;                /* Symbol size */
++} Elf64_Sym;
++
++/* The syminfo section if available contains additional information about
++   every dynamic symbol.  */
++
++typedef struct
++{
++  Elf32_Half si_boundto;              /* Direct bindings, symbol bound to */
++  Elf32_Half si_flags;                        /* Per symbol flags */
++} Elf32_Syminfo;
++
++typedef struct
++{
++  Elf64_Half si_boundto;              /* Direct bindings, symbol bound to */
++  Elf64_Half si_flags;                        /* Per symbol flags */
++} Elf64_Syminfo;
++
++/* Possible values for si_boundto.  */
++#define SYMINFO_BT_SELF               0xffff  /* Symbol bound to self */
++#define SYMINFO_BT_PARENT     0xfffe  /* Symbol bound to parent */
++#define SYMINFO_BT_LOWRESERVE 0xff00  /* Beginning of reserved entries */
++
++/* Possible bitmasks for si_flags.  */
++#define SYMINFO_FLG_DIRECT    0x0001  /* Direct bound symbol */
++#define SYMINFO_FLG_PASSTHRU  0x0002  /* Pass-thru symbol for translator */
++#define SYMINFO_FLG_COPY      0x0004  /* Symbol is a copy-reloc */
++#define SYMINFO_FLG_LAZYLOAD  0x0008  /* Symbol bound to object to be lazy
++                                         loaded */
++/* Syminfo version values.  */
++#define SYMINFO_NONE          0
++#define SYMINFO_CURRENT               1
++#define SYMINFO_NUM           2
++
++
++/* How to extract and insert information held in the st_info field.  */
++
++#define ELF32_ST_BIND(val)            (((unsigned char) (val)) >> 4)
++#define ELF32_ST_TYPE(val)            ((val) & 0xf)
++#define ELF32_ST_INFO(bind, type)     (((bind) << 4) + ((type) & 0xf))
++
++/* Both Elf32_Sym and Elf64_Sym use the same one-byte st_info field.  */
++#define ELF64_ST_BIND(val)            ELF32_ST_BIND (val)
++#define ELF64_ST_TYPE(val)            ELF32_ST_TYPE (val)
++#define ELF64_ST_INFO(bind, type)     ELF32_ST_INFO ((bind), (type))
++
++/* Legal values for ST_BIND subfield of st_info (symbol binding).  */
++
++#define STB_LOCAL     0               /* Local symbol */
++#define STB_GLOBAL    1               /* Global symbol */
++#define STB_WEAK      2               /* Weak symbol */
++#define       STB_NUM         3               /* Number of defined types.  */
++#define STB_LOOS      10              /* Start of OS-specific */
++#define STB_GNU_UNIQUE        10              /* Unique symbol.  */
++#define STB_HIOS      12              /* End of OS-specific */
++#define STB_LOPROC    13              /* Start of processor-specific */
++#define STB_HIPROC    15              /* End of processor-specific */
++
++/* Legal values for ST_TYPE subfield of st_info (symbol type).  */
++
++#define STT_NOTYPE    0               /* Symbol type is unspecified */
++#define STT_OBJECT    1               /* Symbol is a data object */
++#define STT_FUNC      2               /* Symbol is a code object */
++#define STT_SECTION   3               /* Symbol associated with a section */
++#define STT_FILE      4               /* Symbol's name is file name */
++#define STT_COMMON    5               /* Symbol is a common data object */
++#define STT_TLS               6               /* Symbol is thread-local data object*/
++#define       STT_NUM         7               /* Number of defined types.  */
++#define STT_LOOS      10              /* Start of OS-specific */
++#define STT_GNU_IFUNC 10              /* Symbol is indirect code object */
++#define STT_HIOS      12              /* End of OS-specific */
++#define STT_LOPROC    13              /* Start of processor-specific */
++#define STT_HIPROC    15              /* End of processor-specific */
++
++
++/* Symbol table indices are found in the hash buckets and chain table
++   of a symbol hash table section.  This special index value indicates
++   the end of a chain, meaning no further symbols are found in that bucket.  */
++
++#define STN_UNDEF     0               /* End of a chain.  */
++
++
++/* How to extract and insert information held in the st_other field.  */
++
++#define ELF32_ST_VISIBILITY(o)        ((o) & 0x03)
++
++/* For ELF64 the definitions are the same.  */
++#define ELF64_ST_VISIBILITY(o)        ELF32_ST_VISIBILITY (o)
++
++/* Symbol visibility specification encoded in the st_other field.  */
++#define STV_DEFAULT   0               /* Default symbol visibility rules */
++#define STV_INTERNAL  1               /* Processor specific hidden class */
++#define STV_HIDDEN    2               /* Sym unavailable in other modules */
++#define STV_PROTECTED 3               /* Not preemptible, not exported */
++
++
++/* Relocation table entry without addend (in section of type SHT_REL).  */
++
++typedef struct
++{
++  Elf32_Addr  r_offset;               /* Address */
++  Elf32_Word  r_info;                 /* Relocation type and symbol index */
++} Elf32_Rel;
++
++/* I have seen two different definitions of the Elf64_Rel and
++   Elf64_Rela structures, so we'll leave them out until Novell (or
++   whoever) gets their act together.  */
++/* The following, at least, is used on Sparc v9, MIPS, and Alpha.  */
++
++typedef struct
++{
++  Elf64_Addr  r_offset;               /* Address */
++  Elf64_Xword r_info;                 /* Relocation type and symbol index */
++} Elf64_Rel;
++
++/* Relocation table entry with addend (in section of type SHT_RELA).  */
++
++typedef struct
++{
++  Elf32_Addr  r_offset;               /* Address */
++  Elf32_Word  r_info;                 /* Relocation type and symbol index */
++  Elf32_Sword r_addend;               /* Addend */
++} Elf32_Rela;
++
++typedef struct
++{
++  Elf64_Addr  r_offset;               /* Address */
++  Elf64_Xword r_info;                 /* Relocation type and symbol index */
++  Elf64_Sxword        r_addend;               /* Addend */
++} Elf64_Rela;
++
++/* How to extract and insert information held in the r_info field.  */
++
++#define ELF32_R_SYM(val)              ((val) >> 8)
++#define ELF32_R_TYPE(val)             ((val) & 0xff)
++#define ELF32_R_INFO(sym, type)               (((sym) << 8) + ((type) & 0xff))
++
++#define ELF64_R_SYM(i)                        ((i) >> 32)
++#define ELF64_R_TYPE(i)                       ((i) & 0xffffffff)
++#define ELF64_R_INFO(sym,type)                ((((Elf64_Xword) (sym)) << 32) + (type))
++
++/* Program segment header.  */
++
++typedef struct
++{
++  Elf32_Word  p_type;                 /* Segment type */
++  Elf32_Off   p_offset;               /* Segment file offset */
++  Elf32_Addr  p_vaddr;                /* Segment virtual address */
++  Elf32_Addr  p_paddr;                /* Segment physical address */
++  Elf32_Word  p_filesz;               /* Segment size in file */
++  Elf32_Word  p_memsz;                /* Segment size in memory */
++  Elf32_Word  p_flags;                /* Segment flags */
++  Elf32_Word  p_align;                /* Segment alignment */
++} Elf32_Phdr;
++
++typedef struct
++{
++  Elf64_Word  p_type;                 /* Segment type */
++  Elf64_Word  p_flags;                /* Segment flags */
++  Elf64_Off   p_offset;               /* Segment file offset */
++  Elf64_Addr  p_vaddr;                /* Segment virtual address */
++  Elf64_Addr  p_paddr;                /* Segment physical address */
++  Elf64_Xword p_filesz;               /* Segment size in file */
++  Elf64_Xword p_memsz;                /* Segment size in memory */
++  Elf64_Xword p_align;                /* Segment alignment */
++} Elf64_Phdr;
++
++/* Special value for e_phnum.  This indicates that the real number of
++   program headers is too large to fit into e_phnum.  Instead the real
++   value is in the field sh_info of section 0.  */
++
++#define PN_XNUM               0xffff
++
++/* Legal values for p_type (segment type).  */
++
++#define       PT_NULL         0               /* Program header table entry unused */
++#define PT_LOAD               1               /* Loadable program segment */
++#define PT_DYNAMIC    2               /* Dynamic linking information */
++#define PT_INTERP     3               /* Program interpreter */
++#define PT_NOTE               4               /* Auxiliary information */
++#define PT_SHLIB      5               /* Reserved */
++#define PT_PHDR               6               /* Entry for header table itself */
++#define PT_TLS                7               /* Thread-local storage segment */
++#define       PT_NUM          8               /* Number of defined types */
++#define PT_LOOS               0x60000000      /* Start of OS-specific */
++#define PT_GNU_EH_FRAME       0x6474e550      /* GCC .eh_frame_hdr segment */
++#define PT_GNU_STACK  0x6474e551      /* Indicates stack executability */
++#define PT_GNU_RELRO  0x6474e552      /* Read-only after relocation */
++#define PT_LOSUNW     0x6ffffffa
++#define PT_SUNWBSS    0x6ffffffa      /* Sun Specific segment */
++#define PT_SUNWSTACK  0x6ffffffb      /* Stack segment */
++#define PT_HISUNW     0x6fffffff
++#define PT_HIOS               0x6fffffff      /* End of OS-specific */
++#define PT_LOPROC     0x70000000      /* Start of processor-specific */
++#define PT_HIPROC     0x7fffffff      /* End of processor-specific */
++
++/* Legal values for p_flags (segment flags).  */
++
++#define PF_X          (1 << 0)        /* Segment is executable */
++#define PF_W          (1 << 1)        /* Segment is writable */
++#define PF_R          (1 << 2)        /* Segment is readable */
++#define PF_MASKOS     0x0ff00000      /* OS-specific */
++#define PF_MASKPROC   0xf0000000      /* Processor-specific */
++
++/* Legal values for note segment descriptor types for core files. */
++
++#define NT_PRSTATUS   1               /* Contains copy of prstatus struct */
++#define NT_FPREGSET   2               /* Contains copy of fpregset struct */
++#define NT_PRPSINFO   3               /* Contains copy of prpsinfo struct */
++#define NT_PRXREG     4               /* Contains copy of prxregset struct */
++#define NT_TASKSTRUCT 4               /* Contains copy of task structure */
++#define NT_PLATFORM   5               /* String from sysinfo(SI_PLATFORM) */
++#define NT_AUXV               6               /* Contains copy of auxv array */
++#define NT_GWINDOWS   7               /* Contains copy of gwindows struct */
++#define NT_ASRS               8               /* Contains copy of asrset struct */
++#define NT_PSTATUS    10              /* Contains copy of pstatus struct */
++#define NT_PSINFO     13              /* Contains copy of psinfo struct */
++#define NT_PRCRED     14              /* Contains copy of prcred struct */
++#define NT_UTSNAME    15              /* Contains copy of utsname struct */
++#define NT_LWPSTATUS  16              /* Contains copy of lwpstatus struct */
++#define NT_LWPSINFO   17              /* Contains copy of lwpinfo struct */
++#define NT_PRFPXREG   20              /* Contains copy of fprxregset struct */
++#define NT_PRXFPREG   0x46e62b7f      /* Contains copy of user_fxsr_struct */
++#define NT_PPC_VMX    0x100           /* PowerPC Altivec/VMX registers */
++#define NT_PPC_SPE    0x101           /* PowerPC SPE/EVR registers */
++#define NT_PPC_VSX    0x102           /* PowerPC VSX registers */
++#define NT_386_TLS    0x200           /* i386 TLS slots (struct user_desc) */
++#define NT_386_IOPERM 0x201           /* x86 io permission bitmap (1=deny) */
++#define NT_X86_XSTATE 0x202           /* x86 extended state using xsave */
++
++/* Legal values for the note segment descriptor types for object files.  */
++
++#define NT_VERSION    1               /* Contains a version string.  */
++
++
++/* Dynamic section entry.  */
++
++typedef struct
++{
++  Elf32_Sword d_tag;                  /* Dynamic entry type */
++  union
++    {
++      Elf32_Word d_val;                       /* Integer value */
++      Elf32_Addr d_ptr;                       /* Address value */
++    } d_un;
++} Elf32_Dyn;
++
++typedef struct
++{
++  Elf64_Sxword        d_tag;                  /* Dynamic entry type */
++  union
++    {
++      Elf64_Xword d_val;              /* Integer value */
++      Elf64_Addr d_ptr;                       /* Address value */
++    } d_un;
++} Elf64_Dyn;
++
++/* Legal values for d_tag (dynamic entry type).  */
++
++#define DT_NULL               0               /* Marks end of dynamic section */
++#define DT_NEEDED     1               /* Name of needed library */
++#define DT_PLTRELSZ   2               /* Size in bytes of PLT relocs */
++#define DT_PLTGOT     3               /* Processor defined value */
++#define DT_HASH               4               /* Address of symbol hash table */
++#define DT_STRTAB     5               /* Address of string table */
++#define DT_SYMTAB     6               /* Address of symbol table */
++#define DT_RELA               7               /* Address of Rela relocs */
++#define DT_RELASZ     8               /* Total size of Rela relocs */
++#define DT_RELAENT    9               /* Size of one Rela reloc */
++#define DT_STRSZ      10              /* Size of string table */
++#define DT_SYMENT     11              /* Size of one symbol table entry */
++#define DT_INIT               12              /* Address of init function */
++#define DT_FINI               13              /* Address of termination function */
++#define DT_SONAME     14              /* Name of shared object */
++#define DT_RPATH      15              /* Library search path (deprecated) */
++#define DT_SYMBOLIC   16              /* Start symbol search here */
++#define DT_REL                17              /* Address of Rel relocs */
++#define DT_RELSZ      18              /* Total size of Rel relocs */
++#define DT_RELENT     19              /* Size of one Rel reloc */
++#define DT_PLTREL     20              /* Type of reloc in PLT */
++#define DT_DEBUG      21              /* For debugging; unspecified */
++#define DT_TEXTREL    22              /* Reloc might modify .text */
++#define DT_JMPREL     23              /* Address of PLT relocs */
++#define       DT_BIND_NOW     24              /* Process relocations of object */
++#define       DT_INIT_ARRAY   25              /* Array with addresses of init fct */
++#define       DT_FINI_ARRAY   26              /* Array with addresses of fini fct */
++#define       DT_INIT_ARRAYSZ 27              /* Size in bytes of DT_INIT_ARRAY */
++#define       DT_FINI_ARRAYSZ 28              /* Size in bytes of DT_FINI_ARRAY */
++#define DT_RUNPATH    29              /* Library search path */
++#define DT_FLAGS      30              /* Flags for the object being loaded */
++#define DT_ENCODING   32              /* Start of encoded range */
++#define DT_PREINIT_ARRAY 32           /* Array with addresses of preinit fct*/
++#define DT_PREINIT_ARRAYSZ 33         /* size in bytes of DT_PREINIT_ARRAY */
++#define       DT_NUM          34              /* Number used */
++#define DT_LOOS               0x6000000d      /* Start of OS-specific */
++#define DT_HIOS               0x6ffff000      /* End of OS-specific */
++#define DT_LOPROC     0x70000000      /* Start of processor-specific */
++#define DT_HIPROC     0x7fffffff      /* End of processor-specific */
++#define       DT_PROCNUM      DT_MIPS_NUM     /* Most used by any processor */
++
++/* DT_* entries which fall between DT_VALRNGHI & DT_VALRNGLO use the
++   Dyn.d_un.d_val field of the Elf*_Dyn structure.  This follows Sun's
++   approach.  */
++#define DT_VALRNGLO   0x6ffffd00
++#define DT_GNU_PRELINKED 0x6ffffdf5   /* Prelinking timestamp */
++#define DT_GNU_CONFLICTSZ 0x6ffffdf6  /* Size of conflict section */
++#define DT_GNU_LIBLISTSZ 0x6ffffdf7   /* Size of library list */
++#define DT_CHECKSUM   0x6ffffdf8
++#define DT_PLTPADSZ   0x6ffffdf9
++#define DT_MOVEENT    0x6ffffdfa
++#define DT_MOVESZ     0x6ffffdfb
++#define DT_FEATURE_1  0x6ffffdfc      /* Feature selection (DTF_*).  */
++#define DT_POSFLAG_1  0x6ffffdfd      /* Flags for DT_* entries, effecting
++                                         the following DT_* entry.  */
++#define DT_SYMINSZ    0x6ffffdfe      /* Size of syminfo table (in bytes) */
++#define DT_SYMINENT   0x6ffffdff      /* Entry size of syminfo */
++#define DT_VALRNGHI   0x6ffffdff
++#define DT_VALTAGIDX(tag)     (DT_VALRNGHI - (tag))   /* Reverse order! */
++#define DT_VALNUM 12
++
++/* DT_* entries which fall between DT_ADDRRNGHI & DT_ADDRRNGLO use the
++   Dyn.d_un.d_ptr field of the Elf*_Dyn structure.
++
++   If any adjustment is made to the ELF object after it has been
++   built these entries will need to be adjusted.  */
++#define DT_ADDRRNGLO  0x6ffffe00
++#define DT_GNU_HASH   0x6ffffef5      /* GNU-style hash table.  */
++#define DT_TLSDESC_PLT        0x6ffffef6
++#define DT_TLSDESC_GOT        0x6ffffef7
++#define DT_GNU_CONFLICT       0x6ffffef8      /* Start of conflict section */
++#define DT_GNU_LIBLIST        0x6ffffef9      /* Library list */
++#define DT_CONFIG     0x6ffffefa      /* Configuration information.  */
++#define DT_DEPAUDIT   0x6ffffefb      /* Dependency auditing.  */
++#define DT_AUDIT      0x6ffffefc      /* Object auditing.  */
++#define       DT_PLTPAD       0x6ffffefd      /* PLT padding.  */
++#define       DT_MOVETAB      0x6ffffefe      /* Move table.  */
++#define DT_SYMINFO    0x6ffffeff      /* Syminfo table.  */
++#define DT_ADDRRNGHI  0x6ffffeff
++#define DT_ADDRTAGIDX(tag)    (DT_ADDRRNGHI - (tag))  /* Reverse order! */
++#define DT_ADDRNUM 11
++
++/* The versioning entry types.  The next are defined as part of the
++   GNU extension.  */
++#define DT_VERSYM     0x6ffffff0
++
++#define DT_RELACOUNT  0x6ffffff9
++#define DT_RELCOUNT   0x6ffffffa
++
++/* These were chosen by Sun.  */
++#define DT_FLAGS_1    0x6ffffffb      /* State flags, see DF_1_* below.  */
++#define       DT_VERDEF       0x6ffffffc      /* Address of version definition
++                                         table */
++#define       DT_VERDEFNUM    0x6ffffffd      /* Number of version definitions */
++#define       DT_VERNEED      0x6ffffffe      /* Address of table with needed
++                                         versions */
++#define       DT_VERNEEDNUM   0x6fffffff      /* Number of needed versions */
++#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
++#define DT_VERSIONTAGNUM 16
++
++/* Sun added these machine-independent extensions in the "processor-specific"
++   range.  Be compatible.  */
++#define DT_AUXILIARY    0x7ffffffd      /* Shared object to load before self */
++#define DT_FILTER       0x7fffffff      /* Shared object to get values from */
++#define DT_EXTRATAGIDX(tag)   ((Elf32_Word)-((Elf32_Sword) (tag) <<1>>1)-1)
++#define DT_EXTRANUM   3
++
++/* Values of `d_un.d_val' in the DT_FLAGS entry.  */
++#define DF_ORIGIN     0x00000001      /* Object may use DF_ORIGIN */
++#define DF_SYMBOLIC   0x00000002      /* Symbol resolutions starts here */
++#define DF_TEXTREL    0x00000004      /* Object contains text relocations */
++#define DF_BIND_NOW   0x00000008      /* No lazy binding for this object */
++#define DF_STATIC_TLS 0x00000010      /* Module uses the static TLS model */
++
++/* State flags selectable in the `d_un.d_val' element of the DT_FLAGS_1
++   entry in the dynamic section.  */
++#define DF_1_NOW      0x00000001      /* Set RTLD_NOW for this object.  */
++#define DF_1_GLOBAL   0x00000002      /* Set RTLD_GLOBAL for this object.  */
++#define DF_1_GROUP    0x00000004      /* Set RTLD_GROUP for this object.  */
++#define DF_1_NODELETE 0x00000008      /* Set RTLD_NODELETE for this object.*/
++#define DF_1_LOADFLTR 0x00000010      /* Trigger filtee loading at runtime.*/
++#define DF_1_INITFIRST        0x00000020      /* Set RTLD_INITFIRST for this object*/
++#define DF_1_NOOPEN   0x00000040      /* Set RTLD_NOOPEN for this object.  */
++#define DF_1_ORIGIN   0x00000080      /* $ORIGIN must be handled.  */
++#define DF_1_DIRECT   0x00000100      /* Direct binding enabled.  */
++#define DF_1_TRANS    0x00000200
++#define DF_1_INTERPOSE        0x00000400      /* Object is used to interpose.  */
++#define DF_1_NODEFLIB 0x00000800      /* Ignore default lib search path.  */
++#define DF_1_NODUMP   0x00001000      /* Object can't be dldump'ed.  */
++#define DF_1_CONFALT  0x00002000      /* Configuration alternative created.*/
++#define DF_1_ENDFILTEE        0x00004000      /* Filtee terminates filters search. */
++#define       DF_1_DISPRELDNE 0x00008000      /* Disp reloc applied at build time. */
++#define       DF_1_DISPRELPND 0x00010000      /* Disp reloc applied at run-time.  */
++
++/* Flags for the feature selection in DT_FEATURE_1.  */
++#define DTF_1_PARINIT 0x00000001
++#define DTF_1_CONFEXP 0x00000002
++
++/* Flags in the DT_POSFLAG_1 entry effecting only the next DT_* entry.  */
++#define DF_P1_LAZYLOAD        0x00000001      /* Lazyload following object.  */
++#define DF_P1_GROUPPERM       0x00000002      /* Symbols from next object are not
++                                         generally available.  */
++
++/* Version definition sections.  */
++
++typedef struct
++{
++  Elf32_Half  vd_version;             /* Version revision */
++  Elf32_Half  vd_flags;               /* Version information */
++  Elf32_Half  vd_ndx;                 /* Version Index */
++  Elf32_Half  vd_cnt;                 /* Number of associated aux entries */
++  Elf32_Word  vd_hash;                /* Version name hash value */
++  Elf32_Word  vd_aux;                 /* Offset in bytes to verdaux array */
++  Elf32_Word  vd_next;                /* Offset in bytes to next verdef
++                                         entry */
++} Elf32_Verdef;
++
++typedef struct
++{
++  Elf64_Half  vd_version;             /* Version revision */
++  Elf64_Half  vd_flags;               /* Version information */
++  Elf64_Half  vd_ndx;                 /* Version Index */
++  Elf64_Half  vd_cnt;                 /* Number of associated aux entries */
++  Elf64_Word  vd_hash;                /* Version name hash value */
++  Elf64_Word  vd_aux;                 /* Offset in bytes to verdaux array */
++  Elf64_Word  vd_next;                /* Offset in bytes to next verdef
++                                         entry */
++} Elf64_Verdef;
++
++
++/* Legal values for vd_version (version revision).  */
++#define VER_DEF_NONE  0               /* No version */
++#define VER_DEF_CURRENT       1               /* Current version */
++#define VER_DEF_NUM   2               /* Given version number */
++
++/* Legal values for vd_flags (version information flags).  */
++#define VER_FLG_BASE  0x1             /* Version definition of file itself */
++#define VER_FLG_WEAK  0x2             /* Weak version identifier */
++
++/* Versym symbol index values.  */
++#define       VER_NDX_LOCAL           0       /* Symbol is local.  */
++#define       VER_NDX_GLOBAL          1       /* Symbol is global.  */
++#define       VER_NDX_LORESERVE       0xff00  /* Beginning of reserved entries.  */
++#define       VER_NDX_ELIMINATE       0xff01  /* Symbol is to be eliminated.  */
++
++/* Auxialiary version information.  */
++
++typedef struct
++{
++  Elf32_Word  vda_name;               /* Version or dependency names */
++  Elf32_Word  vda_next;               /* Offset in bytes to next verdaux
++                                         entry */
++} Elf32_Verdaux;
++
++typedef struct
++{
++  Elf64_Word  vda_name;               /* Version or dependency names */
++  Elf64_Word  vda_next;               /* Offset in bytes to next verdaux
++                                         entry */
++} Elf64_Verdaux;
++
++
++/* Version dependency section.  */
++
++typedef struct
++{
++  Elf32_Half  vn_version;             /* Version of structure */
++  Elf32_Half  vn_cnt;                 /* Number of associated aux entries */
++  Elf32_Word  vn_file;                /* Offset of filename for this
++                                         dependency */
++  Elf32_Word  vn_aux;                 /* Offset in bytes to vernaux array */
++  Elf32_Word  vn_next;                /* Offset in bytes to next verneed
++                                         entry */
++} Elf32_Verneed;
++
++typedef struct
++{
++  Elf64_Half  vn_version;             /* Version of structure */
++  Elf64_Half  vn_cnt;                 /* Number of associated aux entries */
++  Elf64_Word  vn_file;                /* Offset of filename for this
++                                         dependency */
++  Elf64_Word  vn_aux;                 /* Offset in bytes to vernaux array */
++  Elf64_Word  vn_next;                /* Offset in bytes to next verneed
++                                         entry */
++} Elf64_Verneed;
++
++
++/* Legal values for vn_version (version revision).  */
++#define VER_NEED_NONE  0              /* No version */
++#define VER_NEED_CURRENT 1            /* Current version */
++#define VER_NEED_NUM   2              /* Given version number */
++
++/* Auxiliary needed version information.  */
++
++typedef struct
++{
++  Elf32_Word  vna_hash;               /* Hash value of dependency name */
++  Elf32_Half  vna_flags;              /* Dependency specific information */
++  Elf32_Half  vna_other;              /* Unused */
++  Elf32_Word  vna_name;               /* Dependency name string offset */
++  Elf32_Word  vna_next;               /* Offset in bytes to next vernaux
++                                         entry */
++} Elf32_Vernaux;
++
++typedef struct
++{
++  Elf64_Word  vna_hash;               /* Hash value of dependency name */
++  Elf64_Half  vna_flags;              /* Dependency specific information */
++  Elf64_Half  vna_other;              /* Unused */
++  Elf64_Word  vna_name;               /* Dependency name string offset */
++  Elf64_Word  vna_next;               /* Offset in bytes to next vernaux
++                                         entry */
++} Elf64_Vernaux;
++
++
++/* Legal values for vna_flags.  */
++#define VER_FLG_WEAK  0x2             /* Weak version identifier */
++
++
++/* Auxiliary vector.  */
++
++/* This vector is normally only used by the program interpreter.  The
++   usual definition in an ABI supplement uses the name auxv_t.  The
++   vector is not usually defined in a standard <elf.h> file, but it
++   can't hurt.  We rename it to avoid conflicts.  The sizes of these
++   types are an arrangement between the exec server and the program
++   interpreter, so we don't fully specify them here.  */
++
++typedef struct
++{
++  uint32_t a_type;            /* Entry type */
++  union
++    {
++      uint32_t a_val;         /* Integer value */
++      /* We use to have pointer elements added here.  We cannot do that,
++       though, since it does not work when using 32-bit definitions
++       on 64-bit platforms and vice versa.  */
++    } a_un;
++} Elf32_auxv_t;
++
++typedef struct
++{
++  uint64_t a_type;            /* Entry type */
++  union
++    {
++      uint64_t a_val;         /* Integer value */
++      /* We use to have pointer elements added here.  We cannot do that,
++       though, since it does not work when using 32-bit definitions
++       on 64-bit platforms and vice versa.  */
++    } a_un;
++} Elf64_auxv_t;
++
++/* Legal values for a_type (entry type).  */
++
++#define AT_NULL               0               /* End of vector */
++#define AT_IGNORE     1               /* Entry should be ignored */
++#define AT_EXECFD     2               /* File descriptor of program */
++#define AT_PHDR               3               /* Program headers for program */
++#define AT_PHENT      4               /* Size of program header entry */
++#define AT_PHNUM      5               /* Number of program headers */
++#define AT_PAGESZ     6               /* System page size */
++#define AT_BASE               7               /* Base address of interpreter */
++#define AT_FLAGS      8               /* Flags */
++#define AT_ENTRY      9               /* Entry point of program */
++#define AT_NOTELF     10              /* Program is not ELF */
++#define AT_UID                11              /* Real uid */
++#define AT_EUID               12              /* Effective uid */
++#define AT_GID                13              /* Real gid */
++#define AT_EGID               14              /* Effective gid */
++#define AT_CLKTCK     17              /* Frequency of times() */
++
++/* Some more special a_type values describing the hardware.  */
++#define AT_PLATFORM   15              /* String identifying platform.  */
++#define AT_HWCAP      16              /* Machine dependent hints about
++                                         processor capabilities.  */
++
++/* This entry gives some information about the FPU initialization
++   performed by the kernel.  */
++#define AT_FPUCW      18              /* Used FPU control word.  */
++
++/* Cache block sizes.  */
++#define AT_DCACHEBSIZE        19              /* Data cache block size.  */
++#define AT_ICACHEBSIZE        20              /* Instruction cache block size.  */
++#define AT_UCACHEBSIZE        21              /* Unified cache block size.  */
++
++/* A special ignored value for PPC, used by the kernel to control the
++   interpretation of the AUXV. Must be > 16.  */
++#define AT_IGNOREPPC  22              /* Entry should be ignored.  */
++
++#define       AT_SECURE       23              /* Boolean, was exec setuid-like?  */
++
++#define AT_BASE_PLATFORM 24           /* String identifying real platforms.*/
++
++#define AT_RANDOM     25              /* Address of 16 random bytes.  */
++
++#define AT_EXECFN     31              /* Filename of executable.  */
++
++/* Pointer to the global system page used for system calls and other
++   nice things.  */
++#define AT_SYSINFO    32
++#define AT_SYSINFO_EHDR       33
++
++/* Shapes of the caches.  Bits 0-3 contains associativity; bits 4-7 contains
++   log2 of line size; mask those to get cache size.  */
++#define AT_L1I_CACHESHAPE     34
++#define AT_L1D_CACHESHAPE     35
++#define AT_L2_CACHESHAPE      36
++#define AT_L3_CACHESHAPE      37
++
++/* Note section contents.  Each entry in the note section begins with
++   a header of a fixed form.  */
++
++typedef struct
++{
++  Elf32_Word n_namesz;                        /* Length of the note's name.  */
++  Elf32_Word n_descsz;                        /* Length of the note's descriptor.  */
++  Elf32_Word n_type;                  /* Type of the note.  */
++} Elf32_Nhdr;
++
++typedef struct
++{
++  Elf64_Word n_namesz;                        /* Length of the note's name.  */
++  Elf64_Word n_descsz;                        /* Length of the note's descriptor.  */
++  Elf64_Word n_type;                  /* Type of the note.  */
++} Elf64_Nhdr;
++
++/* Known names of notes.  */
++
++/* Solaris entries in the note section have this name.  */
++#define ELF_NOTE_SOLARIS      "SUNW Solaris"
++
++/* Note entries for GNU systems have this name.  */
++#define ELF_NOTE_GNU          "GNU"
++
++
++/* Defined types of notes for Solaris.  */
++
++/* Value of descriptor (one word) is desired pagesize for the binary.  */
++#define ELF_NOTE_PAGESIZE_HINT        1
++
++
++/* Defined note types for GNU systems.  */
++
++/* ABI information.  The descriptor consists of words:
++   word 0: OS descriptor
++   word 1: major version of the ABI
++   word 2: minor version of the ABI
++   word 3: subminor version of the ABI
++*/
++#define NT_GNU_ABI_TAG        1
++#define ELF_NOTE_ABI  NT_GNU_ABI_TAG /* Old name.  */
++
++/* Known OSes.  These values can appear in word 0 of an
++   NT_GNU_ABI_TAG note section entry.  */
++#define ELF_NOTE_OS_LINUX     0
++#define ELF_NOTE_OS_GNU               1
++#define ELF_NOTE_OS_SOLARIS2  2
++#define ELF_NOTE_OS_FREEBSD   3
++
++/* Synthetic hwcap information.  The descriptor begins with two words:
++   word 0: number of entries
++   word 1: bitmask of enabled entries
++   Then follow variable-length entries, one byte followed by a
++   '\0'-terminated hwcap name string.  The byte gives the bit
++   number to test if enabled, (1U << bit) & bitmask.  */
++#define NT_GNU_HWCAP  2
++
++/* Build ID bits as generated by ld --build-id.
++   The descriptor consists of any nonzero number of bytes.  */
++#define NT_GNU_BUILD_ID       3
++
++/* Version note generated by GNU gold containing a version string.  */
++#define NT_GNU_GOLD_VERSION   4
++
++
++/* Move records.  */
++typedef struct
++{
++  Elf32_Xword m_value;                /* Symbol value.  */
++  Elf32_Word m_info;          /* Size and index.  */
++  Elf32_Word m_poffset;               /* Symbol offset.  */
++  Elf32_Half m_repeat;                /* Repeat count.  */
++  Elf32_Half m_stride;                /* Stride info.  */
++} Elf32_Move;
++
++typedef struct
++{
++  Elf64_Xword m_value;                /* Symbol value.  */
++  Elf64_Xword m_info;         /* Size and index.  */
++  Elf64_Xword m_poffset;      /* Symbol offset.  */
++  Elf64_Half m_repeat;                /* Repeat count.  */
++  Elf64_Half m_stride;                /* Stride info.  */
++} Elf64_Move;
++
++/* Macro to construct move records.  */
++#define ELF32_M_SYM(info)     ((info) >> 8)
++#define ELF32_M_SIZE(info)    ((unsigned char) (info))
++#define ELF32_M_INFO(sym, size)       (((sym) << 8) + (unsigned char) (size))
++
++#define ELF64_M_SYM(info)     ELF32_M_SYM (info)
++#define ELF64_M_SIZE(info)    ELF32_M_SIZE (info)
++#define ELF64_M_INFO(sym, size)       ELF32_M_INFO (sym, size)
++
++
++/* Motorola 68k specific definitions.  */
++
++/* Values for Elf32_Ehdr.e_flags.  */
++#define EF_CPU32      0x00810000
++
++/* m68k relocs.  */
++
++#define R_68K_NONE    0               /* No reloc */
++#define R_68K_32      1               /* Direct 32 bit  */
++#define R_68K_16      2               /* Direct 16 bit  */
++#define R_68K_8               3               /* Direct 8 bit  */
++#define R_68K_PC32    4               /* PC relative 32 bit */
++#define R_68K_PC16    5               /* PC relative 16 bit */
++#define R_68K_PC8     6               /* PC relative 8 bit */
++#define R_68K_GOT32   7               /* 32 bit PC relative GOT entry */
++#define R_68K_GOT16   8               /* 16 bit PC relative GOT entry */
++#define R_68K_GOT8    9               /* 8 bit PC relative GOT entry */
++#define R_68K_GOT32O  10              /* 32 bit GOT offset */
++#define R_68K_GOT16O  11              /* 16 bit GOT offset */
++#define R_68K_GOT8O   12              /* 8 bit GOT offset */
++#define R_68K_PLT32   13              /* 32 bit PC relative PLT address */
++#define R_68K_PLT16   14              /* 16 bit PC relative PLT address */
++#define R_68K_PLT8    15              /* 8 bit PC relative PLT address */
++#define R_68K_PLT32O  16              /* 32 bit PLT offset */
++#define R_68K_PLT16O  17              /* 16 bit PLT offset */
++#define R_68K_PLT8O   18              /* 8 bit PLT offset */
++#define R_68K_COPY    19              /* Copy symbol at runtime */
++#define R_68K_GLOB_DAT        20              /* Create GOT entry */
++#define R_68K_JMP_SLOT        21              /* Create PLT entry */
++#define R_68K_RELATIVE        22              /* Adjust by program base */
++#define R_68K_TLS_GD32      25          /* 32 bit GOT offset for GD */
++#define R_68K_TLS_GD16      26          /* 16 bit GOT offset for GD */
++#define R_68K_TLS_GD8       27          /* 8 bit GOT offset for GD */
++#define R_68K_TLS_LDM32     28          /* 32 bit GOT offset for LDM */
++#define R_68K_TLS_LDM16     29          /* 16 bit GOT offset for LDM */
++#define R_68K_TLS_LDM8      30          /* 8 bit GOT offset for LDM */
++#define R_68K_TLS_LDO32     31          /* 32 bit module-relative offset */
++#define R_68K_TLS_LDO16     32          /* 16 bit module-relative offset */
++#define R_68K_TLS_LDO8      33          /* 8 bit module-relative offset */
++#define R_68K_TLS_IE32      34          /* 32 bit GOT offset for IE */
++#define R_68K_TLS_IE16      35          /* 16 bit GOT offset for IE */
++#define R_68K_TLS_IE8       36          /* 8 bit GOT offset for IE */
++#define R_68K_TLS_LE32      37          /* 32 bit offset relative to
++                                         static TLS block */
++#define R_68K_TLS_LE16      38          /* 16 bit offset relative to
++                                         static TLS block */
++#define R_68K_TLS_LE8       39          /* 8 bit offset relative to
++                                         static TLS block */
++#define R_68K_TLS_DTPMOD32  40          /* 32 bit module number */
++#define R_68K_TLS_DTPREL32  41          /* 32 bit module-relative offset */
++#define R_68K_TLS_TPREL32   42          /* 32 bit TP-relative offset */
++/* Keep this the last entry.  */
++#define R_68K_NUM     43
++
++/* Intel 80386 specific definitions.  */
++
++/* i386 relocs.  */
++
++#define R_386_NONE       0            /* No reloc */
++#define R_386_32         1            /* Direct 32 bit  */
++#define R_386_PC32       2            /* PC relative 32 bit */
++#define R_386_GOT32      3            /* 32 bit GOT entry */
++#define R_386_PLT32      4            /* 32 bit PLT address */
++#define R_386_COPY       5            /* Copy symbol at runtime */
++#define R_386_GLOB_DAT           6            /* Create GOT entry */
++#define R_386_JMP_SLOT           7            /* Create PLT entry */
++#define R_386_RELATIVE           8            /* Adjust by program base */
++#define R_386_GOTOFF     9            /* 32 bit offset to GOT */
++#define R_386_GOTPC      10           /* 32 bit PC relative offset to GOT */
++#define R_386_32PLT      11
++#define R_386_TLS_TPOFF          14           /* Offset in static TLS block */
++#define R_386_TLS_IE     15           /* Address of GOT entry for static TLS
++                                         block offset */
++#define R_386_TLS_GOTIE          16           /* GOT entry for static TLS block
++                                         offset */
++#define R_386_TLS_LE     17           /* Offset relative to static TLS
++                                         block */
++#define R_386_TLS_GD     18           /* Direct 32 bit for GNU version of
++                                         general dynamic thread local data */
++#define R_386_TLS_LDM    19           /* Direct 32 bit for GNU version of
++                                         local dynamic thread local data
++                                         in LE code */
++#define R_386_16         20
++#define R_386_PC16       21
++#define R_386_8                  22
++#define R_386_PC8        23
++#define R_386_TLS_GD_32          24           /* Direct 32 bit for general dynamic
++                                         thread local data */
++#define R_386_TLS_GD_PUSH  25         /* Tag for pushl in GD TLS code */
++#define R_386_TLS_GD_CALL  26         /* Relocation for call to
++                                         __tls_get_addr() */
++#define R_386_TLS_GD_POP   27         /* Tag for popl in GD TLS code */
++#define R_386_TLS_LDM_32   28         /* Direct 32 bit for local dynamic
++                                         thread local data in LE code */
++#define R_386_TLS_LDM_PUSH 29         /* Tag for pushl in LDM TLS code */
++#define R_386_TLS_LDM_CALL 30         /* Relocation for call to
++                                         __tls_get_addr() in LDM code */
++#define R_386_TLS_LDM_POP  31         /* Tag for popl in LDM TLS code */
++#define R_386_TLS_LDO_32   32         /* Offset relative to TLS block */
++#define R_386_TLS_IE_32          33           /* GOT entry for negated static TLS
++                                         block offset */
++#define R_386_TLS_LE_32          34           /* Negated offset relative to static
++                                         TLS block */
++#define R_386_TLS_DTPMOD32 35         /* ID of module containing symbol */
++#define R_386_TLS_DTPOFF32 36         /* Offset in TLS block */
++#define R_386_TLS_TPOFF32  37         /* Negated offset in static TLS block */
++/* 38? */
++#define R_386_TLS_GOTDESC  39         /* GOT offset for TLS descriptor.  */
++#define R_386_TLS_DESC_CALL 40                /* Marker of call through TLS
++                                         descriptor for
++                                         relaxation.  */
++#define R_386_TLS_DESC     41         /* TLS descriptor containing
++                                         pointer to code and to
++                                         argument, returning the TLS
++                                         offset for the symbol.  */
++#define R_386_IRELATIVE          42           /* Adjust indirectly by program base */
++/* Keep this the last entry.  */
++#define R_386_NUM        43
++
++/* SUN SPARC specific definitions.  */
++
++/* Legal values for ST_TYPE subfield of st_info (symbol type).  */
++
++#define STT_SPARC_REGISTER    13      /* Global register reserved to app. */
++
++/* Values for Elf64_Ehdr.e_flags.  */
++
++#define EF_SPARCV9_MM         3
++#define EF_SPARCV9_TSO                0
++#define EF_SPARCV9_PSO                1
++#define EF_SPARCV9_RMO                2
++#define EF_SPARC_LEDATA               0x800000 /* little endian data */
++#define EF_SPARC_EXT_MASK     0xFFFF00
++#define EF_SPARC_32PLUS               0x000100 /* generic V8+ features */
++#define EF_SPARC_SUN_US1      0x000200 /* Sun UltraSPARC1 extensions */
++#define EF_SPARC_HAL_R1               0x000400 /* HAL R1 extensions */
++#define EF_SPARC_SUN_US3      0x000800 /* Sun UltraSPARCIII extensions */
++
++/* SPARC relocs.  */
++
++#define R_SPARC_NONE          0       /* No reloc */
++#define R_SPARC_8             1       /* Direct 8 bit */
++#define R_SPARC_16            2       /* Direct 16 bit */
++#define R_SPARC_32            3       /* Direct 32 bit */
++#define R_SPARC_DISP8         4       /* PC relative 8 bit */
++#define R_SPARC_DISP16                5       /* PC relative 16 bit */
++#define R_SPARC_DISP32                6       /* PC relative 32 bit */
++#define R_SPARC_WDISP30               7       /* PC relative 30 bit shifted */
++#define R_SPARC_WDISP22               8       /* PC relative 22 bit shifted */
++#define R_SPARC_HI22          9       /* High 22 bit */
++#define R_SPARC_22            10      /* Direct 22 bit */
++#define R_SPARC_13            11      /* Direct 13 bit */
++#define R_SPARC_LO10          12      /* Truncated 10 bit */
++#define R_SPARC_GOT10         13      /* Truncated 10 bit GOT entry */
++#define R_SPARC_GOT13         14      /* 13 bit GOT entry */
++#define R_SPARC_GOT22         15      /* 22 bit GOT entry shifted */
++#define R_SPARC_PC10          16      /* PC relative 10 bit truncated */
++#define R_SPARC_PC22          17      /* PC relative 22 bit shifted */
++#define R_SPARC_WPLT30                18      /* 30 bit PC relative PLT address */
++#define R_SPARC_COPY          19      /* Copy symbol at runtime */
++#define R_SPARC_GLOB_DAT      20      /* Create GOT entry */
++#define R_SPARC_JMP_SLOT      21      /* Create PLT entry */
++#define R_SPARC_RELATIVE      22      /* Adjust by program base */
++#define R_SPARC_UA32          23      /* Direct 32 bit unaligned */
++
++/* Additional Sparc64 relocs.  */
++
++#define R_SPARC_PLT32         24      /* Direct 32 bit ref to PLT entry */
++#define R_SPARC_HIPLT22               25      /* High 22 bit PLT entry */
++#define R_SPARC_LOPLT10               26      /* Truncated 10 bit PLT entry */
++#define R_SPARC_PCPLT32               27      /* PC rel 32 bit ref to PLT entry */
++#define R_SPARC_PCPLT22               28      /* PC rel high 22 bit PLT entry */
++#define R_SPARC_PCPLT10               29      /* PC rel trunc 10 bit PLT entry */
++#define R_SPARC_10            30      /* Direct 10 bit */
++#define R_SPARC_11            31      /* Direct 11 bit */
++#define R_SPARC_64            32      /* Direct 64 bit */
++#define R_SPARC_OLO10         33      /* 10bit with secondary 13bit addend */
++#define R_SPARC_HH22          34      /* Top 22 bits of direct 64 bit */
++#define R_SPARC_HM10          35      /* High middle 10 bits of ... */
++#define R_SPARC_LM22          36      /* Low middle 22 bits of ... */
++#define R_SPARC_PC_HH22               37      /* Top 22 bits of pc rel 64 bit */
++#define R_SPARC_PC_HM10               38      /* High middle 10 bit of ... */
++#define R_SPARC_PC_LM22               39      /* Low miggle 22 bits of ... */
++#define R_SPARC_WDISP16               40      /* PC relative 16 bit shifted */
++#define R_SPARC_WDISP19               41      /* PC relative 19 bit shifted */
++#define R_SPARC_GLOB_JMP      42      /* was part of v9 ABI but was removed */
++#define R_SPARC_7             43      /* Direct 7 bit */
++#define R_SPARC_5             44      /* Direct 5 bit */
++#define R_SPARC_6             45      /* Direct 6 bit */
++#define R_SPARC_DISP64                46      /* PC relative 64 bit */
++#define R_SPARC_PLT64         47      /* Direct 64 bit ref to PLT entry */
++#define R_SPARC_HIX22         48      /* High 22 bit complemented */
++#define R_SPARC_LOX10         49      /* Truncated 11 bit complemented */
++#define R_SPARC_H44           50      /* Direct high 12 of 44 bit */
++#define R_SPARC_M44           51      /* Direct mid 22 of 44 bit */
++#define R_SPARC_L44           52      /* Direct low 10 of 44 bit */
++#define R_SPARC_REGISTER      53      /* Global register usage */
++#define R_SPARC_UA64          54      /* Direct 64 bit unaligned */
++#define R_SPARC_UA16          55      /* Direct 16 bit unaligned */
++#define R_SPARC_TLS_GD_HI22   56
++#define R_SPARC_TLS_GD_LO10   57
++#define R_SPARC_TLS_GD_ADD    58
++#define R_SPARC_TLS_GD_CALL   59
++#define R_SPARC_TLS_LDM_HI22  60
++#define R_SPARC_TLS_LDM_LO10  61
++#define R_SPARC_TLS_LDM_ADD   62
++#define R_SPARC_TLS_LDM_CALL  63
++#define R_SPARC_TLS_LDO_HIX22 64
++#define R_SPARC_TLS_LDO_LOX10 65
++#define R_SPARC_TLS_LDO_ADD   66
++#define R_SPARC_TLS_IE_HI22   67
++#define R_SPARC_TLS_IE_LO10   68
++#define R_SPARC_TLS_IE_LD     69
++#define R_SPARC_TLS_IE_LDX    70
++#define R_SPARC_TLS_IE_ADD    71
++#define R_SPARC_TLS_LE_HIX22  72
++#define R_SPARC_TLS_LE_LOX10  73
++#define R_SPARC_TLS_DTPMOD32  74
++#define R_SPARC_TLS_DTPMOD64  75
++#define R_SPARC_TLS_DTPOFF32  76
++#define R_SPARC_TLS_DTPOFF64  77
++#define R_SPARC_TLS_TPOFF32   78
++#define R_SPARC_TLS_TPOFF64   79
++#define R_SPARC_GOTDATA_HIX22 80
++#define R_SPARC_GOTDATA_LOX10 81
++#define R_SPARC_GOTDATA_OP_HIX22      82
++#define R_SPARC_GOTDATA_OP_LOX10      83
++#define R_SPARC_GOTDATA_OP    84
++#define R_SPARC_H34           85
++#define R_SPARC_SIZE32                86
++#define R_SPARC_SIZE64                87
++#define R_SPARC_WDISP10               88
++#define R_SPARC_JMP_IREL      248
++#define R_SPARC_IRELATIVE     249
++#define R_SPARC_GNU_VTINHERIT 250
++#define R_SPARC_GNU_VTENTRY   251
++#define R_SPARC_REV32         252
++/* Keep this the last entry.  */
++#define R_SPARC_NUM           253
++
++/* For Sparc64, legal values for d_tag of Elf64_Dyn.  */
++
++#define DT_SPARC_REGISTER 0x70000001
++#define DT_SPARC_NUM  2
++
++/* MIPS R3000 specific definitions.  */
++
++/* Legal values for e_flags field of Elf32_Ehdr.  */
++
++#define EF_MIPS_NOREORDER   1         /* A .noreorder directive was used */
++#define EF_MIPS_PIC       2           /* Contains PIC code */
++#define EF_MIPS_CPIC      4           /* Uses PIC calling sequence */
++#define EF_MIPS_XGOT      8
++#define EF_MIPS_64BIT_WHIRL 16
++#define EF_MIPS_ABI2      32
++#define EF_MIPS_ABI_ON32    64
++#define EF_MIPS_ARCH      0xf0000000  /* MIPS architecture level */
++
++/* Legal values for MIPS architecture level.  */
++
++#define EF_MIPS_ARCH_1            0x00000000  /* -mips1 code.  */
++#define EF_MIPS_ARCH_2            0x10000000  /* -mips2 code.  */
++#define EF_MIPS_ARCH_3            0x20000000  /* -mips3 code.  */
++#define EF_MIPS_ARCH_4            0x30000000  /* -mips4 code.  */
++#define EF_MIPS_ARCH_5            0x40000000  /* -mips5 code.  */
++#define EF_MIPS_ARCH_32           0x60000000  /* MIPS32 code.  */
++#define EF_MIPS_ARCH_64           0x70000000  /* MIPS64 code.  */
++
++/* The following are non-official names and should not be used.  */
++
++#define E_MIPS_ARCH_1   0x00000000    /* -mips1 code.  */
++#define E_MIPS_ARCH_2   0x10000000    /* -mips2 code.  */
++#define E_MIPS_ARCH_3   0x20000000    /* -mips3 code.  */
++#define E_MIPS_ARCH_4   0x30000000    /* -mips4 code.  */
++#define E_MIPS_ARCH_5   0x40000000    /* -mips5 code.  */
++#define E_MIPS_ARCH_32          0x60000000    /* MIPS32 code.  */
++#define E_MIPS_ARCH_64          0x70000000    /* MIPS64 code.  */
++
++/* Special section indices.  */
++
++#define SHN_MIPS_ACOMMON    0xff00    /* Allocated common symbols */
++#define SHN_MIPS_TEXT     0xff01      /* Allocated test symbols.  */
++#define SHN_MIPS_DATA     0xff02      /* Allocated data symbols.  */
++#define SHN_MIPS_SCOMMON    0xff03    /* Small common symbols */
++#define SHN_MIPS_SUNDEFINED 0xff04    /* Small undefined symbols */
++
++/* Legal values for sh_type field of Elf32_Shdr.  */
++
++#define SHT_MIPS_LIBLIST       0x70000000 /* Shared objects used in link */
++#define SHT_MIPS_MSYM        0x70000001
++#define SHT_MIPS_CONFLICT      0x70000002 /* Conflicting symbols */
++#define SHT_MIPS_GPTAB               0x70000003 /* Global data area sizes */
++#define SHT_MIPS_UCODE               0x70000004 /* Reserved for SGI/MIPS compilers */
++#define SHT_MIPS_DEBUG               0x70000005 /* MIPS ECOFF debugging information*/
++#define SHT_MIPS_REGINFO       0x70000006 /* Register usage information */
++#define SHT_MIPS_PACKAGE       0x70000007
++#define SHT_MIPS_PACKSYM       0x70000008
++#define SHT_MIPS_RELD        0x70000009
++#define SHT_MIPS_IFACE         0x7000000b
++#define SHT_MIPS_CONTENT       0x7000000c
++#define SHT_MIPS_OPTIONS       0x7000000d /* Miscellaneous options.  */
++#define SHT_MIPS_SHDR        0x70000010
++#define SHT_MIPS_FDESC               0x70000011
++#define SHT_MIPS_EXTSYM              0x70000012
++#define SHT_MIPS_DENSE               0x70000013
++#define SHT_MIPS_PDESC               0x70000014
++#define SHT_MIPS_LOCSYM              0x70000015
++#define SHT_MIPS_AUXSYM              0x70000016
++#define SHT_MIPS_OPTSYM              0x70000017
++#define SHT_MIPS_LOCSTR              0x70000018
++#define SHT_MIPS_LINE        0x70000019
++#define SHT_MIPS_RFDESC              0x7000001a
++#define SHT_MIPS_DELTASYM      0x7000001b
++#define SHT_MIPS_DELTAINST     0x7000001c
++#define SHT_MIPS_DELTACLASS    0x7000001d
++#define SHT_MIPS_DWARF         0x7000001e /* DWARF debugging information.  */
++#define SHT_MIPS_DELTADECL     0x7000001f
++#define SHT_MIPS_SYMBOL_LIB    0x70000020
++#define SHT_MIPS_EVENTS              0x70000021 /* Event section.  */
++#define SHT_MIPS_TRANSLATE     0x70000022
++#define SHT_MIPS_PIXIE               0x70000023
++#define SHT_MIPS_XLATE               0x70000024
++#define SHT_MIPS_XLATE_DEBUG   0x70000025
++#define SHT_MIPS_WHIRL               0x70000026
++#define SHT_MIPS_EH_REGION     0x70000027
++#define SHT_MIPS_XLATE_OLD     0x70000028
++#define SHT_MIPS_PDR_EXCEPTION 0x70000029
++
++/* Legal values for sh_flags field of Elf32_Shdr.  */
++
++#define SHF_MIPS_GPREL         0x10000000     /* Must be part of global data area */
++#define SHF_MIPS_MERGE         0x20000000
++#define SHF_MIPS_ADDR  0x40000000
++#define SHF_MIPS_STRINGS 0x80000000
++#define SHF_MIPS_NOSTRIP 0x08000000
++#define SHF_MIPS_LOCAL         0x04000000
++#define SHF_MIPS_NAMES         0x02000000
++#define SHF_MIPS_NODUPE        0x01000000
++
++
++/* Symbol tables.  */
++
++/* MIPS specific values for `st_other'.  */
++#define STO_MIPS_DEFAULT              0x0
++#define STO_MIPS_INTERNAL             0x1
++#define STO_MIPS_HIDDEN                       0x2
++#define STO_MIPS_PROTECTED            0x3
++#define STO_MIPS_PLT                  0x8
++#define STO_MIPS_SC_ALIGN_UNUSED      0xff
++
++/* MIPS specific values for `st_info'.  */
++#define STB_MIPS_SPLIT_COMMON         13
++
++/* Entries found in sections of type SHT_MIPS_GPTAB.  */
++
++typedef union
++{
++  struct
++    {
++      Elf32_Word gt_current_g_value;  /* -G value used for compilation */
++      Elf32_Word gt_unused;           /* Not used */
++    } gt_header;                      /* First entry in section */
++  struct
++    {
++      Elf32_Word gt_g_value;          /* If this value were used for -G */
++      Elf32_Word gt_bytes;            /* This many bytes would be used */
++    } gt_entry;                               /* Subsequent entries in section */
++} Elf32_gptab;
++
++/* Entry found in sections of type SHT_MIPS_REGINFO.  */
++
++typedef struct
++{
++  Elf32_Word  ri_gprmask;             /* General registers used */
++  Elf32_Word  ri_cprmask[4];          /* Coprocessor registers used */
++  Elf32_Sword ri_gp_value;            /* $gp register value */
++} Elf32_RegInfo;
++
++/* Entries found in sections of type SHT_MIPS_OPTIONS.  */
++
++typedef struct
++{
++  unsigned char kind;         /* Determines interpretation of the
++                                 variable part of descriptor.  */
++  unsigned char size;         /* Size of descriptor, including header.  */
++  Elf32_Section section;      /* Section header index of section affected,
++                                 0 for global options.  */
++  Elf32_Word info;            /* Kind-specific information.  */
++} Elf_Options;
++
++/* Values for `kind' field in Elf_Options.  */
++
++#define ODK_NULL      0       /* Undefined.  */
++#define ODK_REGINFO   1       /* Register usage information.  */
++#define ODK_EXCEPTIONS        2       /* Exception processing options.  */
++#define ODK_PAD               3       /* Section padding options.  */
++#define ODK_HWPATCH   4       /* Hardware workarounds performed */
++#define ODK_FILL      5       /* record the fill value used by the linker. */
++#define ODK_TAGS      6       /* reserve space for desktop tools to write. */
++#define ODK_HWAND     7       /* HW workarounds.  'AND' bits when merging. */
++#define ODK_HWOR      8       /* HW workarounds.  'OR' bits when merging.  */
++
++/* Values for `info' in Elf_Options for ODK_EXCEPTIONS entries.  */
++
++#define OEX_FPU_MIN   0x1f    /* FPE's which MUST be enabled.  */
++#define OEX_FPU_MAX   0x1f00  /* FPE's which MAY be enabled.  */
++#define OEX_PAGE0     0x10000 /* page zero must be mapped.  */
++#define OEX_SMM               0x20000 /* Force sequential memory mode?  */
++#define OEX_FPDBUG    0x40000 /* Force floating point debug mode?  */
++#define OEX_PRECISEFP OEX_FPDBUG
++#define OEX_DISMISS   0x80000 /* Dismiss invalid address faults?  */
++
++#define OEX_FPU_INVAL 0x10
++#define OEX_FPU_DIV0  0x08
++#define OEX_FPU_OFLO  0x04
++#define OEX_FPU_UFLO  0x02
++#define OEX_FPU_INEX  0x01
++
++/* Masks for `info' in Elf_Options for an ODK_HWPATCH entry.  */
++
++#define OHW_R4KEOP    0x1     /* R4000 end-of-page patch.  */
++#define OHW_R8KPFETCH 0x2     /* may need R8000 prefetch patch.  */
++#define OHW_R5KEOP    0x4     /* R5000 end-of-page patch.  */
++#define OHW_R5KCVTL   0x8     /* R5000 cvt.[ds].l bug.  clean=1.  */
++
++#define OPAD_PREFIX   0x1
++#define OPAD_POSTFIX  0x2
++#define OPAD_SYMBOL   0x4
++
++/* Entry found in `.options' section.  */
++
++typedef struct
++{
++  Elf32_Word hwp_flags1;      /* Extra flags.  */
++  Elf32_Word hwp_flags2;      /* Extra flags.  */
++} Elf_Options_Hw;
++
++/* Masks for `info' in ElfOptions for ODK_HWAND and ODK_HWOR entries.  */
++
++#define OHWA0_R4KEOP_CHECKED  0x00000001
++#define OHWA1_R4KEOP_CLEAN    0x00000002
++
++/* MIPS relocs.  */
++
++#define R_MIPS_NONE           0       /* No reloc */
++#define R_MIPS_16             1       /* Direct 16 bit */
++#define R_MIPS_32             2       /* Direct 32 bit */
++#define R_MIPS_REL32          3       /* PC relative 32 bit */
++#define R_MIPS_26             4       /* Direct 26 bit shifted */
++#define R_MIPS_HI16           5       /* High 16 bit */
++#define R_MIPS_LO16           6       /* Low 16 bit */
++#define R_MIPS_GPREL16                7       /* GP relative 16 bit */
++#define R_MIPS_LITERAL                8       /* 16 bit literal entry */
++#define R_MIPS_GOT16          9       /* 16 bit GOT entry */
++#define R_MIPS_PC16           10      /* PC relative 16 bit */
++#define R_MIPS_CALL16         11      /* 16 bit GOT entry for function */
++#define R_MIPS_GPREL32                12      /* GP relative 32 bit */
++
++#define R_MIPS_SHIFT5         16
++#define R_MIPS_SHIFT6         17
++#define R_MIPS_64             18
++#define R_MIPS_GOT_DISP               19
++#define R_MIPS_GOT_PAGE               20
++#define R_MIPS_GOT_OFST               21
++#define R_MIPS_GOT_HI16               22
++#define R_MIPS_GOT_LO16               23
++#define R_MIPS_SUB            24
++#define R_MIPS_INSERT_A               25
++#define R_MIPS_INSERT_B               26
++#define R_MIPS_DELETE         27
++#define R_MIPS_HIGHER         28
++#define R_MIPS_HIGHEST                29
++#define R_MIPS_CALL_HI16      30
++#define R_MIPS_CALL_LO16      31
++#define R_MIPS_SCN_DISP               32
++#define R_MIPS_REL16          33
++#define R_MIPS_ADD_IMMEDIATE  34
++#define R_MIPS_PJUMP          35
++#define R_MIPS_RELGOT         36
++#define R_MIPS_JALR           37
++#define R_MIPS_TLS_DTPMOD32   38      /* Module number 32 bit */
++#define R_MIPS_TLS_DTPREL32   39      /* Module-relative offset 32 bit */
++#define R_MIPS_TLS_DTPMOD64   40      /* Module number 64 bit */
++#define R_MIPS_TLS_DTPREL64   41      /* Module-relative offset 64 bit */
++#define R_MIPS_TLS_GD         42      /* 16 bit GOT offset for GD */
++#define R_MIPS_TLS_LDM                43      /* 16 bit GOT offset for LDM */
++#define R_MIPS_TLS_DTPREL_HI16        44      /* Module-relative offset, high 16 bits */
++#define R_MIPS_TLS_DTPREL_LO16        45      /* Module-relative offset, low 16 bits */
++#define R_MIPS_TLS_GOTTPREL   46      /* 16 bit GOT offset for IE */
++#define R_MIPS_TLS_TPREL32    47      /* TP-relative offset, 32 bit */
++#define R_MIPS_TLS_TPREL64    48      /* TP-relative offset, 64 bit */
++#define R_MIPS_TLS_TPREL_HI16 49      /* TP-relative offset, high 16 bits */
++#define R_MIPS_TLS_TPREL_LO16 50      /* TP-relative offset, low 16 bits */
++#define R_MIPS_GLOB_DAT               51
++#define R_MIPS_COPY           126
++#define R_MIPS_JUMP_SLOT        127
++/* Keep this the last entry.  */
++#define R_MIPS_NUM            128
++
++/* Legal values for p_type field of Elf32_Phdr.  */
++
++#define PT_MIPS_REGINFO       0x70000000      /* Register usage information */
++#define PT_MIPS_RTPROC  0x70000001    /* Runtime procedure table. */
++#define PT_MIPS_OPTIONS 0x70000002
++
++/* Special program header types.  */
++
++#define PF_MIPS_LOCAL 0x10000000
++
++/* Legal values for d_tag field of Elf32_Dyn.  */
++
++#define DT_MIPS_RLD_VERSION  0x70000001       /* Runtime linker interface version */
++#define DT_MIPS_TIME_STAMP   0x70000002       /* Timestamp */
++#define DT_MIPS_ICHECKSUM    0x70000003       /* Checksum */
++#define DT_MIPS_IVERSION     0x70000004       /* Version string (string tbl index) */
++#define DT_MIPS_FLAGS      0x70000005 /* Flags */
++#define DT_MIPS_BASE_ADDRESS 0x70000006       /* Base address */
++#define DT_MIPS_MSYM       0x70000007
++#define DT_MIPS_CONFLICT     0x70000008       /* Address of CONFLICT section */
++#define DT_MIPS_LIBLIST            0x70000009 /* Address of LIBLIST section */
++#define DT_MIPS_LOCAL_GOTNO  0x7000000a       /* Number of local GOT entries */
++#define DT_MIPS_CONFLICTNO   0x7000000b       /* Number of CONFLICT entries */
++#define DT_MIPS_LIBLISTNO    0x70000010       /* Number of LIBLIST entries */
++#define DT_MIPS_SYMTABNO     0x70000011       /* Number of DYNSYM entries */
++#define DT_MIPS_UNREFEXTNO   0x70000012       /* First external DYNSYM */
++#define DT_MIPS_GOTSYM             0x70000013 /* First GOT entry in DYNSYM */
++#define DT_MIPS_HIPAGENO     0x70000014       /* Number of GOT page table entries */
++#define DT_MIPS_RLD_MAP            0x70000016 /* Address of run time loader map.  */
++#define DT_MIPS_DELTA_CLASS  0x70000017       /* Delta C++ class definition.  */
++#define DT_MIPS_DELTA_CLASS_NO    0x70000018 /* Number of entries in
++                                              DT_MIPS_DELTA_CLASS.  */
++#define DT_MIPS_DELTA_INSTANCE    0x70000019 /* Delta C++ class instances.  */
++#define DT_MIPS_DELTA_INSTANCE_NO 0x7000001a /* Number of entries in
++                                              DT_MIPS_DELTA_INSTANCE.  */
++#define DT_MIPS_DELTA_RELOC  0x7000001b /* Delta relocations.  */
++#define DT_MIPS_DELTA_RELOC_NO 0x7000001c /* Number of entries in
++                                           DT_MIPS_DELTA_RELOC.  */
++#define DT_MIPS_DELTA_SYM    0x7000001d /* Delta symbols that Delta
++                                         relocations refer to.  */
++#define DT_MIPS_DELTA_SYM_NO 0x7000001e /* Number of entries in
++                                         DT_MIPS_DELTA_SYM.  */
++#define DT_MIPS_DELTA_CLASSSYM 0x70000020 /* Delta symbols that hold the
++                                           class declaration.  */
++#define DT_MIPS_DELTA_CLASSSYM_NO 0x70000021 /* Number of entries in
++                                              DT_MIPS_DELTA_CLASSSYM.  */
++#define DT_MIPS_CXX_FLAGS    0x70000022 /* Flags indicating for C++ flavor.  */
++#define DT_MIPS_PIXIE_INIT   0x70000023
++#define DT_MIPS_SYMBOL_LIB   0x70000024
++#define DT_MIPS_LOCALPAGE_GOTIDX 0x70000025
++#define DT_MIPS_LOCAL_GOTIDX 0x70000026
++#define DT_MIPS_HIDDEN_GOTIDX 0x70000027
++#define DT_MIPS_PROTECTED_GOTIDX 0x70000028
++#define DT_MIPS_OPTIONS            0x70000029 /* Address of .options.  */
++#define DT_MIPS_INTERFACE    0x7000002a /* Address of .interface.  */
++#define DT_MIPS_DYNSTR_ALIGN 0x7000002b
++#define DT_MIPS_INTERFACE_SIZE 0x7000002c /* Size of the .interface section. */
++#define DT_MIPS_RLD_TEXT_RESOLVE_ADDR 0x7000002d /* Address of rld_text_rsolve
++                                                  function stored in GOT.  */
++#define DT_MIPS_PERF_SUFFIX  0x7000002e /* Default suffix of dso to be added
++                                         by rld on dlopen() calls.  */
++#define DT_MIPS_COMPACT_SIZE 0x7000002f /* (O32)Size of compact rel section. */
++#define DT_MIPS_GP_VALUE     0x70000030 /* GP value for aux GOTs.  */
++#define DT_MIPS_AUX_DYNAMIC  0x70000031 /* Address of aux .dynamic.  */
++/* The address of .got.plt in an executable using the new non-PIC ABI.  */
++#define DT_MIPS_PLTGOT             0x70000032
++/* The base of the PLT in an executable using the new non-PIC ABI if that
++   PLT is writable.  For a non-writable PLT, this is omitted or has a zero
++   value.  */
++#define DT_MIPS_RWPLT        0x70000034
++#define DT_MIPS_NUM        0x35
++
++/* Legal values for DT_MIPS_FLAGS Elf32_Dyn entry.  */
++
++#define RHF_NONE                 0            /* No flags */
++#define RHF_QUICKSTART                   (1 << 0)     /* Use quickstart */
++#define RHF_NOTPOT               (1 << 1)     /* Hash size not power of 2 */
++#define RHF_NO_LIBRARY_REPLACEMENT (1 << 2)   /* Ignore LD_LIBRARY_PATH */
++#define RHF_NO_MOVE              (1 << 3)
++#define RHF_SGI_ONLY             (1 << 4)
++#define RHF_GUARANTEE_INIT       (1 << 5)
++#define RHF_DELTA_C_PLUS_PLUS    (1 << 6)
++#define RHF_GUARANTEE_START_INIT   (1 << 7)
++#define RHF_PIXIE                (1 << 8)
++#define RHF_DEFAULT_DELAY_LOAD           (1 << 9)
++#define RHF_REQUICKSTART         (1 << 10)
++#define RHF_REQUICKSTARTED       (1 << 11)
++#define RHF_CORD                 (1 << 12)
++#define RHF_NO_UNRES_UNDEF       (1 << 13)
++#define RHF_RLD_ORDER_SAFE       (1 << 14)
++
++/* Entries found in sections of type SHT_MIPS_LIBLIST.  */
++
++typedef struct
++{
++  Elf32_Word l_name;          /* Name (string table index) */
++  Elf32_Word l_time_stamp;    /* Timestamp */
++  Elf32_Word l_checksum;      /* Checksum */
++  Elf32_Word l_version;               /* Interface version */
++  Elf32_Word l_flags;         /* Flags */
++} Elf32_Lib;
++
++typedef struct
++{
++  Elf64_Word l_name;          /* Name (string table index) */
++  Elf64_Word l_time_stamp;    /* Timestamp */
++  Elf64_Word l_checksum;      /* Checksum */
++  Elf64_Word l_version;               /* Interface version */
++  Elf64_Word l_flags;         /* Flags */
++} Elf64_Lib;
++
++
++/* Legal values for l_flags.  */
++
++#define LL_NONE                 0
++#define LL_EXACT_MATCH          (1 << 0)      /* Require exact match */
++#define LL_IGNORE_INT_VER (1 << 1)    /* Ignore interface version */
++#define LL_REQUIRE_MINOR  (1 << 2)
++#define LL_EXPORTS      (1 << 3)
++#define LL_DELAY_LOAD   (1 << 4)
++#define LL_DELTA        (1 << 5)
++
++/* Entries found in sections of type SHT_MIPS_CONFLICT.  */
++
++typedef Elf32_Addr Elf32_Conflict;
++
++
++/* HPPA specific definitions.  */
++
++/* Legal values for e_flags field of Elf32_Ehdr.  */
++
++#define EF_PARISC_TRAPNIL     0x00010000 /* Trap nil pointer dereference.  */
++#define EF_PARISC_EXT         0x00020000 /* Program uses arch. extensions. */
++#define EF_PARISC_LSB         0x00040000 /* Program expects little endian. */
++#define EF_PARISC_WIDE                0x00080000 /* Program expects wide mode.  */
++#define EF_PARISC_NO_KABP     0x00100000 /* No kernel assisted branch
++                                            prediction.  */
++#define EF_PARISC_LAZYSWAP    0x00400000 /* Allow lazy swapping.  */
++#define EF_PARISC_ARCH                0x0000ffff /* Architecture version.  */
++
++/* Defined values for `e_flags & EF_PARISC_ARCH' are:  */
++
++#define EFA_PARISC_1_0                    0x020b /* PA-RISC 1.0 big-endian.  */
++#define EFA_PARISC_1_1                    0x0210 /* PA-RISC 1.1 big-endian.  */
++#define EFA_PARISC_2_0                    0x0214 /* PA-RISC 2.0 big-endian.  */
++
++/* Additional section indeces.  */
++
++#define SHN_PARISC_ANSI_COMMON        0xff00     /* Section for tenatively declared
++                                            symbols in ANSI C.  */
++#define SHN_PARISC_HUGE_COMMON        0xff01     /* Common blocks in huge model.  */
++
++/* Legal values for sh_type field of Elf32_Shdr.  */
++
++#define SHT_PARISC_EXT                0x70000000 /* Contains product specific ext. */
++#define SHT_PARISC_UNWIND     0x70000001 /* Unwind information.  */
++#define SHT_PARISC_DOC                0x70000002 /* Debug info for optimized code. */
++
++/* Legal values for sh_flags field of Elf32_Shdr.  */
++
++#define SHF_PARISC_SHORT      0x20000000 /* Section with short addressing. */
++#define SHF_PARISC_HUGE               0x40000000 /* Section far from gp.  */
++#define SHF_PARISC_SBP                0x80000000 /* Static branch prediction code. */
++
++/* Legal values for ST_TYPE subfield of st_info (symbol type).  */
++
++#define STT_PARISC_MILLICODE  13      /* Millicode function entry point.  */
++
++#define STT_HP_OPAQUE         (STT_LOOS + 0x1)
++#define STT_HP_STUB           (STT_LOOS + 0x2)
++
++/* HPPA relocs.  */
++
++#define R_PARISC_NONE         0       /* No reloc.  */
++#define R_PARISC_DIR32                1       /* Direct 32-bit reference.  */
++#define R_PARISC_DIR21L               2       /* Left 21 bits of eff. address.  */
++#define R_PARISC_DIR17R               3       /* Right 17 bits of eff. address.  */
++#define R_PARISC_DIR17F               4       /* 17 bits of eff. address.  */
++#define R_PARISC_DIR14R               6       /* Right 14 bits of eff. address.  */
++#define R_PARISC_PCREL32      9       /* 32-bit rel. address.  */
++#define R_PARISC_PCREL21L     10      /* Left 21 bits of rel. address.  */
++#define R_PARISC_PCREL17R     11      /* Right 17 bits of rel. address.  */
++#define R_PARISC_PCREL17F     12      /* 17 bits of rel. address.  */
++#define R_PARISC_PCREL14R     14      /* Right 14 bits of rel. address.  */
++#define R_PARISC_DPREL21L     18      /* Left 21 bits of rel. address.  */
++#define R_PARISC_DPREL14R     22      /* Right 14 bits of rel. address.  */
++#define R_PARISC_GPREL21L     26      /* GP-relative, left 21 bits.  */
++#define R_PARISC_GPREL14R     30      /* GP-relative, right 14 bits.  */
++#define R_PARISC_LTOFF21L     34      /* LT-relative, left 21 bits.  */
++#define R_PARISC_LTOFF14R     38      /* LT-relative, right 14 bits.  */
++#define R_PARISC_SECREL32     41      /* 32 bits section rel. address.  */
++#define R_PARISC_SEGBASE      48      /* No relocation, set segment base.  */
++#define R_PARISC_SEGREL32     49      /* 32 bits segment rel. address.  */
++#define R_PARISC_PLTOFF21L    50      /* PLT rel. address, left 21 bits.  */
++#define R_PARISC_PLTOFF14R    54      /* PLT rel. address, right 14 bits.  */
++#define R_PARISC_LTOFF_FPTR32 57      /* 32 bits LT-rel. function pointer. */
++#define R_PARISC_LTOFF_FPTR21L        58      /* LT-rel. fct ptr, left 21 bits. */
++#define R_PARISC_LTOFF_FPTR14R        62      /* LT-rel. fct ptr, right 14 bits. */
++#define R_PARISC_FPTR64               64      /* 64 bits function address.  */
++#define R_PARISC_PLABEL32     65      /* 32 bits function address.  */
++#define R_PARISC_PLABEL21L    66      /* Left 21 bits of fdesc address.  */
++#define R_PARISC_PLABEL14R    70      /* Right 14 bits of fdesc address.  */
++#define R_PARISC_PCREL64      72      /* 64 bits PC-rel. address.  */
++#define R_PARISC_PCREL22F     74      /* 22 bits PC-rel. address.  */
++#define R_PARISC_PCREL14WR    75      /* PC-rel. address, right 14 bits.  */
++#define R_PARISC_PCREL14DR    76      /* PC rel. address, right 14 bits.  */
++#define R_PARISC_PCREL16F     77      /* 16 bits PC-rel. address.  */
++#define R_PARISC_PCREL16WF    78      /* 16 bits PC-rel. address.  */
++#define R_PARISC_PCREL16DF    79      /* 16 bits PC-rel. address.  */
++#define R_PARISC_DIR64                80      /* 64 bits of eff. address.  */
++#define R_PARISC_DIR14WR      83      /* 14 bits of eff. address.  */
++#define R_PARISC_DIR14DR      84      /* 14 bits of eff. address.  */
++#define R_PARISC_DIR16F               85      /* 16 bits of eff. address.  */
++#define R_PARISC_DIR16WF      86      /* 16 bits of eff. address.  */
++#define R_PARISC_DIR16DF      87      /* 16 bits of eff. address.  */
++#define R_PARISC_GPREL64      88      /* 64 bits of GP-rel. address.  */
++#define R_PARISC_GPREL14WR    91      /* GP-rel. address, right 14 bits.  */
++#define R_PARISC_GPREL14DR    92      /* GP-rel. address, right 14 bits.  */
++#define R_PARISC_GPREL16F     93      /* 16 bits GP-rel. address.  */
++#define R_PARISC_GPREL16WF    94      /* 16 bits GP-rel. address.  */
++#define R_PARISC_GPREL16DF    95      /* 16 bits GP-rel. address.  */
++#define R_PARISC_LTOFF64      96      /* 64 bits LT-rel. address.  */
++#define R_PARISC_LTOFF14WR    99      /* LT-rel. address, right 14 bits.  */
++#define R_PARISC_LTOFF14DR    100     /* LT-rel. address, right 14 bits.  */
++#define R_PARISC_LTOFF16F     101     /* 16 bits LT-rel. address.  */
++#define R_PARISC_LTOFF16WF    102     /* 16 bits LT-rel. address.  */
++#define R_PARISC_LTOFF16DF    103     /* 16 bits LT-rel. address.  */
++#define R_PARISC_SECREL64     104     /* 64 bits section rel. address.  */
++#define R_PARISC_SEGREL64     112     /* 64 bits segment rel. address.  */
++#define R_PARISC_PLTOFF14WR   115     /* PLT-rel. address, right 14 bits.  */
++#define R_PARISC_PLTOFF14DR   116     /* PLT-rel. address, right 14 bits.  */
++#define R_PARISC_PLTOFF16F    117     /* 16 bits LT-rel. address.  */
++#define R_PARISC_PLTOFF16WF   118     /* 16 bits PLT-rel. address.  */
++#define R_PARISC_PLTOFF16DF   119     /* 16 bits PLT-rel. address.  */
++#define R_PARISC_LTOFF_FPTR64 120     /* 64 bits LT-rel. function ptr.  */
++#define R_PARISC_LTOFF_FPTR14WR       123     /* LT-rel. fct. ptr., right 14 bits. */
++#define R_PARISC_LTOFF_FPTR14DR       124     /* LT-rel. fct. ptr., right 14 bits. */
++#define R_PARISC_LTOFF_FPTR16F        125     /* 16 bits LT-rel. function ptr.  */
++#define R_PARISC_LTOFF_FPTR16WF       126     /* 16 bits LT-rel. function ptr.  */
++#define R_PARISC_LTOFF_FPTR16DF       127     /* 16 bits LT-rel. function ptr.  */
++#define R_PARISC_LORESERVE    128
++#define R_PARISC_COPY         128     /* Copy relocation.  */
++#define R_PARISC_IPLT         129     /* Dynamic reloc, imported PLT */
++#define R_PARISC_EPLT         130     /* Dynamic reloc, exported PLT */
++#define R_PARISC_TPREL32      153     /* 32 bits TP-rel. address.  */
++#define R_PARISC_TPREL21L     154     /* TP-rel. address, left 21 bits.  */
++#define R_PARISC_TPREL14R     158     /* TP-rel. address, right 14 bits.  */
++#define R_PARISC_LTOFF_TP21L  162     /* LT-TP-rel. address, left 21 bits. */
++#define R_PARISC_LTOFF_TP14R  166     /* LT-TP-rel. address, right 14 bits.*/
++#define R_PARISC_LTOFF_TP14F  167     /* 14 bits LT-TP-rel. address.  */
++#define R_PARISC_TPREL64      216     /* 64 bits TP-rel. address.  */
++#define R_PARISC_TPREL14WR    219     /* TP-rel. address, right 14 bits.  */
++#define R_PARISC_TPREL14DR    220     /* TP-rel. address, right 14 bits.  */
++#define R_PARISC_TPREL16F     221     /* 16 bits TP-rel. address.  */
++#define R_PARISC_TPREL16WF    222     /* 16 bits TP-rel. address.  */
++#define R_PARISC_TPREL16DF    223     /* 16 bits TP-rel. address.  */
++#define R_PARISC_LTOFF_TP64   224     /* 64 bits LT-TP-rel. address.  */
++#define R_PARISC_LTOFF_TP14WR 227     /* LT-TP-rel. address, right 14 bits.*/
++#define R_PARISC_LTOFF_TP14DR 228     /* LT-TP-rel. address, right 14 bits.*/
++#define R_PARISC_LTOFF_TP16F  229     /* 16 bits LT-TP-rel. address.  */
++#define R_PARISC_LTOFF_TP16WF 230     /* 16 bits LT-TP-rel. address.  */
++#define R_PARISC_LTOFF_TP16DF 231     /* 16 bits LT-TP-rel. address.  */
++#define R_PARISC_GNU_VTENTRY  232
++#define R_PARISC_GNU_VTINHERIT        233
++#define R_PARISC_TLS_GD21L    234     /* GD 21-bit left.  */
++#define R_PARISC_TLS_GD14R    235     /* GD 14-bit right.  */
++#define R_PARISC_TLS_GDCALL   236     /* GD call to __t_g_a.  */
++#define R_PARISC_TLS_LDM21L   237     /* LD module 21-bit left.  */
++#define R_PARISC_TLS_LDM14R   238     /* LD module 14-bit right.  */
++#define R_PARISC_TLS_LDMCALL  239     /* LD module call to __t_g_a.  */
++#define R_PARISC_TLS_LDO21L   240     /* LD offset 21-bit left.  */
++#define R_PARISC_TLS_LDO14R   241     /* LD offset 14-bit right.  */
++#define R_PARISC_TLS_DTPMOD32 242     /* DTP module 32-bit.  */
++#define R_PARISC_TLS_DTPMOD64 243     /* DTP module 64-bit.  */
++#define R_PARISC_TLS_DTPOFF32 244     /* DTP offset 32-bit.  */
++#define R_PARISC_TLS_DTPOFF64 245     /* DTP offset 32-bit.  */
++#define R_PARISC_TLS_LE21L    R_PARISC_TPREL21L
++#define R_PARISC_TLS_LE14R    R_PARISC_TPREL14R
++#define R_PARISC_TLS_IE21L    R_PARISC_LTOFF_TP21L
++#define R_PARISC_TLS_IE14R    R_PARISC_LTOFF_TP14R
++#define R_PARISC_TLS_TPREL32  R_PARISC_TPREL32
++#define R_PARISC_TLS_TPREL64  R_PARISC_TPREL64
++#define R_PARISC_HIRESERVE    255
++
++/* Legal values for p_type field of Elf32_Phdr/Elf64_Phdr.  */
++
++#define PT_HP_TLS             (PT_LOOS + 0x0)
++#define PT_HP_CORE_NONE               (PT_LOOS + 0x1)
++#define PT_HP_CORE_VERSION    (PT_LOOS + 0x2)
++#define PT_HP_CORE_KERNEL     (PT_LOOS + 0x3)
++#define PT_HP_CORE_COMM               (PT_LOOS + 0x4)
++#define PT_HP_CORE_PROC               (PT_LOOS + 0x5)
++#define PT_HP_CORE_LOADABLE   (PT_LOOS + 0x6)
++#define PT_HP_CORE_STACK      (PT_LOOS + 0x7)
++#define PT_HP_CORE_SHM                (PT_LOOS + 0x8)
++#define PT_HP_CORE_MMF                (PT_LOOS + 0x9)
++#define PT_HP_PARALLEL                (PT_LOOS + 0x10)
++#define PT_HP_FASTBIND                (PT_LOOS + 0x11)
++#define PT_HP_OPT_ANNOT               (PT_LOOS + 0x12)
++#define PT_HP_HSL_ANNOT               (PT_LOOS + 0x13)
++#define PT_HP_STACK           (PT_LOOS + 0x14)
++
++#define PT_PARISC_ARCHEXT     0x70000000
++#define PT_PARISC_UNWIND      0x70000001
++
++/* Legal values for p_flags field of Elf32_Phdr/Elf64_Phdr.  */
++
++#define PF_PARISC_SBP         0x08000000
++
++#define PF_HP_PAGE_SIZE               0x00100000
++#define PF_HP_FAR_SHARED      0x00200000
++#define PF_HP_NEAR_SHARED     0x00400000
++#define PF_HP_CODE            0x01000000
++#define PF_HP_MODIFY          0x02000000
++#define PF_HP_LAZYSWAP                0x04000000
++#define PF_HP_SBP             0x08000000
++
++
++/* Alpha specific definitions.  */
++
++/* Legal values for e_flags field of Elf64_Ehdr.  */
++
++#define EF_ALPHA_32BIT                1       /* All addresses must be < 2GB.  */
++#define EF_ALPHA_CANRELAX     2       /* Relocations for relaxing exist.  */
++
++/* Legal values for sh_type field of Elf64_Shdr.  */
++
++/* These two are primerily concerned with ECOFF debugging info.  */
++#define SHT_ALPHA_DEBUG               0x70000001
++#define SHT_ALPHA_REGINFO     0x70000002
++
++/* Legal values for sh_flags field of Elf64_Shdr.  */
++
++#define SHF_ALPHA_GPREL               0x10000000
++
++/* Legal values for st_other field of Elf64_Sym.  */
++#define STO_ALPHA_NOPV                0x80    /* No PV required.  */
++#define STO_ALPHA_STD_GPLOAD  0x88    /* PV only used for initial ldgp.  */
++
++/* Alpha relocs.  */
++
++#define R_ALPHA_NONE          0       /* No reloc */
++#define R_ALPHA_REFLONG               1       /* Direct 32 bit */
++#define R_ALPHA_REFQUAD               2       /* Direct 64 bit */
++#define R_ALPHA_GPREL32               3       /* GP relative 32 bit */
++#define R_ALPHA_LITERAL               4       /* GP relative 16 bit w/optimization */
++#define R_ALPHA_LITUSE                5       /* Optimization hint for LITERAL */
++#define R_ALPHA_GPDISP                6       /* Add displacement to GP */
++#define R_ALPHA_BRADDR                7       /* PC+4 relative 23 bit shifted */
++#define R_ALPHA_HINT          8       /* PC+4 relative 16 bit shifted */
++#define R_ALPHA_SREL16                9       /* PC relative 16 bit */
++#define R_ALPHA_SREL32                10      /* PC relative 32 bit */
++#define R_ALPHA_SREL64                11      /* PC relative 64 bit */
++#define R_ALPHA_GPRELHIGH     17      /* GP relative 32 bit, high 16 bits */
++#define R_ALPHA_GPRELLOW      18      /* GP relative 32 bit, low 16 bits */
++#define R_ALPHA_GPREL16               19      /* GP relative 16 bit */
++#define R_ALPHA_COPY          24      /* Copy symbol at runtime */
++#define R_ALPHA_GLOB_DAT      25      /* Create GOT entry */
++#define R_ALPHA_JMP_SLOT      26      /* Create PLT entry */
++#define R_ALPHA_RELATIVE      27      /* Adjust by program base */
++#define R_ALPHA_TLS_GD_HI     28
++#define R_ALPHA_TLSGD         29
++#define R_ALPHA_TLS_LDM               30
++#define R_ALPHA_DTPMOD64      31
++#define R_ALPHA_GOTDTPREL     32
++#define R_ALPHA_DTPREL64      33
++#define R_ALPHA_DTPRELHI      34
++#define R_ALPHA_DTPRELLO      35
++#define R_ALPHA_DTPREL16      36
++#define R_ALPHA_GOTTPREL      37
++#define R_ALPHA_TPREL64               38
++#define R_ALPHA_TPRELHI               39
++#define R_ALPHA_TPRELLO               40
++#define R_ALPHA_TPREL16               41
++/* Keep this the last entry.  */
++#define R_ALPHA_NUM           46
++
++/* Magic values of the LITUSE relocation addend.  */
++#define LITUSE_ALPHA_ADDR     0
++#define LITUSE_ALPHA_BASE     1
++#define LITUSE_ALPHA_BYTOFF   2
++#define LITUSE_ALPHA_JSR      3
++#define LITUSE_ALPHA_TLS_GD   4
++#define LITUSE_ALPHA_TLS_LDM  5
++
++/* Legal values for d_tag of Elf64_Dyn.  */
++#define DT_ALPHA_PLTRO                (DT_LOPROC + 0)
++#define DT_ALPHA_NUM          1
++
++/* PowerPC specific declarations */
++
++/* Values for Elf32/64_Ehdr.e_flags.  */
++#define EF_PPC_EMB            0x80000000      /* PowerPC embedded flag */
++
++/* Cygnus local bits below */
++#define EF_PPC_RELOCATABLE    0x00010000      /* PowerPC -mrelocatable flag*/
++#define EF_PPC_RELOCATABLE_LIB        0x00008000      /* PowerPC -mrelocatable-lib
++                                                 flag */
++
++/* PowerPC relocations defined by the ABIs */
++#define R_PPC_NONE            0
++#define R_PPC_ADDR32          1       /* 32bit absolute address */
++#define R_PPC_ADDR24          2       /* 26bit address, 2 bits ignored.  */
++#define R_PPC_ADDR16          3       /* 16bit absolute address */
++#define R_PPC_ADDR16_LO               4       /* lower 16bit of absolute address */
++#define R_PPC_ADDR16_HI               5       /* high 16bit of absolute address */
++#define R_PPC_ADDR16_HA               6       /* adjusted high 16bit */
++#define R_PPC_ADDR14          7       /* 16bit address, 2 bits ignored */
++#define R_PPC_ADDR14_BRTAKEN  8
++#define R_PPC_ADDR14_BRNTAKEN 9
++#define R_PPC_REL24           10      /* PC relative 26 bit */
++#define R_PPC_REL14           11      /* PC relative 16 bit */
++#define R_PPC_REL14_BRTAKEN   12
++#define R_PPC_REL14_BRNTAKEN  13
++#define R_PPC_GOT16           14
++#define R_PPC_GOT16_LO                15
++#define R_PPC_GOT16_HI                16
++#define R_PPC_GOT16_HA                17
++#define R_PPC_PLTREL24                18
++#define R_PPC_COPY            19
++#define R_PPC_GLOB_DAT                20
++#define R_PPC_JMP_SLOT                21
++#define R_PPC_RELATIVE                22
++#define R_PPC_LOCAL24PC               23
++#define R_PPC_UADDR32         24
++#define R_PPC_UADDR16         25
++#define R_PPC_REL32           26
++#define R_PPC_PLT32           27
++#define R_PPC_PLTREL32                28
++#define R_PPC_PLT16_LO                29
++#define R_PPC_PLT16_HI                30
++#define R_PPC_PLT16_HA                31
++#define R_PPC_SDAREL16                32
++#define R_PPC_SECTOFF         33
++#define R_PPC_SECTOFF_LO      34
++#define R_PPC_SECTOFF_HI      35
++#define R_PPC_SECTOFF_HA      36
++
++/* PowerPC relocations defined for the TLS access ABI.  */
++#define R_PPC_TLS             67 /* none      (sym+add)@tls */
++#define R_PPC_DTPMOD32                68 /* word32    (sym+add)@dtpmod */
++#define R_PPC_TPREL16         69 /* half16*   (sym+add)@tprel */
++#define R_PPC_TPREL16_LO      70 /* half16    (sym+add)@tprel@l */
++#define R_PPC_TPREL16_HI      71 /* half16    (sym+add)@tprel@h */
++#define R_PPC_TPREL16_HA      72 /* half16    (sym+add)@tprel@ha */
++#define R_PPC_TPREL32         73 /* word32    (sym+add)@tprel */
++#define R_PPC_DTPREL16                74 /* half16*   (sym+add)@dtprel */
++#define R_PPC_DTPREL16_LO     75 /* half16    (sym+add)@dtprel@l */
++#define R_PPC_DTPREL16_HI     76 /* half16    (sym+add)@dtprel@h */
++#define R_PPC_DTPREL16_HA     77 /* half16    (sym+add)@dtprel@ha */
++#define R_PPC_DTPREL32                78 /* word32    (sym+add)@dtprel */
++#define R_PPC_GOT_TLSGD16     79 /* half16*   (sym+add)@got@tlsgd */
++#define R_PPC_GOT_TLSGD16_LO  80 /* half16    (sym+add)@got@tlsgd@l */
++#define R_PPC_GOT_TLSGD16_HI  81 /* half16    (sym+add)@got@tlsgd@h */
++#define R_PPC_GOT_TLSGD16_HA  82 /* half16    (sym+add)@got@tlsgd@ha */
++#define R_PPC_GOT_TLSLD16     83 /* half16*   (sym+add)@got@tlsld */
++#define R_PPC_GOT_TLSLD16_LO  84 /* half16    (sym+add)@got@tlsld@l */
++#define R_PPC_GOT_TLSLD16_HI  85 /* half16    (sym+add)@got@tlsld@h */
++#define R_PPC_GOT_TLSLD16_HA  86 /* half16    (sym+add)@got@tlsld@ha */
++#define R_PPC_GOT_TPREL16     87 /* half16*   (sym+add)@got@tprel */
++#define R_PPC_GOT_TPREL16_LO  88 /* half16    (sym+add)@got@tprel@l */
++#define R_PPC_GOT_TPREL16_HI  89 /* half16    (sym+add)@got@tprel@h */
++#define R_PPC_GOT_TPREL16_HA  90 /* half16    (sym+add)@got@tprel@ha */
++#define R_PPC_GOT_DTPREL16    91 /* half16*   (sym+add)@got@dtprel */
++#define R_PPC_GOT_DTPREL16_LO 92 /* half16*   (sym+add)@got@dtprel@l */
++#define R_PPC_GOT_DTPREL16_HI 93 /* half16*   (sym+add)@got@dtprel@h */
++#define R_PPC_GOT_DTPREL16_HA 94 /* half16*   (sym+add)@got@dtprel@ha */
++
++/* The remaining relocs are from the Embedded ELF ABI, and are not
++   in the SVR4 ELF ABI.  */
++#define R_PPC_EMB_NADDR32     101
++#define R_PPC_EMB_NADDR16     102
++#define R_PPC_EMB_NADDR16_LO  103
++#define R_PPC_EMB_NADDR16_HI  104
++#define R_PPC_EMB_NADDR16_HA  105
++#define R_PPC_EMB_SDAI16      106
++#define R_PPC_EMB_SDA2I16     107
++#define R_PPC_EMB_SDA2REL     108
++#define R_PPC_EMB_SDA21               109     /* 16 bit offset in SDA */
++#define R_PPC_EMB_MRKREF      110
++#define R_PPC_EMB_RELSEC16    111
++#define R_PPC_EMB_RELST_LO    112
++#define R_PPC_EMB_RELST_HI    113
++#define R_PPC_EMB_RELST_HA    114
++#define R_PPC_EMB_BIT_FLD     115
++#define R_PPC_EMB_RELSDA      116     /* 16 bit relative offset in SDA */
++
++/* Diab tool relocations.  */
++#define R_PPC_DIAB_SDA21_LO   180     /* like EMB_SDA21, but lower 16 bit */
++#define R_PPC_DIAB_SDA21_HI   181     /* like EMB_SDA21, but high 16 bit */
++#define R_PPC_DIAB_SDA21_HA   182     /* like EMB_SDA21, adjusted high 16 */
++#define R_PPC_DIAB_RELSDA_LO  183     /* like EMB_RELSDA, but lower 16 bit */
++#define R_PPC_DIAB_RELSDA_HI  184     /* like EMB_RELSDA, but high 16 bit */
++#define R_PPC_DIAB_RELSDA_HA  185     /* like EMB_RELSDA, adjusted high 16 */
++
++/* GNU extension to support local ifunc.  */
++#define R_PPC_IRELATIVE               248
++
++/* GNU relocs used in PIC code sequences.  */
++#define R_PPC_REL16           249     /* half16   (sym+add-.) */
++#define R_PPC_REL16_LO                250     /* half16   (sym+add-.)@l */
++#define R_PPC_REL16_HI                251     /* half16   (sym+add-.)@h */
++#define R_PPC_REL16_HA                252     /* half16   (sym+add-.)@ha */
++
++/* This is a phony reloc to handle any old fashioned TOC16 references
++   that may still be in object files.  */
++#define R_PPC_TOC16           255
++
++/* PowerPC specific values for the Dyn d_tag field.  */
++#define DT_PPC_GOT            (DT_LOPROC + 0)
++#define DT_PPC_NUM            1
++
++/* PowerPC64 relocations defined by the ABIs */
++#define R_PPC64_NONE          R_PPC_NONE
++#define R_PPC64_ADDR32                R_PPC_ADDR32 /* 32bit absolute address */
++#define R_PPC64_ADDR24                R_PPC_ADDR24 /* 26bit address, word aligned */
++#define R_PPC64_ADDR16                R_PPC_ADDR16 /* 16bit absolute address */
++#define R_PPC64_ADDR16_LO     R_PPC_ADDR16_LO /* lower 16bits of address */
++#define R_PPC64_ADDR16_HI     R_PPC_ADDR16_HI /* high 16bits of address. */
++#define R_PPC64_ADDR16_HA     R_PPC_ADDR16_HA /* adjusted high 16bits.  */
++#define R_PPC64_ADDR14                R_PPC_ADDR14 /* 16bit address, word aligned */
++#define R_PPC64_ADDR14_BRTAKEN        R_PPC_ADDR14_BRTAKEN
++#define R_PPC64_ADDR14_BRNTAKEN       R_PPC_ADDR14_BRNTAKEN
++#define R_PPC64_REL24         R_PPC_REL24 /* PC-rel. 26 bit, word aligned */
++#define R_PPC64_REL14         R_PPC_REL14 /* PC relative 16 bit */
++#define R_PPC64_REL14_BRTAKEN R_PPC_REL14_BRTAKEN
++#define R_PPC64_REL14_BRNTAKEN        R_PPC_REL14_BRNTAKEN
++#define R_PPC64_GOT16         R_PPC_GOT16
++#define R_PPC64_GOT16_LO      R_PPC_GOT16_LO
++#define R_PPC64_GOT16_HI      R_PPC_GOT16_HI
++#define R_PPC64_GOT16_HA      R_PPC_GOT16_HA
++
++#define R_PPC64_COPY          R_PPC_COPY
++#define R_PPC64_GLOB_DAT      R_PPC_GLOB_DAT
++#define R_PPC64_JMP_SLOT      R_PPC_JMP_SLOT
++#define R_PPC64_RELATIVE      R_PPC_RELATIVE
++
++#define R_PPC64_UADDR32               R_PPC_UADDR32
++#define R_PPC64_UADDR16               R_PPC_UADDR16
++#define R_PPC64_REL32         R_PPC_REL32
++#define R_PPC64_PLT32         R_PPC_PLT32
++#define R_PPC64_PLTREL32      R_PPC_PLTREL32
++#define R_PPC64_PLT16_LO      R_PPC_PLT16_LO
++#define R_PPC64_PLT16_HI      R_PPC_PLT16_HI
++#define R_PPC64_PLT16_HA      R_PPC_PLT16_HA
++
++#define R_PPC64_SECTOFF               R_PPC_SECTOFF
++#define R_PPC64_SECTOFF_LO    R_PPC_SECTOFF_LO
++#define R_PPC64_SECTOFF_HI    R_PPC_SECTOFF_HI
++#define R_PPC64_SECTOFF_HA    R_PPC_SECTOFF_HA
++#define R_PPC64_ADDR30                37 /* word30 (S + A - P) >> 2 */
++#define R_PPC64_ADDR64                38 /* doubleword64 S + A */
++#define R_PPC64_ADDR16_HIGHER 39 /* half16 #higher(S + A) */
++#define R_PPC64_ADDR16_HIGHERA        40 /* half16 #highera(S + A) */
++#define R_PPC64_ADDR16_HIGHEST        41 /* half16 #highest(S + A) */
++#define R_PPC64_ADDR16_HIGHESTA       42 /* half16 #highesta(S + A) */
++#define R_PPC64_UADDR64               43 /* doubleword64 S + A */
++#define R_PPC64_REL64         44 /* doubleword64 S + A - P */
++#define R_PPC64_PLT64         45 /* doubleword64 L + A */
++#define R_PPC64_PLTREL64      46 /* doubleword64 L + A - P */
++#define R_PPC64_TOC16         47 /* half16* S + A - .TOC */
++#define R_PPC64_TOC16_LO      48 /* half16 #lo(S + A - .TOC.) */
++#define R_PPC64_TOC16_HI      49 /* half16 #hi(S + A - .TOC.) */
++#define R_PPC64_TOC16_HA      50 /* half16 #ha(S + A - .TOC.) */
++#define R_PPC64_TOC           51 /* doubleword64 .TOC */
++#define R_PPC64_PLTGOT16      52 /* half16* M + A */
++#define R_PPC64_PLTGOT16_LO   53 /* half16 #lo(M + A) */
++#define R_PPC64_PLTGOT16_HI   54 /* half16 #hi(M + A) */
++#define R_PPC64_PLTGOT16_HA   55 /* half16 #ha(M + A) */
++
++#define R_PPC64_ADDR16_DS     56 /* half16ds* (S + A) >> 2 */
++#define R_PPC64_ADDR16_LO_DS  57 /* half16ds  #lo(S + A) >> 2 */
++#define R_PPC64_GOT16_DS      58 /* half16ds* (G + A) >> 2 */
++#define R_PPC64_GOT16_LO_DS   59 /* half16ds  #lo(G + A) >> 2 */
++#define R_PPC64_PLT16_LO_DS   60 /* half16ds  #lo(L + A) >> 2 */
++#define R_PPC64_SECTOFF_DS    61 /* half16ds* (R + A) >> 2 */
++#define R_PPC64_SECTOFF_LO_DS 62 /* half16ds  #lo(R + A) >> 2 */
++#define R_PPC64_TOC16_DS      63 /* half16ds* (S + A - .TOC.) >> 2 */
++#define R_PPC64_TOC16_LO_DS   64 /* half16ds  #lo(S + A - .TOC.) >> 2 */
++#define R_PPC64_PLTGOT16_DS   65 /* half16ds* (M + A) >> 2 */
++#define R_PPC64_PLTGOT16_LO_DS        66 /* half16ds  #lo(M + A) >> 2 */
++
++/* PowerPC64 relocations defined for the TLS access ABI.  */
++#define R_PPC64_TLS           67 /* none      (sym+add)@tls */
++#define R_PPC64_DTPMOD64      68 /* doubleword64 (sym+add)@dtpmod */
++#define R_PPC64_TPREL16               69 /* half16*   (sym+add)@tprel */
++#define R_PPC64_TPREL16_LO    70 /* half16    (sym+add)@tprel@l */
++#define R_PPC64_TPREL16_HI    71 /* half16    (sym+add)@tprel@h */
++#define R_PPC64_TPREL16_HA    72 /* half16    (sym+add)@tprel@ha */
++#define R_PPC64_TPREL64               73 /* doubleword64 (sym+add)@tprel */
++#define R_PPC64_DTPREL16      74 /* half16*   (sym+add)@dtprel */
++#define R_PPC64_DTPREL16_LO   75 /* half16    (sym+add)@dtprel@l */
++#define R_PPC64_DTPREL16_HI   76 /* half16    (sym+add)@dtprel@h */
++#define R_PPC64_DTPREL16_HA   77 /* half16    (sym+add)@dtprel@ha */
++#define R_PPC64_DTPREL64      78 /* doubleword64 (sym+add)@dtprel */
++#define R_PPC64_GOT_TLSGD16   79 /* half16*   (sym+add)@got@tlsgd */
++#define R_PPC64_GOT_TLSGD16_LO        80 /* half16    (sym+add)@got@tlsgd@l */
++#define R_PPC64_GOT_TLSGD16_HI        81 /* half16    (sym+add)@got@tlsgd@h */
++#define R_PPC64_GOT_TLSGD16_HA        82 /* half16    (sym+add)@got@tlsgd@ha */
++#define R_PPC64_GOT_TLSLD16   83 /* half16*   (sym+add)@got@tlsld */
++#define R_PPC64_GOT_TLSLD16_LO        84 /* half16    (sym+add)@got@tlsld@l */
++#define R_PPC64_GOT_TLSLD16_HI        85 /* half16    (sym+add)@got@tlsld@h */
++#define R_PPC64_GOT_TLSLD16_HA        86 /* half16    (sym+add)@got@tlsld@ha */
++#define R_PPC64_GOT_TPREL16_DS        87 /* half16ds* (sym+add)@got@tprel */
++#define R_PPC64_GOT_TPREL16_LO_DS 88 /* half16ds (sym+add)@got@tprel@l */
++#define R_PPC64_GOT_TPREL16_HI        89 /* half16    (sym+add)@got@tprel@h */
++#define R_PPC64_GOT_TPREL16_HA        90 /* half16    (sym+add)@got@tprel@ha */
++#define R_PPC64_GOT_DTPREL16_DS       91 /* half16ds* (sym+add)@got@dtprel */
++#define R_PPC64_GOT_DTPREL16_LO_DS 92 /* half16ds (sym+add)@got@dtprel@l */
++#define R_PPC64_GOT_DTPREL16_HI       93 /* half16    (sym+add)@got@dtprel@h */
++#define R_PPC64_GOT_DTPREL16_HA       94 /* half16    (sym+add)@got@dtprel@ha */
++#define R_PPC64_TPREL16_DS    95 /* half16ds* (sym+add)@tprel */
++#define R_PPC64_TPREL16_LO_DS 96 /* half16ds  (sym+add)@tprel@l */
++#define R_PPC64_TPREL16_HIGHER        97 /* half16    (sym+add)@tprel@higher */
++#define R_PPC64_TPREL16_HIGHERA       98 /* half16    (sym+add)@tprel@highera */
++#define R_PPC64_TPREL16_HIGHEST       99 /* half16    (sym+add)@tprel@highest */
++#define R_PPC64_TPREL16_HIGHESTA 100 /* half16        (sym+add)@tprel@highesta */
++#define R_PPC64_DTPREL16_DS   101 /* half16ds* (sym+add)@dtprel */
++#define R_PPC64_DTPREL16_LO_DS        102 /* half16ds (sym+add)@dtprel@l */
++#define R_PPC64_DTPREL16_HIGHER       103 /* half16   (sym+add)@dtprel@higher */
++#define R_PPC64_DTPREL16_HIGHERA 104 /* half16        (sym+add)@dtprel@highera */
++#define R_PPC64_DTPREL16_HIGHEST 105 /* half16        (sym+add)@dtprel@highest */
++#define R_PPC64_DTPREL16_HIGHESTA 106 /* half16       (sym+add)@dtprel@highesta */
++
++/* GNU extension to support local ifunc.  */
++#define R_PPC64_JMP_IREL      247
++#define R_PPC64_IRELATIVE     248
++#define R_PPC64_REL16         249     /* half16   (sym+add-.) */
++#define R_PPC64_REL16_LO      250     /* half16   (sym+add-.)@l */
++#define R_PPC64_REL16_HI      251     /* half16   (sym+add-.)@h */
++#define R_PPC64_REL16_HA      252     /* half16   (sym+add-.)@ha */
++
++/* PowerPC64 specific values for the Dyn d_tag field.  */
++#define DT_PPC64_GLINK  (DT_LOPROC + 0)
++#define DT_PPC64_OPD  (DT_LOPROC + 1)
++#define DT_PPC64_OPDSZ        (DT_LOPROC + 2)
++#define DT_PPC64_NUM    3
++
++
++/* ARM specific declarations */
++
++/* Processor specific flags for the ELF header e_flags field.  */
++#define EF_ARM_RELEXEC                0x01
++#define EF_ARM_HASENTRY               0x02
++#define EF_ARM_INTERWORK      0x04
++#define EF_ARM_APCS_26                0x08
++#define EF_ARM_APCS_FLOAT     0x10
++#define EF_ARM_PIC            0x20
++#define EF_ARM_ALIGN8         0x40 /* 8-bit structure alignment is in use */
++#define EF_ARM_NEW_ABI                0x80
++#define EF_ARM_OLD_ABI                0x100
++#define EF_ARM_SOFT_FLOAT     0x200
++#define EF_ARM_VFP_FLOAT      0x400
++#define EF_ARM_MAVERICK_FLOAT 0x800
++
++
++/* Other constants defined in the ARM ELF spec. version B-01.  */
++/* NB. These conflict with values defined above.  */
++#define EF_ARM_SYMSARESORTED  0x04
++#define EF_ARM_DYNSYMSUSESEGIDX       0x08
++#define EF_ARM_MAPSYMSFIRST   0x10
++#define EF_ARM_EABIMASK               0XFF000000
++
++/* Constants defined in AAELF.  */
++#define EF_ARM_BE8        0x00800000
++#define EF_ARM_LE8        0x00400000
++
++#define EF_ARM_EABI_VERSION(flags)    ((flags) & EF_ARM_EABIMASK)
++#define EF_ARM_EABI_UNKNOWN   0x00000000
++#define EF_ARM_EABI_VER1      0x01000000
++#define EF_ARM_EABI_VER2      0x02000000
++#define EF_ARM_EABI_VER3      0x03000000
++#define EF_ARM_EABI_VER4      0x04000000
++#define EF_ARM_EABI_VER5      0x05000000
++
++/* Additional symbol types for Thumb.  */
++#define STT_ARM_TFUNC         STT_LOPROC /* A Thumb function.  */
++#define STT_ARM_16BIT         STT_HIPROC /* A Thumb label.  */
++
++/* ARM-specific values for sh_flags */
++#define SHF_ARM_ENTRYSECT     0x10000000 /* Section contains an entry point */
++#define SHF_ARM_COMDEF                0x80000000 /* Section may be multiply defined
++                                            in the input to a link step.  */
++
++/* ARM-specific program header flags */
++#define PF_ARM_SB             0x10000000 /* Segment contains the location
++                                            addressed by the static base. */
++#define PF_ARM_PI             0x20000000 /* Position-independent segment.  */
++#define PF_ARM_ABS            0x40000000 /* Absolute segment.  */
++
++/* Processor specific values for the Phdr p_type field.  */
++#define PT_ARM_EXIDX          (PT_LOPROC + 1) /* ARM unwind segment.  */
++
++/* Processor specific values for the Shdr sh_type field.  */
++#define SHT_ARM_EXIDX         (SHT_LOPROC + 1) /* ARM unwind section.  */
++#define SHT_ARM_PREEMPTMAP    (SHT_LOPROC + 2) /* Preemption details.  */
++#define SHT_ARM_ATTRIBUTES    (SHT_LOPROC + 3) /* ARM attributes section.  */
++
++
++/* ARM relocs.  */
++
++#define R_ARM_NONE            0       /* No reloc */
++#define R_ARM_PC24            1       /* PC relative 26 bit branch */
++#define R_ARM_ABS32           2       /* Direct 32 bit  */
++#define R_ARM_REL32           3       /* PC relative 32 bit */
++#define R_ARM_PC13            4
++#define R_ARM_ABS16           5       /* Direct 16 bit */
++#define R_ARM_ABS12           6       /* Direct 12 bit */
++#define R_ARM_THM_ABS5                7
++#define R_ARM_ABS8            8       /* Direct 8 bit */
++#define R_ARM_SBREL32         9
++#define R_ARM_THM_PC22                10
++#define R_ARM_THM_PC8         11
++#define R_ARM_AMP_VCALL9      12
++#define R_ARM_SWI24           13      /* Obsolete static relocation.  */
++#define R_ARM_TLS_DESC                13      /* Dynamic relocation.  */
++#define R_ARM_THM_SWI8                14
++#define R_ARM_XPC25           15
++#define R_ARM_THM_XPC22               16
++#define R_ARM_TLS_DTPMOD32    17      /* ID of module containing symbol */
++#define R_ARM_TLS_DTPOFF32    18      /* Offset in TLS block */
++#define R_ARM_TLS_TPOFF32     19      /* Offset in static TLS block */
++#define R_ARM_COPY            20      /* Copy symbol at runtime */
++#define R_ARM_GLOB_DAT                21      /* Create GOT entry */
++#define R_ARM_JUMP_SLOT               22      /* Create PLT entry */
++#define R_ARM_RELATIVE                23      /* Adjust by program base */
++#define R_ARM_GOTOFF          24      /* 32 bit offset to GOT */
++#define R_ARM_GOTPC           25      /* 32 bit PC relative offset to GOT */
++#define R_ARM_GOT32           26      /* 32 bit GOT entry */
++#define R_ARM_PLT32           27      /* 32 bit PLT address */
++#define R_ARM_ALU_PCREL_7_0   32
++#define R_ARM_ALU_PCREL_15_8  33
++#define R_ARM_ALU_PCREL_23_15 34
++#define R_ARM_LDR_SBREL_11_0  35
++#define R_ARM_ALU_SBREL_19_12 36
++#define R_ARM_ALU_SBREL_27_20 37
++#define R_ARM_TLS_GOTDESC     90
++#define R_ARM_TLS_CALL                91
++#define R_ARM_TLS_DESCSEQ     92
++#define R_ARM_THM_TLS_CALL    93
++#define R_ARM_GNU_VTENTRY     100
++#define R_ARM_GNU_VTINHERIT   101
++#define R_ARM_THM_PC11                102     /* thumb unconditional branch */
++#define R_ARM_THM_PC9         103     /* thumb conditional branch */
++#define R_ARM_TLS_GD32                104     /* PC-rel 32 bit for global dynamic
++                                         thread local data */
++#define R_ARM_TLS_LDM32               105     /* PC-rel 32 bit for local dynamic
++                                         thread local data */
++#define R_ARM_TLS_LDO32               106     /* 32 bit offset relative to TLS
++                                         block */
++#define R_ARM_TLS_IE32                107     /* PC-rel 32 bit for GOT entry of
++                                         static TLS block offset */
++#define R_ARM_TLS_LE32                108     /* 32 bit offset relative to static
++                                         TLS block */
++#define       R_ARM_THM_TLS_DESCSEQ   129
++#define R_ARM_IRELATIVE               160
++#define R_ARM_RXPC25          249
++#define R_ARM_RSBREL32                250
++#define R_ARM_THM_RPC22               251
++#define R_ARM_RREL32          252
++#define R_ARM_RABS22          253
++#define R_ARM_RPC24           254
++#define R_ARM_RBASE           255
++/* Keep this the last entry.  */
++#define R_ARM_NUM             256
++
++/* IA-64 specific declarations.  */
++
++/* Processor specific flags for the Ehdr e_flags field.  */
++#define EF_IA_64_MASKOS               0x0000000f      /* os-specific flags */
++#define EF_IA_64_ABI64                0x00000010      /* 64-bit ABI */
++#define EF_IA_64_ARCH         0xff000000      /* arch. version mask */
++
++/* Processor specific values for the Phdr p_type field.  */
++#define PT_IA_64_ARCHEXT      (PT_LOPROC + 0) /* arch extension bits */
++#define PT_IA_64_UNWIND               (PT_LOPROC + 1) /* ia64 unwind bits */
++#define PT_IA_64_HP_OPT_ANOT  (PT_LOOS + 0x12)
++#define PT_IA_64_HP_HSL_ANOT  (PT_LOOS + 0x13)
++#define PT_IA_64_HP_STACK     (PT_LOOS + 0x14)
++
++/* Processor specific flags for the Phdr p_flags field.  */
++#define PF_IA_64_NORECOV      0x80000000      /* spec insns w/o recovery */
++
++/* Processor specific values for the Shdr sh_type field.  */
++#define SHT_IA_64_EXT         (SHT_LOPROC + 0) /* extension bits */
++#define SHT_IA_64_UNWIND      (SHT_LOPROC + 1) /* unwind bits */
++
++/* Processor specific flags for the Shdr sh_flags field.  */
++#define SHF_IA_64_SHORT               0x10000000      /* section near gp */
++#define SHF_IA_64_NORECOV     0x20000000      /* spec insns w/o recovery */
++
++/* Processor specific values for the Dyn d_tag field.  */
++#define DT_IA_64_PLT_RESERVE  (DT_LOPROC + 0)
++#define DT_IA_64_NUM          1
++
++/* IA-64 relocations.  */
++#define R_IA64_NONE           0x00    /* none */
++#define R_IA64_IMM14          0x21    /* symbol + addend, add imm14 */
++#define R_IA64_IMM22          0x22    /* symbol + addend, add imm22 */
++#define R_IA64_IMM64          0x23    /* symbol + addend, mov imm64 */
++#define R_IA64_DIR32MSB               0x24    /* symbol + addend, data4 MSB */
++#define R_IA64_DIR32LSB               0x25    /* symbol + addend, data4 LSB */
++#define R_IA64_DIR64MSB               0x26    /* symbol + addend, data8 MSB */
++#define R_IA64_DIR64LSB               0x27    /* symbol + addend, data8 LSB */
++#define R_IA64_GPREL22                0x2a    /* @gprel(sym + add), add imm22 */
++#define R_IA64_GPREL64I               0x2b    /* @gprel(sym + add), mov imm64 */
++#define R_IA64_GPREL32MSB     0x2c    /* @gprel(sym + add), data4 MSB */
++#define R_IA64_GPREL32LSB     0x2d    /* @gprel(sym + add), data4 LSB */
++#define R_IA64_GPREL64MSB     0x2e    /* @gprel(sym + add), data8 MSB */
++#define R_IA64_GPREL64LSB     0x2f    /* @gprel(sym + add), data8 LSB */
++#define R_IA64_LTOFF22                0x32    /* @ltoff(sym + add), add imm22 */
++#define R_IA64_LTOFF64I               0x33    /* @ltoff(sym + add), mov imm64 */
++#define R_IA64_PLTOFF22               0x3a    /* @pltoff(sym + add), add imm22 */
++#define R_IA64_PLTOFF64I      0x3b    /* @pltoff(sym + add), mov imm64 */
++#define R_IA64_PLTOFF64MSB    0x3e    /* @pltoff(sym + add), data8 MSB */
++#define R_IA64_PLTOFF64LSB    0x3f    /* @pltoff(sym + add), data8 LSB */
++#define R_IA64_FPTR64I                0x43    /* @fptr(sym + add), mov imm64 */
++#define R_IA64_FPTR32MSB      0x44    /* @fptr(sym + add), data4 MSB */
++#define R_IA64_FPTR32LSB      0x45    /* @fptr(sym + add), data4 LSB */
++#define R_IA64_FPTR64MSB      0x46    /* @fptr(sym + add), data8 MSB */
++#define R_IA64_FPTR64LSB      0x47    /* @fptr(sym + add), data8 LSB */
++#define R_IA64_PCREL60B               0x48    /* @pcrel(sym + add), brl */
++#define R_IA64_PCREL21B               0x49    /* @pcrel(sym + add), ptb, call */
++#define R_IA64_PCREL21M               0x4a    /* @pcrel(sym + add), chk.s */
++#define R_IA64_PCREL21F               0x4b    /* @pcrel(sym + add), fchkf */
++#define R_IA64_PCREL32MSB     0x4c    /* @pcrel(sym + add), data4 MSB */
++#define R_IA64_PCREL32LSB     0x4d    /* @pcrel(sym + add), data4 LSB */
++#define R_IA64_PCREL64MSB     0x4e    /* @pcrel(sym + add), data8 MSB */
++#define R_IA64_PCREL64LSB     0x4f    /* @pcrel(sym + add), data8 LSB */
++#define R_IA64_LTOFF_FPTR22   0x52    /* @ltoff(@fptr(s+a)), imm22 */
++#define R_IA64_LTOFF_FPTR64I  0x53    /* @ltoff(@fptr(s+a)), imm64 */
++#define R_IA64_LTOFF_FPTR32MSB        0x54    /* @ltoff(@fptr(s+a)), data4 MSB */
++#define R_IA64_LTOFF_FPTR32LSB        0x55    /* @ltoff(@fptr(s+a)), data4 LSB */
++#define R_IA64_LTOFF_FPTR64MSB        0x56    /* @ltoff(@fptr(s+a)), data8 MSB */
++#define R_IA64_LTOFF_FPTR64LSB        0x57    /* @ltoff(@fptr(s+a)), data8 LSB */
++#define R_IA64_SEGREL32MSB    0x5c    /* @segrel(sym + add), data4 MSB */
++#define R_IA64_SEGREL32LSB    0x5d    /* @segrel(sym + add), data4 LSB */
++#define R_IA64_SEGREL64MSB    0x5e    /* @segrel(sym + add), data8 MSB */
++#define R_IA64_SEGREL64LSB    0x5f    /* @segrel(sym + add), data8 LSB */
++#define R_IA64_SECREL32MSB    0x64    /* @secrel(sym + add), data4 MSB */
++#define R_IA64_SECREL32LSB    0x65    /* @secrel(sym + add), data4 LSB */
++#define R_IA64_SECREL64MSB    0x66    /* @secrel(sym + add), data8 MSB */
++#define R_IA64_SECREL64LSB    0x67    /* @secrel(sym + add), data8 LSB */
++#define R_IA64_REL32MSB               0x6c    /* data 4 + REL */
++#define R_IA64_REL32LSB               0x6d    /* data 4 + REL */
++#define R_IA64_REL64MSB               0x6e    /* data 8 + REL */
++#define R_IA64_REL64LSB               0x6f    /* data 8 + REL */
++#define R_IA64_LTV32MSB               0x74    /* symbol + addend, data4 MSB */
++#define R_IA64_LTV32LSB               0x75    /* symbol + addend, data4 LSB */
++#define R_IA64_LTV64MSB               0x76    /* symbol + addend, data8 MSB */
++#define R_IA64_LTV64LSB               0x77    /* symbol + addend, data8 LSB */
++#define R_IA64_PCREL21BI      0x79    /* @pcrel(sym + add), 21bit inst */
++#define R_IA64_PCREL22                0x7a    /* @pcrel(sym + add), 22bit inst */
++#define R_IA64_PCREL64I               0x7b    /* @pcrel(sym + add), 64bit inst */
++#define R_IA64_IPLTMSB                0x80    /* dynamic reloc, imported PLT, MSB */
++#define R_IA64_IPLTLSB                0x81    /* dynamic reloc, imported PLT, LSB */
++#define R_IA64_COPY           0x84    /* copy relocation */
++#define R_IA64_SUB            0x85    /* Addend and symbol difference */
++#define R_IA64_LTOFF22X               0x86    /* LTOFF22, relaxable.  */
++#define R_IA64_LDXMOV         0x87    /* Use of LTOFF22X.  */
++#define R_IA64_TPREL14                0x91    /* @tprel(sym + add), imm14 */
++#define R_IA64_TPREL22                0x92    /* @tprel(sym + add), imm22 */
++#define R_IA64_TPREL64I               0x93    /* @tprel(sym + add), imm64 */
++#define R_IA64_TPREL64MSB     0x96    /* @tprel(sym + add), data8 MSB */
++#define R_IA64_TPREL64LSB     0x97    /* @tprel(sym + add), data8 LSB */
++#define R_IA64_LTOFF_TPREL22  0x9a    /* @ltoff(@tprel(s+a)), imm2 */
++#define R_IA64_DTPMOD64MSB    0xa6    /* @dtpmod(sym + add), data8 MSB */
++#define R_IA64_DTPMOD64LSB    0xa7    /* @dtpmod(sym + add), data8 LSB */
++#define R_IA64_LTOFF_DTPMOD22 0xaa    /* @ltoff(@dtpmod(sym + add)), imm22 */
++#define R_IA64_DTPREL14               0xb1    /* @dtprel(sym + add), imm14 */
++#define R_IA64_DTPREL22               0xb2    /* @dtprel(sym + add), imm22 */
++#define R_IA64_DTPREL64I      0xb3    /* @dtprel(sym + add), imm64 */
++#define R_IA64_DTPREL32MSB    0xb4    /* @dtprel(sym + add), data4 MSB */
++#define R_IA64_DTPREL32LSB    0xb5    /* @dtprel(sym + add), data4 LSB */
++#define R_IA64_DTPREL64MSB    0xb6    /* @dtprel(sym + add), data8 MSB */
++#define R_IA64_DTPREL64LSB    0xb7    /* @dtprel(sym + add), data8 LSB */
++#define R_IA64_LTOFF_DTPREL22 0xba    /* @ltoff(@dtprel(s+a)), imm22 */
++
++/* SH specific declarations */
++
++/* Processor specific flags for the ELF header e_flags field.  */
++#define EF_SH_MACH_MASK               0x1f
++#define EF_SH_UNKNOWN         0x0
++#define EF_SH1                        0x1
++#define EF_SH2                        0x2
++#define EF_SH3                        0x3
++#define EF_SH_DSP             0x4
++#define EF_SH3_DSP            0x5
++#define EF_SH4AL_DSP          0x6
++#define EF_SH3E                       0x8
++#define EF_SH4                        0x9
++#define EF_SH2E                       0xb
++#define EF_SH4A                       0xc
++#define EF_SH2A                       0xd
++#define EF_SH4_NOFPU          0x10
++#define EF_SH4A_NOFPU         0x11
++#define EF_SH4_NOMMU_NOFPU    0x12
++#define EF_SH2A_NOFPU         0x13
++#define EF_SH3_NOMMU          0x14
++#define EF_SH2A_SH4_NOFPU     0x15
++#define EF_SH2A_SH3_NOFPU     0x16
++#define EF_SH2A_SH4           0x17
++#define EF_SH2A_SH3E          0x18
++
++/* SH relocs.  */
++#define       R_SH_NONE               0
++#define       R_SH_DIR32              1
++#define       R_SH_REL32              2
++#define       R_SH_DIR8WPN            3
++#define       R_SH_IND12W             4
++#define       R_SH_DIR8WPL            5
++#define       R_SH_DIR8WPZ            6
++#define       R_SH_DIR8BP             7
++#define       R_SH_DIR8W              8
++#define       R_SH_DIR8L              9
++#define       R_SH_SWITCH16           25
++#define       R_SH_SWITCH32           26
++#define       R_SH_USES               27
++#define       R_SH_COUNT              28
++#define       R_SH_ALIGN              29
++#define       R_SH_CODE               30
++#define       R_SH_DATA               31
++#define       R_SH_LABEL              32
++#define       R_SH_SWITCH8            33
++#define       R_SH_GNU_VTINHERIT      34
++#define       R_SH_GNU_VTENTRY        35
++#define       R_SH_TLS_GD_32          144
++#define       R_SH_TLS_LD_32          145
++#define       R_SH_TLS_LDO_32         146
++#define       R_SH_TLS_IE_32          147
++#define       R_SH_TLS_LE_32          148
++#define       R_SH_TLS_DTPMOD32       149
++#define       R_SH_TLS_DTPOFF32       150
++#define       R_SH_TLS_TPOFF32        151
++#define       R_SH_GOT32              160
++#define       R_SH_PLT32              161
++#define       R_SH_COPY               162
++#define       R_SH_GLOB_DAT           163
++#define       R_SH_JMP_SLOT           164
++#define       R_SH_RELATIVE           165
++#define       R_SH_GOTOFF             166
++#define       R_SH_GOTPC              167
++/* Keep this the last entry.  */
++#define       R_SH_NUM                256
++
++/* S/390 specific definitions.  */
++
++/* Valid values for the e_flags field.  */
++
++#define EF_S390_HIGH_GPRS    0x00000001  /* High GPRs kernel facility needed.  */
++
++/* Additional s390 relocs */
++
++#define R_390_NONE            0       /* No reloc.  */
++#define R_390_8                       1       /* Direct 8 bit.  */
++#define R_390_12              2       /* Direct 12 bit.  */
++#define R_390_16              3       /* Direct 16 bit.  */
++#define R_390_32              4       /* Direct 32 bit.  */
++#define R_390_PC32            5       /* PC relative 32 bit.  */
++#define R_390_GOT12           6       /* 12 bit GOT offset.  */
++#define R_390_GOT32           7       /* 32 bit GOT offset.  */
++#define R_390_PLT32           8       /* 32 bit PC relative PLT address.  */
++#define R_390_COPY            9       /* Copy symbol at runtime.  */
++#define R_390_GLOB_DAT                10      /* Create GOT entry.  */
++#define R_390_JMP_SLOT                11      /* Create PLT entry.  */
++#define R_390_RELATIVE                12      /* Adjust by program base.  */
++#define R_390_GOTOFF32                13      /* 32 bit offset to GOT.         */
++#define R_390_GOTPC           14      /* 32 bit PC relative offset to GOT.  */
++#define R_390_GOT16           15      /* 16 bit GOT offset.  */
++#define R_390_PC16            16      /* PC relative 16 bit.  */
++#define R_390_PC16DBL         17      /* PC relative 16 bit shifted by 1.  */
++#define R_390_PLT16DBL                18      /* 16 bit PC rel. PLT shifted by 1.  */
++#define R_390_PC32DBL         19      /* PC relative 32 bit shifted by 1.  */
++#define R_390_PLT32DBL                20      /* 32 bit PC rel. PLT shifted by 1.  */
++#define R_390_GOTPCDBL                21      /* 32 bit PC rel. GOT shifted by 1.  */
++#define R_390_64              22      /* Direct 64 bit.  */
++#define R_390_PC64            23      /* PC relative 64 bit.  */
++#define R_390_GOT64           24      /* 64 bit GOT offset.  */
++#define R_390_PLT64           25      /* 64 bit PC relative PLT address.  */
++#define R_390_GOTENT          26      /* 32 bit PC rel. to GOT entry >> 1. */
++#define R_390_GOTOFF16                27      /* 16 bit offset to GOT. */
++#define R_390_GOTOFF64                28      /* 64 bit offset to GOT. */
++#define R_390_GOTPLT12                29      /* 12 bit offset to jump slot.  */
++#define R_390_GOTPLT16                30      /* 16 bit offset to jump slot.  */
++#define R_390_GOTPLT32                31      /* 32 bit offset to jump slot.  */
++#define R_390_GOTPLT64                32      /* 64 bit offset to jump slot.  */
++#define R_390_GOTPLTENT               33      /* 32 bit rel. offset to jump slot.  */
++#define R_390_PLTOFF16                34      /* 16 bit offset from GOT to PLT. */
++#define R_390_PLTOFF32                35      /* 32 bit offset from GOT to PLT. */
++#define R_390_PLTOFF64                36      /* 16 bit offset from GOT to PLT. */
++#define R_390_TLS_LOAD                37      /* Tag for load insn in TLS code.  */
++#define R_390_TLS_GDCALL      38      /* Tag for function call in general
++                                         dynamic TLS code. */
++#define R_390_TLS_LDCALL      39      /* Tag for function call in local
++                                         dynamic TLS code. */
++#define R_390_TLS_GD32                40      /* Direct 32 bit for general dynamic
++                                         thread local data.  */
++#define R_390_TLS_GD64                41      /* Direct 64 bit for general dynamic
++                                        thread local data.  */
++#define R_390_TLS_GOTIE12     42      /* 12 bit GOT offset for static TLS
++                                         block offset.  */
++#define R_390_TLS_GOTIE32     43      /* 32 bit GOT offset for static TLS
++                                         block offset.  */
++#define R_390_TLS_GOTIE64     44      /* 64 bit GOT offset for static TLS
++                                         block offset. */
++#define R_390_TLS_LDM32               45      /* Direct 32 bit for local dynamic
++                                         thread local data in LE code.  */
++#define R_390_TLS_LDM64               46      /* Direct 64 bit for local dynamic
++                                         thread local data in LE code.  */
++#define R_390_TLS_IE32                47      /* 32 bit address of GOT entry for
++                                         negated static TLS block offset.  */
++#define R_390_TLS_IE64                48      /* 64 bit address of GOT entry for
++                                         negated static TLS block offset.  */
++#define R_390_TLS_IEENT               49      /* 32 bit rel. offset to GOT entry for
++                                         negated static TLS block offset.  */
++#define R_390_TLS_LE32                50      /* 32 bit negated offset relative to
++                                         static TLS block.  */
++#define R_390_TLS_LE64                51      /* 64 bit negated offset relative to
++                                         static TLS block.  */
++#define R_390_TLS_LDO32               52      /* 32 bit offset relative to TLS
++                                         block.  */
++#define R_390_TLS_LDO64               53      /* 64 bit offset relative to TLS
++                                         block.  */
++#define R_390_TLS_DTPMOD      54      /* ID of module containing symbol.  */
++#define R_390_TLS_DTPOFF      55      /* Offset in TLS block.  */
++#define R_390_TLS_TPOFF               56      /* Negated offset in static TLS
++                                         block.  */
++#define R_390_20              57      /* Direct 20 bit.  */
++#define R_390_GOT20           58      /* 20 bit GOT offset.  */
++#define R_390_GOTPLT20                59      /* 20 bit offset to jump slot.  */
++#define R_390_TLS_GOTIE20     60      /* 20 bit GOT offset for static TLS
++                                         block offset.  */
++#define R_390_IRELATIVE         61      /* STT_GNU_IFUNC relocation.  */
++/* Keep this the last entry.  */
++#define R_390_NUM             62
++
++
++/* CRIS relocations.  */
++#define R_CRIS_NONE           0
++#define R_CRIS_8              1
++#define R_CRIS_16             2
++#define R_CRIS_32             3
++#define R_CRIS_8_PCREL                4
++#define R_CRIS_16_PCREL               5
++#define R_CRIS_32_PCREL               6
++#define R_CRIS_GNU_VTINHERIT  7
++#define R_CRIS_GNU_VTENTRY    8
++#define R_CRIS_COPY           9
++#define R_CRIS_GLOB_DAT               10
++#define R_CRIS_JUMP_SLOT      11
++#define R_CRIS_RELATIVE               12
++#define R_CRIS_16_GOT         13
++#define R_CRIS_32_GOT         14
++#define R_CRIS_16_GOTPLT      15
++#define R_CRIS_32_GOTPLT      16
++#define R_CRIS_32_GOTREL      17
++#define R_CRIS_32_PLT_GOTREL  18
++#define R_CRIS_32_PLT_PCREL   19
++
++#define R_CRIS_NUM            20
++
++
++/* AMD x86-64 relocations.  */
++#define R_X86_64_NONE         0       /* No reloc */
++#define R_X86_64_64           1       /* Direct 64 bit  */
++#define R_X86_64_PC32         2       /* PC relative 32 bit signed */
++#define R_X86_64_GOT32                3       /* 32 bit GOT entry */
++#define R_X86_64_PLT32                4       /* 32 bit PLT address */
++#define R_X86_64_COPY         5       /* Copy symbol at runtime */
++#define R_X86_64_GLOB_DAT     6       /* Create GOT entry */
++#define R_X86_64_JUMP_SLOT    7       /* Create PLT entry */
++#define R_X86_64_RELATIVE     8       /* Adjust by program base */
++#define R_X86_64_GOTPCREL     9       /* 32 bit signed PC relative
++                                         offset to GOT */
++#define R_X86_64_32           10      /* Direct 32 bit zero extended */
++#define R_X86_64_32S          11      /* Direct 32 bit sign extended */
++#define R_X86_64_16           12      /* Direct 16 bit zero extended */
++#define R_X86_64_PC16         13      /* 16 bit sign extended pc relative */
++#define R_X86_64_8            14      /* Direct 8 bit sign extended  */
++#define R_X86_64_PC8          15      /* 8 bit sign extended pc relative */
++#define R_X86_64_DTPMOD64     16      /* ID of module containing symbol */
++#define R_X86_64_DTPOFF64     17      /* Offset in module's TLS block */
++#define R_X86_64_TPOFF64      18      /* Offset in initial TLS block */
++#define R_X86_64_TLSGD                19      /* 32 bit signed PC relative offset
++                                         to two GOT entries for GD symbol */
++#define R_X86_64_TLSLD                20      /* 32 bit signed PC relative offset
++                                         to two GOT entries for LD symbol */
++#define R_X86_64_DTPOFF32     21      /* Offset in TLS block */
++#define R_X86_64_GOTTPOFF     22      /* 32 bit signed PC relative offset
++                                         to GOT entry for IE symbol */
++#define R_X86_64_TPOFF32      23      /* Offset in initial TLS block */
++#define R_X86_64_PC64         24      /* PC relative 64 bit */
++#define R_X86_64_GOTOFF64     25      /* 64 bit offset to GOT */
++#define R_X86_64_GOTPC32      26      /* 32 bit signed pc relative
++                                         offset to GOT */
++#define R_X86_64_GOT64                27      /* 64-bit GOT entry offset */
++#define R_X86_64_GOTPCREL64   28      /* 64-bit PC relative offset
++                                         to GOT entry */
++#define R_X86_64_GOTPC64      29      /* 64-bit PC relative offset to GOT */
++#define R_X86_64_GOTPLT64     30      /* like GOT64, says PLT entry needed */
++#define R_X86_64_PLTOFF64     31      /* 64-bit GOT relative offset
++                                         to PLT entry */
++#define R_X86_64_SIZE32               32      /* Size of symbol plus 32-bit addend */
++#define R_X86_64_SIZE64               33      /* Size of symbol plus 64-bit addend */
++#define R_X86_64_GOTPC32_TLSDESC 34   /* GOT offset for TLS descriptor.  */
++#define R_X86_64_TLSDESC_CALL   35    /* Marker for call through TLS
++                                         descriptor.  */
++#define R_X86_64_TLSDESC        36    /* TLS descriptor.  */
++#define R_X86_64_IRELATIVE    37      /* Adjust indirectly by program base */
++#define R_X86_64_RELATIVE64   38      /* 64-bit adjust by program base */
++
++#define R_X86_64_NUM          39
++
++
++/* AM33 relocations.  */
++#define R_MN10300_NONE                0       /* No reloc.  */
++#define R_MN10300_32          1       /* Direct 32 bit.  */
++#define R_MN10300_16          2       /* Direct 16 bit.  */
++#define R_MN10300_8           3       /* Direct 8 bit.  */
++#define R_MN10300_PCREL32     4       /* PC-relative 32-bit.  */
++#define R_MN10300_PCREL16     5       /* PC-relative 16-bit signed.  */
++#define R_MN10300_PCREL8      6       /* PC-relative 8-bit signed.  */
++#define R_MN10300_GNU_VTINHERIT       7       /* Ancient C++ vtable garbage... */
++#define R_MN10300_GNU_VTENTRY 8       /* ... collection annotation.  */
++#define R_MN10300_24          9       /* Direct 24 bit.  */
++#define R_MN10300_GOTPC32     10      /* 32-bit PCrel offset to GOT.  */
++#define R_MN10300_GOTPC16     11      /* 16-bit PCrel offset to GOT.  */
++#define R_MN10300_GOTOFF32    12      /* 32-bit offset from GOT.  */
++#define R_MN10300_GOTOFF24    13      /* 24-bit offset from GOT.  */
++#define R_MN10300_GOTOFF16    14      /* 16-bit offset from GOT.  */
++#define R_MN10300_PLT32               15      /* 32-bit PCrel to PLT entry.  */
++#define R_MN10300_PLT16               16      /* 16-bit PCrel to PLT entry.  */
++#define R_MN10300_GOT32               17      /* 32-bit offset to GOT entry.  */
++#define R_MN10300_GOT24               18      /* 24-bit offset to GOT entry.  */
++#define R_MN10300_GOT16               19      /* 16-bit offset to GOT entry.  */
++#define R_MN10300_COPY                20      /* Copy symbol at runtime.  */
++#define R_MN10300_GLOB_DAT    21      /* Create GOT entry.  */
++#define R_MN10300_JMP_SLOT    22      /* Create PLT entry.  */
++#define R_MN10300_RELATIVE    23      /* Adjust by program base.  */
++
++#define R_MN10300_NUM         24
++
++
++/* M32R relocs.  */
++#define R_M32R_NONE           0       /* No reloc. */
++#define R_M32R_16             1       /* Direct 16 bit. */
++#define R_M32R_32             2       /* Direct 32 bit. */
++#define R_M32R_24             3       /* Direct 24 bit. */
++#define R_M32R_10_PCREL               4       /* PC relative 10 bit shifted. */
++#define R_M32R_18_PCREL               5       /* PC relative 18 bit shifted. */
++#define R_M32R_26_PCREL               6       /* PC relative 26 bit shifted. */
++#define R_M32R_HI16_ULO               7       /* High 16 bit with unsigned low. */
++#define R_M32R_HI16_SLO               8       /* High 16 bit with signed low. */
++#define R_M32R_LO16           9       /* Low 16 bit. */
++#define R_M32R_SDA16          10      /* 16 bit offset in SDA. */
++#define R_M32R_GNU_VTINHERIT  11
++#define R_M32R_GNU_VTENTRY    12
++/* M32R relocs use SHT_RELA.  */
++#define R_M32R_16_RELA                33      /* Direct 16 bit. */
++#define R_M32R_32_RELA                34      /* Direct 32 bit. */
++#define R_M32R_24_RELA                35      /* Direct 24 bit. */
++#define R_M32R_10_PCREL_RELA  36      /* PC relative 10 bit shifted. */
++#define R_M32R_18_PCREL_RELA  37      /* PC relative 18 bit shifted. */
++#define R_M32R_26_PCREL_RELA  38      /* PC relative 26 bit shifted. */
++#define R_M32R_HI16_ULO_RELA  39      /* High 16 bit with unsigned low */
++#define R_M32R_HI16_SLO_RELA  40      /* High 16 bit with signed low */
++#define R_M32R_LO16_RELA      41      /* Low 16 bit */
++#define R_M32R_SDA16_RELA     42      /* 16 bit offset in SDA */
++#define R_M32R_RELA_GNU_VTINHERIT     43
++#define R_M32R_RELA_GNU_VTENTRY       44
++#define R_M32R_REL32          45      /* PC relative 32 bit.  */
++
++#define R_M32R_GOT24          48      /* 24 bit GOT entry */
++#define R_M32R_26_PLTREL      49      /* 26 bit PC relative to PLT shifted */
++#define R_M32R_COPY           50      /* Copy symbol at runtime */
++#define R_M32R_GLOB_DAT               51      /* Create GOT entry */
++#define R_M32R_JMP_SLOT               52      /* Create PLT entry */
++#define R_M32R_RELATIVE               53      /* Adjust by program base */
++#define R_M32R_GOTOFF         54      /* 24 bit offset to GOT */
++#define R_M32R_GOTPC24                55      /* 24 bit PC relative offset to GOT */
++#define R_M32R_GOT16_HI_ULO   56      /* High 16 bit GOT entry with unsigned
++                                         low */
++#define R_M32R_GOT16_HI_SLO   57      /* High 16 bit GOT entry with signed
++                                         low */
++#define R_M32R_GOT16_LO               58      /* Low 16 bit GOT entry */
++#define R_M32R_GOTPC_HI_ULO   59      /* High 16 bit PC relative offset to
++                                         GOT with unsigned low */
++#define R_M32R_GOTPC_HI_SLO   60      /* High 16 bit PC relative offset to
++                                         GOT with signed low */
++#define R_M32R_GOTPC_LO               61      /* Low 16 bit PC relative offset to
++                                         GOT */
++#define R_M32R_GOTOFF_HI_ULO  62      /* High 16 bit offset to GOT
++                                         with unsigned low */
++#define R_M32R_GOTOFF_HI_SLO  63      /* High 16 bit offset to GOT
++                                         with signed low */
++#define R_M32R_GOTOFF_LO      64      /* Low 16 bit offset to GOT */
++#define R_M32R_NUM            256     /* Keep this the last entry. */
++
++
++/* TILEPro relocations.  */
++#define R_TILEPRO_NONE                0       /* No reloc */
++#define R_TILEPRO_32          1       /* Direct 32 bit */
++#define R_TILEPRO_16          2       /* Direct 16 bit */
++#define R_TILEPRO_8           3       /* Direct 8 bit */
++#define R_TILEPRO_32_PCREL    4       /* PC relative 32 bit */
++#define R_TILEPRO_16_PCREL    5       /* PC relative 16 bit */
++#define R_TILEPRO_8_PCREL     6       /* PC relative 8 bit */
++#define R_TILEPRO_LO16                7       /* Low 16 bit */
++#define R_TILEPRO_HI16                8       /* High 16 bit */
++#define R_TILEPRO_HA16                9       /* High 16 bit, adjusted */
++#define R_TILEPRO_COPY                10      /* Copy relocation */
++#define R_TILEPRO_GLOB_DAT    11      /* Create GOT entry */
++#define R_TILEPRO_JMP_SLOT    12      /* Create PLT entry */
++#define R_TILEPRO_RELATIVE    13      /* Adjust by program base */
++#define R_TILEPRO_BROFF_X1    14      /* X1 pipe branch offset */
++#define R_TILEPRO_JOFFLONG_X1 15      /* X1 pipe jump offset */
++#define R_TILEPRO_JOFFLONG_X1_PLT 16  /* X1 pipe jump offset to PLT */
++#define R_TILEPRO_IMM8_X0     17      /* X0 pipe 8-bit */
++#define R_TILEPRO_IMM8_Y0     18      /* Y0 pipe 8-bit */
++#define R_TILEPRO_IMM8_X1     19      /* X1 pipe 8-bit */
++#define R_TILEPRO_IMM8_Y1     20      /* Y1 pipe 8-bit */
++#define R_TILEPRO_MT_IMM15_X1 21      /* X1 pipe mtspr */
++#define R_TILEPRO_MF_IMM15_X1 22      /* X1 pipe mfspr */
++#define R_TILEPRO_IMM16_X0    23      /* X0 pipe 16-bit */
++#define R_TILEPRO_IMM16_X1    24      /* X1 pipe 16-bit */
++#define R_TILEPRO_IMM16_X0_LO 25      /* X0 pipe low 16-bit */
++#define R_TILEPRO_IMM16_X1_LO 26      /* X1 pipe low 16-bit */
++#define R_TILEPRO_IMM16_X0_HI 27      /* X0 pipe high 16-bit */
++#define R_TILEPRO_IMM16_X1_HI 28      /* X1 pipe high 16-bit */
++#define R_TILEPRO_IMM16_X0_HA 29      /* X0 pipe high 16-bit, adjusted */
++#define R_TILEPRO_IMM16_X1_HA 30      /* X1 pipe high 16-bit, adjusted */
++#define R_TILEPRO_IMM16_X0_PCREL 31   /* X0 pipe PC relative 16 bit */
++#define R_TILEPRO_IMM16_X1_PCREL 32   /* X1 pipe PC relative 16 bit */
++#define R_TILEPRO_IMM16_X0_LO_PCREL 33        /* X0 pipe PC relative low 16 bit */
++#define R_TILEPRO_IMM16_X1_LO_PCREL 34        /* X1 pipe PC relative low 16 bit */
++#define R_TILEPRO_IMM16_X0_HI_PCREL 35        /* X0 pipe PC relative high 16 bit */
++#define R_TILEPRO_IMM16_X1_HI_PCREL 36        /* X1 pipe PC relative high 16 bit */
++#define R_TILEPRO_IMM16_X0_HA_PCREL 37        /* X0 pipe PC relative ha() 16 bit */
++#define R_TILEPRO_IMM16_X1_HA_PCREL 38        /* X1 pipe PC relative ha() 16 bit */
++#define R_TILEPRO_IMM16_X0_GOT        39      /* X0 pipe 16-bit GOT offset */
++#define R_TILEPRO_IMM16_X1_GOT        40      /* X1 pipe 16-bit GOT offset */
++#define R_TILEPRO_IMM16_X0_GOT_LO 41  /* X0 pipe low 16-bit GOT offset */
++#define R_TILEPRO_IMM16_X1_GOT_LO 42  /* X1 pipe low 16-bit GOT offset */
++#define R_TILEPRO_IMM16_X0_GOT_HI 43  /* X0 pipe high 16-bit GOT offset */
++#define R_TILEPRO_IMM16_X1_GOT_HI 44  /* X1 pipe high 16-bit GOT offset */
++#define R_TILEPRO_IMM16_X0_GOT_HA 45  /* X0 pipe ha() 16-bit GOT offset */
++#define R_TILEPRO_IMM16_X1_GOT_HA 46  /* X1 pipe ha() 16-bit GOT offset */
++#define R_TILEPRO_MMSTART_X0  47      /* X0 pipe mm "start" */
++#define R_TILEPRO_MMEND_X0    48      /* X0 pipe mm "end" */
++#define R_TILEPRO_MMSTART_X1  49      /* X1 pipe mm "start" */
++#define R_TILEPRO_MMEND_X1    50      /* X1 pipe mm "end" */
++#define R_TILEPRO_SHAMT_X0    51      /* X0 pipe shift amount */
++#define R_TILEPRO_SHAMT_X1    52      /* X1 pipe shift amount */
++#define R_TILEPRO_SHAMT_Y0    53      /* Y0 pipe shift amount */
++#define R_TILEPRO_SHAMT_Y1    54      /* Y1 pipe shift amount */
++#define R_TILEPRO_DEST_IMM8_X1        55      /* X1 pipe destination 8-bit */
++/* Relocs 56-59 are currently not defined.  */
++#define R_TILEPRO_TLS_GD_CALL 60      /* "jal" for TLS GD */
++#define R_TILEPRO_IMM8_X0_TLS_GD_ADD 61       /* X0 pipe "addi" for TLS GD */
++#define R_TILEPRO_IMM8_X1_TLS_GD_ADD 62       /* X1 pipe "addi" for TLS GD */
++#define R_TILEPRO_IMM8_Y0_TLS_GD_ADD 63       /* Y0 pipe "addi" for TLS GD */
++#define R_TILEPRO_IMM8_Y1_TLS_GD_ADD 64       /* Y1 pipe "addi" for TLS GD */
++#define R_TILEPRO_TLS_IE_LOAD 65      /* "lw_tls" for TLS IE */
++#define R_TILEPRO_IMM16_X0_TLS_GD 66  /* X0 pipe 16-bit TLS GD offset */
++#define R_TILEPRO_IMM16_X1_TLS_GD 67  /* X1 pipe 16-bit TLS GD offset */
++#define R_TILEPRO_IMM16_X0_TLS_GD_LO 68       /* X0 pipe low 16-bit TLS GD offset */
++#define R_TILEPRO_IMM16_X1_TLS_GD_LO 69       /* X1 pipe low 16-bit TLS GD offset */
++#define R_TILEPRO_IMM16_X0_TLS_GD_HI 70       /* X0 pipe high 16-bit TLS GD offset */
++#define R_TILEPRO_IMM16_X1_TLS_GD_HI 71       /* X1 pipe high 16-bit TLS GD offset */
++#define R_TILEPRO_IMM16_X0_TLS_GD_HA 72       /* X0 pipe ha() 16-bit TLS GD offset */
++#define R_TILEPRO_IMM16_X1_TLS_GD_HA 73       /* X1 pipe ha() 16-bit TLS GD offset */
++#define R_TILEPRO_IMM16_X0_TLS_IE 74  /* X0 pipe 16-bit TLS IE offset */
++#define R_TILEPRO_IMM16_X1_TLS_IE 75  /* X1 pipe 16-bit TLS IE offset */
++#define R_TILEPRO_IMM16_X0_TLS_IE_LO 76       /* X0 pipe low 16-bit TLS IE offset */
++#define R_TILEPRO_IMM16_X1_TLS_IE_LO 77       /* X1 pipe low 16-bit TLS IE offset */
++#define R_TILEPRO_IMM16_X0_TLS_IE_HI 78       /* X0 pipe high 16-bit TLS IE offset */
++#define R_TILEPRO_IMM16_X1_TLS_IE_HI 79       /* X1 pipe high 16-bit TLS IE offset */
++#define R_TILEPRO_IMM16_X0_TLS_IE_HA 80       /* X0 pipe ha() 16-bit TLS IE offset */
++#define R_TILEPRO_IMM16_X1_TLS_IE_HA 81       /* X1 pipe ha() 16-bit TLS IE offset */
++#define R_TILEPRO_TLS_DTPMOD32        82      /* ID of module containing symbol */
++#define R_TILEPRO_TLS_DTPOFF32        83      /* Offset in TLS block */
++#define R_TILEPRO_TLS_TPOFF32 84      /* Offset in static TLS block */
++#define R_TILEPRO_IMM16_X0_TLS_LE 85  /* X0 pipe 16-bit TLS LE offset */
++#define R_TILEPRO_IMM16_X1_TLS_LE 86  /* X1 pipe 16-bit TLS LE offset */
++#define R_TILEPRO_IMM16_X0_TLS_LE_LO 87       /* X0 pipe low 16-bit TLS LE offset */
++#define R_TILEPRO_IMM16_X1_TLS_LE_LO 88       /* X1 pipe low 16-bit TLS LE offset */
++#define R_TILEPRO_IMM16_X0_TLS_LE_HI 89       /* X0 pipe high 16-bit TLS LE offset */
++#define R_TILEPRO_IMM16_X1_TLS_LE_HI 90       /* X1 pipe high 16-bit TLS LE offset */
++#define R_TILEPRO_IMM16_X0_TLS_LE_HA 91       /* X0 pipe ha() 16-bit TLS LE offset */
++#define R_TILEPRO_IMM16_X1_TLS_LE_HA 92       /* X1 pipe ha() 16-bit TLS LE offset */
++
++#define R_TILEPRO_GNU_VTINHERIT       128     /* GNU C++ vtable hierarchy */
++#define R_TILEPRO_GNU_VTENTRY 129     /* GNU C++ vtable member usage */
++
++#define R_TILEPRO_NUM         130
++
++
++/* TILE-Gx relocations.  */
++#define R_TILEGX_NONE         0       /* No reloc */
++#define R_TILEGX_64           1       /* Direct 64 bit */
++#define R_TILEGX_32           2       /* Direct 32 bit */
++#define R_TILEGX_16           3       /* Direct 16 bit */
++#define R_TILEGX_8            4       /* Direct 8 bit */
++#define R_TILEGX_64_PCREL     5       /* PC relative 64 bit */
++#define R_TILEGX_32_PCREL     6       /* PC relative 32 bit */
++#define R_TILEGX_16_PCREL     7       /* PC relative 16 bit */
++#define R_TILEGX_8_PCREL      8       /* PC relative 8 bit */
++#define R_TILEGX_HW0          9       /* hword 0 16-bit */
++#define R_TILEGX_HW1          10      /* hword 1 16-bit */
++#define R_TILEGX_HW2          11      /* hword 2 16-bit */
++#define R_TILEGX_HW3          12      /* hword 3 16-bit */
++#define R_TILEGX_HW0_LAST     13      /* last hword 0 16-bit */
++#define R_TILEGX_HW1_LAST     14      /* last hword 1 16-bit */
++#define R_TILEGX_HW2_LAST     15      /* last hword 2 16-bit */
++#define R_TILEGX_COPY         16      /* Copy relocation */
++#define R_TILEGX_GLOB_DAT     17      /* Create GOT entry */
++#define R_TILEGX_JMP_SLOT     18      /* Create PLT entry */
++#define R_TILEGX_RELATIVE     19      /* Adjust by program base */
++#define R_TILEGX_BROFF_X1     20      /* X1 pipe branch offset */
++#define R_TILEGX_JUMPOFF_X1   21      /* X1 pipe jump offset */
++#define R_TILEGX_JUMPOFF_X1_PLT       22      /* X1 pipe jump offset to PLT */
++#define R_TILEGX_IMM8_X0      23      /* X0 pipe 8-bit */
++#define R_TILEGX_IMM8_Y0      24      /* Y0 pipe 8-bit */
++#define R_TILEGX_IMM8_X1      25      /* X1 pipe 8-bit */
++#define R_TILEGX_IMM8_Y1      26      /* Y1 pipe 8-bit */
++#define R_TILEGX_DEST_IMM8_X1 27      /* X1 pipe destination 8-bit */
++#define R_TILEGX_MT_IMM14_X1  28      /* X1 pipe mtspr */
++#define R_TILEGX_MF_IMM14_X1  29      /* X1 pipe mfspr */
++#define R_TILEGX_MMSTART_X0   30      /* X0 pipe mm "start" */
++#define R_TILEGX_MMEND_X0     31      /* X0 pipe mm "end" */
++#define R_TILEGX_SHAMT_X0     32      /* X0 pipe shift amount */
++#define R_TILEGX_SHAMT_X1     33      /* X1 pipe shift amount */
++#define R_TILEGX_SHAMT_Y0     34      /* Y0 pipe shift amount */
++#define R_TILEGX_SHAMT_Y1     35      /* Y1 pipe shift amount */
++#define R_TILEGX_IMM16_X0_HW0 36      /* X0 pipe hword 0 */
++#define R_TILEGX_IMM16_X1_HW0 37      /* X1 pipe hword 0 */
++#define R_TILEGX_IMM16_X0_HW1 38      /* X0 pipe hword 1 */
++#define R_TILEGX_IMM16_X1_HW1 39      /* X1 pipe hword 1 */
++#define R_TILEGX_IMM16_X0_HW2 40      /* X0 pipe hword 2 */
++#define R_TILEGX_IMM16_X1_HW2 41      /* X1 pipe hword 2 */
++#define R_TILEGX_IMM16_X0_HW3 42      /* X0 pipe hword 3 */
++#define R_TILEGX_IMM16_X1_HW3 43      /* X1 pipe hword 3 */
++#define R_TILEGX_IMM16_X0_HW0_LAST 44 /* X0 pipe last hword 0 */
++#define R_TILEGX_IMM16_X1_HW0_LAST 45 /* X1 pipe last hword 0 */
++#define R_TILEGX_IMM16_X0_HW1_LAST 46 /* X0 pipe last hword 1 */
++#define R_TILEGX_IMM16_X1_HW1_LAST 47 /* X1 pipe last hword 1 */
++#define R_TILEGX_IMM16_X0_HW2_LAST 48 /* X0 pipe last hword 2 */
++#define R_TILEGX_IMM16_X1_HW2_LAST 49 /* X1 pipe last hword 2 */
++#define R_TILEGX_IMM16_X0_HW0_PCREL 50        /* X0 pipe PC relative hword 0 */
++#define R_TILEGX_IMM16_X1_HW0_PCREL 51        /* X1 pipe PC relative hword 0 */
++#define R_TILEGX_IMM16_X0_HW1_PCREL 52        /* X0 pipe PC relative hword 1 */
++#define R_TILEGX_IMM16_X1_HW1_PCREL 53        /* X1 pipe PC relative hword 1 */
++#define R_TILEGX_IMM16_X0_HW2_PCREL 54        /* X0 pipe PC relative hword 2 */
++#define R_TILEGX_IMM16_X1_HW2_PCREL 55        /* X1 pipe PC relative hword 2 */
++#define R_TILEGX_IMM16_X0_HW3_PCREL 56        /* X0 pipe PC relative hword 3 */
++#define R_TILEGX_IMM16_X1_HW3_PCREL 57        /* X1 pipe PC relative hword 3 */
++#define R_TILEGX_IMM16_X0_HW0_LAST_PCREL 58 /* X0 pipe PC-rel last hword 0 */
++#define R_TILEGX_IMM16_X1_HW0_LAST_PCREL 59 /* X1 pipe PC-rel last hword 0 */
++#define R_TILEGX_IMM16_X0_HW1_LAST_PCREL 60 /* X0 pipe PC-rel last hword 1 */
++#define R_TILEGX_IMM16_X1_HW1_LAST_PCREL 61 /* X1 pipe PC-rel last hword 1 */
++#define R_TILEGX_IMM16_X0_HW2_LAST_PCREL 62 /* X0 pipe PC-rel last hword 2 */
++#define R_TILEGX_IMM16_X1_HW2_LAST_PCREL 63 /* X1 pipe PC-rel last hword 2 */
++#define R_TILEGX_IMM16_X0_HW0_GOT 64  /* X0 pipe hword 0 GOT offset */
++#define R_TILEGX_IMM16_X1_HW0_GOT 65  /* X1 pipe hword 0 GOT offset */
++/* Relocs 66-71 are currently not defined.  */
++#define R_TILEGX_IMM16_X0_HW0_LAST_GOT 72 /* X0 pipe last hword 0 GOT offset */
++#define R_TILEGX_IMM16_X1_HW0_LAST_GOT 73 /* X1 pipe last hword 0 GOT offset */
++#define R_TILEGX_IMM16_X0_HW1_LAST_GOT 74 /* X0 pipe last hword 1 GOT offset */
++#define R_TILEGX_IMM16_X1_HW1_LAST_GOT 75 /* X1 pipe last hword 1 GOT offset */
++/* Relocs 76-77 are currently not defined.  */
++#define R_TILEGX_IMM16_X0_HW0_TLS_GD 78       /* X0 pipe hword 0 TLS GD offset */
++#define R_TILEGX_IMM16_X1_HW0_TLS_GD 79       /* X1 pipe hword 0 TLS GD offset */
++#define R_TILEGX_IMM16_X0_HW0_TLS_LE 80       /* X0 pipe hword 0 TLS LE offset */
++#define R_TILEGX_IMM16_X1_HW0_TLS_LE 81       /* X1 pipe hword 0 TLS LE offset */
++#define R_TILEGX_IMM16_X0_HW0_LAST_TLS_LE 82 /* X0 pipe last hword 0 LE off */
++#define R_TILEGX_IMM16_X1_HW0_LAST_TLS_LE 83 /* X1 pipe last hword 0 LE off */
++#define R_TILEGX_IMM16_X0_HW1_LAST_TLS_LE 84 /* X0 pipe last hword 1 LE off */
++#define R_TILEGX_IMM16_X1_HW1_LAST_TLS_LE 85 /* X1 pipe last hword 1 LE off */
++#define R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD 86 /* X0 pipe last hword 0 GD off */
++#define R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD 87 /* X1 pipe last hword 0 GD off */
++#define R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD 88 /* X0 pipe last hword 1 GD off */
++#define R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD 89 /* X1 pipe last hword 1 GD off */
++/* Relocs 90-91 are currently not defined.  */
++#define R_TILEGX_IMM16_X0_HW0_TLS_IE 92       /* X0 pipe hword 0 TLS IE offset */
++#define R_TILEGX_IMM16_X1_HW0_TLS_IE 93       /* X1 pipe hword 0 TLS IE offset */
++/* Relocs 94-99 are currently not defined.  */
++#define R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE 100 /* X0 pipe last hword 0 IE off */
++#define R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE 101 /* X1 pipe last hword 0 IE off */
++#define R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE 102 /* X0 pipe last hword 1 IE off */
++#define R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE 103 /* X1 pipe last hword 1 IE off */
++/* Relocs 104-105 are currently not defined.  */
++#define R_TILEGX_TLS_DTPMOD64 106     /* 64-bit ID of symbol's module */
++#define R_TILEGX_TLS_DTPOFF64 107     /* 64-bit offset in TLS block */
++#define R_TILEGX_TLS_TPOFF64  108     /* 64-bit offset in static TLS block */
++#define R_TILEGX_TLS_DTPMOD32 109     /* 32-bit ID of symbol's module */
++#define R_TILEGX_TLS_DTPOFF32 110     /* 32-bit offset in TLS block */
++#define R_TILEGX_TLS_TPOFF32  111     /* 32-bit offset in static TLS block */
++#define R_TILEGX_TLS_GD_CALL  112     /* "jal" for TLS GD */
++#define R_TILEGX_IMM8_X0_TLS_GD_ADD 113       /* X0 pipe "addi" for TLS GD */
++#define R_TILEGX_IMM8_X1_TLS_GD_ADD 114       /* X1 pipe "addi" for TLS GD */
++#define R_TILEGX_IMM8_Y0_TLS_GD_ADD 115       /* Y0 pipe "addi" for TLS GD */
++#define R_TILEGX_IMM8_Y1_TLS_GD_ADD 116       /* Y1 pipe "addi" for TLS GD */
++#define R_TILEGX_TLS_IE_LOAD  117     /* "ld_tls" for TLS IE */
++#define R_TILEGX_IMM8_X0_TLS_ADD 118  /* X0 pipe "addi" for TLS GD/IE */
++#define R_TILEGX_IMM8_X1_TLS_ADD 119  /* X1 pipe "addi" for TLS GD/IE */
++#define R_TILEGX_IMM8_Y0_TLS_ADD 120  /* Y0 pipe "addi" for TLS GD/IE */
++#define R_TILEGX_IMM8_Y1_TLS_ADD 121  /* Y1 pipe "addi" for TLS GD/IE */
++
++#define R_TILEGX_GNU_VTINHERIT        128     /* GNU C++ vtable hierarchy */
++#define R_TILEGX_GNU_VTENTRY  129     /* GNU C++ vtable member usage */
++
++#define R_TILEGX_NUM          130
++
++#endif        /* elf.h */
diff --git a/target/linux/generic/patches-3.18/212-byteshift_portability.patch b/target/linux/generic/patches-3.18/212-byteshift_portability.patch
new file mode 100644 (file)
index 0000000..0f23ba9
--- /dev/null
@@ -0,0 +1,51 @@
+--- a/tools/include/tools/be_byteshift.h
++++ b/tools/include/tools/be_byteshift.h
+@@ -1,6 +1,10 @@
+ #ifndef _TOOLS_BE_BYTESHIFT_H
+ #define _TOOLS_BE_BYTESHIFT_H
++#ifndef __linux__
++#include "linux_types.h"
++#endif
++
+ #include <stdint.h>
+ static inline uint16_t __get_unaligned_be16(const uint8_t *p)
+--- a/tools/include/tools/le_byteshift.h
++++ b/tools/include/tools/le_byteshift.h
+@@ -1,6 +1,10 @@
+ #ifndef _TOOLS_LE_BYTESHIFT_H
+ #define _TOOLS_LE_BYTESHIFT_H
++#ifndef __linux__
++#include "linux_types.h"
++#endif
++
+ #include <stdint.h>
+ static inline uint16_t __get_unaligned_le16(const uint8_t *p)
+--- /dev/null
++++ b/tools/include/tools/linux_types.h
+@@ -0,0 +1,22 @@
++#ifndef __LINUX_TYPES_H
++#define __LINUX_TYPES_H
++
++#include <stdint.h>
++
++typedef uint8_t __u8;
++typedef uint8_t __be8;
++typedef uint8_t __le8;
++
++typedef uint16_t __u16;
++typedef uint16_t __be16;
++typedef uint16_t __le16;
++
++typedef uint32_t __u32;
++typedef uint32_t __be32;
++typedef uint32_t __le32;
++
++typedef uint64_t __u64;
++typedef uint64_t __be64;
++typedef uint64_t __le64;
++
++#endif
diff --git a/target/linux/generic/patches-3.18/220-gc_sections.patch b/target/linux/generic/patches-3.18/220-gc_sections.patch
new file mode 100644 (file)
index 0000000..c105c40
--- /dev/null
@@ -0,0 +1,531 @@
+From: Felix Fietkau <nbd@openwrt.org>
+
+use -ffunction-sections, -fdata-sections and --gc-sections --sort-section=name
+
+In combination with kernel symbol export stripping this significantly reduces
+the kernel image size. Used on both ARM and MIPS architectures.
+
+Signed-off-by: Felix Fietkau <nbd@openwrt.org>
+Signed-off-by: Jonas Gorski <jogo@openwrt.org>
+Signed-off-by: Gabor Juhos <juhosg@openwrt.org>
+---
+
+--- a/arch/mips/Makefile
++++ b/arch/mips/Makefile
+@@ -89,10 +89,14 @@ all-$(CONFIG_SYS_SUPPORTS_ZBOOT)+= vmlin
+ #
+ cflags-y                      += -G 0 -mno-abicalls -fno-pic -pipe
+ cflags-y                      += -msoft-float
+-LDFLAGS_vmlinux                       += -G 0 -static -n -nostdlib
++LDFLAGS_vmlinux                       += -G 0 -static -n -nostdlib --gc-sections --sort-section=name
+ KBUILD_AFLAGS_MODULE          += -mlong-calls
+ KBUILD_CFLAGS_MODULE          += -mlong-calls
++ifndef CONFIG_FUNCTION_TRACER
++KBUILD_CFLAGS_KERNEL          += -ffunction-sections -fdata-sections
++endif
++
+ cflags-y += -ffreestanding
+ #
+--- a/arch/mips/kernel/vmlinux.lds.S
++++ b/arch/mips/kernel/vmlinux.lds.S
+@@ -67,7 +67,7 @@ SECTIONS
+       /* Exception table for data bus errors */
+       __dbe_table : {
+               __start___dbe_table = .;
+-              *(__dbe_table)
++              KEEP(*(__dbe_table))
+               __stop___dbe_table = .;
+       }
+@@ -112,7 +112,7 @@ SECTIONS
+       . = ALIGN(4);
+       .mips.machines.init : AT(ADDR(.mips.machines.init) - LOAD_OFFSET) {
+               __mips_machines_start = .;
+-              *(.mips.machines.init)
++              KEEP(*(.mips.machines.init))
+               __mips_machines_end = .;
+       }
+--- a/include/asm-generic/vmlinux.lds.h
++++ b/include/asm-generic/vmlinux.lds.h
+@@ -87,7 +87,7 @@
+ #ifdef CONFIG_FTRACE_MCOUNT_RECORD
+ #define MCOUNT_REC()  . = ALIGN(8);                           \
+                       VMLINUX_SYMBOL(__start_mcount_loc) = .; \
+-                      *(__mcount_loc)                         \
++                      KEEP(*(__mcount_loc))                   \
+                       VMLINUX_SYMBOL(__stop_mcount_loc) = .;
+ #else
+ #define MCOUNT_REC()
+@@ -95,7 +95,7 @@
+ #ifdef CONFIG_TRACE_BRANCH_PROFILING
+ #define LIKELY_PROFILE()      VMLINUX_SYMBOL(__start_annotated_branch_profile) = .; \
+-                              *(_ftrace_annotated_branch)                           \
++                              KEEP(*(_ftrace_annotated_branch))                     \
+                               VMLINUX_SYMBOL(__stop_annotated_branch_profile) = .;
+ #else
+ #define LIKELY_PROFILE()
+@@ -103,7 +103,7 @@
+ #ifdef CONFIG_PROFILE_ALL_BRANCHES
+ #define BRANCH_PROFILE()      VMLINUX_SYMBOL(__start_branch_profile) = .;   \
+-                              *(_ftrace_branch)                             \
++                              KEEP(*(_ftrace_branch))                       \
+                               VMLINUX_SYMBOL(__stop_branch_profile) = .;
+ #else
+ #define BRANCH_PROFILE()
+@@ -112,7 +112,7 @@
+ #ifdef CONFIG_EVENT_TRACING
+ #define FTRACE_EVENTS()       . = ALIGN(8);                                   \
+                       VMLINUX_SYMBOL(__start_ftrace_events) = .;      \
+-                      *(_ftrace_events)                               \
++                      KEEP(*(_ftrace_events))                         \
+                       VMLINUX_SYMBOL(__stop_ftrace_events) = .;
+ #else
+ #define FTRACE_EVENTS()
+@@ -120,7 +120,7 @@
+ #ifdef CONFIG_TRACING
+ #define TRACE_PRINTKS() VMLINUX_SYMBOL(__start___trace_bprintk_fmt) = .;      \
+-                       *(__trace_printk_fmt) /* Trace_printk fmt' pointer */ \
++                       KEEP(*(__trace_printk_fmt)) /* Trace_printk fmt' pointer */ \
+                        VMLINUX_SYMBOL(__stop___trace_bprintk_fmt) = .;
+ #define TRACEPOINT_STR() VMLINUX_SYMBOL(__start___tracepoint_str) = .;        \
+                        *(__tracepoint_str) /* Trace_printk fmt' pointer */ \
+@@ -133,7 +133,7 @@
+ #ifdef CONFIG_FTRACE_SYSCALLS
+ #define TRACE_SYSCALLS() . = ALIGN(8);                                        \
+                        VMLINUX_SYMBOL(__start_syscalls_metadata) = .; \
+-                       *(__syscalls_metadata)                         \
++                       KEEP(*(__syscalls_metadata))                   \
+                        VMLINUX_SYMBOL(__stop_syscalls_metadata) = .;
+ #else
+ #define TRACE_SYSCALLS()
+@@ -142,8 +142,8 @@
+ #ifdef CONFIG_CLKSRC_OF
+ #define CLKSRC_OF_TABLES() . = ALIGN(8);                              \
+                          VMLINUX_SYMBOL(__clksrc_of_table) = .;       \
+-                         *(__clksrc_of_table)                         \
+-                         *(__clksrc_of_table_end)
++                         KEEP(*(__clksrc_of_table))                   \
++                         KEEP(*(__clksrc_of_table_end))
+ #else
+ #define CLKSRC_OF_TABLES()
+ #endif
+@@ -152,8 +152,8 @@
+ #define IRQCHIP_OF_MATCH_TABLE()                                      \
+       . = ALIGN(8);                                                   \
+       VMLINUX_SYMBOL(__irqchip_begin) = .;                            \
+-      *(__irqchip_of_table)                                           \
+-      *(__irqchip_of_end)
++      KEEP(*(__irqchip_of_table))                                     \
++      KEEP(*(__irqchip_of_end))
+ #else
+ #define IRQCHIP_OF_MATCH_TABLE()
+ #endif
+@@ -161,8 +161,8 @@
+ #ifdef CONFIG_COMMON_CLK
+ #define CLK_OF_TABLES() . = ALIGN(8);                         \
+                       VMLINUX_SYMBOL(__clk_of_table) = .;     \
+-                      *(__clk_of_table)                       \
+-                      *(__clk_of_table_end)
++                      KEEP(*(__clk_of_table))                 \
++                      KEEP(*(__clk_of_table_end))
+ #else
+ #define CLK_OF_TABLES()
+ #endif
+@@ -170,7 +170,7 @@
+ #define KERNEL_DTB()                                                  \
+       STRUCT_ALIGN();                                                 \
+       VMLINUX_SYMBOL(__dtb_start) = .;                                \
+-      *(.dtb.init.rodata)                                             \
++      KEEP(*(.dtb.init.rodata))                                       \
+       VMLINUX_SYMBOL(__dtb_end) = .;
+ /* .data section */
+@@ -186,16 +186,17 @@
+       /* implement dynamic printk debug */                            \
+       . = ALIGN(8);                                                   \
+       VMLINUX_SYMBOL(__start___jump_table) = .;                       \
+-      *(__jump_table)                                                 \
++      KEEP(*(__jump_table))                                           \
+       VMLINUX_SYMBOL(__stop___jump_table) = .;                        \
+       . = ALIGN(8);                                                   \
+       VMLINUX_SYMBOL(__start___verbose) = .;                          \
+-      *(__verbose)                                                    \
++      KEEP(*(__verbose))                                              \
+       VMLINUX_SYMBOL(__stop___verbose) = .;                           \
+       LIKELY_PROFILE()                                                \
+       BRANCH_PROFILE()                                                \
+       TRACE_PRINTKS()                                                 \
+-      TRACEPOINT_STR()
++      TRACEPOINT_STR()                                                \
++      *(.data.[a-zA-Z_]*)
+ /*
+  * Data section helpers
+@@ -249,32 +250,32 @@
+       /* PCI quirks */                                                \
+       .pci_fixup        : AT(ADDR(.pci_fixup) - LOAD_OFFSET) {        \
+               VMLINUX_SYMBOL(__start_pci_fixups_early) = .;           \
+-              *(.pci_fixup_early)                                     \
++              KEEP(*(.pci_fixup_early))                               \
+               VMLINUX_SYMBOL(__end_pci_fixups_early) = .;             \
+               VMLINUX_SYMBOL(__start_pci_fixups_header) = .;          \
+-              *(.pci_fixup_header)                                    \
++              KEEP(*(.pci_fixup_header))                              \
+               VMLINUX_SYMBOL(__end_pci_fixups_header) = .;            \
+               VMLINUX_SYMBOL(__start_pci_fixups_final) = .;           \
+-              *(.pci_fixup_final)                                     \
++              KEEP(*(.pci_fixup_final))                               \
+               VMLINUX_SYMBOL(__end_pci_fixups_final) = .;             \
+               VMLINUX_SYMBOL(__start_pci_fixups_enable) = .;          \
+-              *(.pci_fixup_enable)                                    \
++              KEEP(*(.pci_fixup_enable))                              \
+               VMLINUX_SYMBOL(__end_pci_fixups_enable) = .;            \
+               VMLINUX_SYMBOL(__start_pci_fixups_resume) = .;          \
+-              *(.pci_fixup_resume)                                    \
++              KEEP(*(.pci_fixup_resume))                              \
+               VMLINUX_SYMBOL(__end_pci_fixups_resume) = .;            \
+               VMLINUX_SYMBOL(__start_pci_fixups_resume_early) = .;    \
+-              *(.pci_fixup_resume_early)                              \
++              KEEP(*(.pci_fixup_resume_early))                        \
+               VMLINUX_SYMBOL(__end_pci_fixups_resume_early) = .;      \
+               VMLINUX_SYMBOL(__start_pci_fixups_suspend) = .;         \
+-              *(.pci_fixup_suspend)                                   \
++              KEEP(*(.pci_fixup_suspend))                             \
+               VMLINUX_SYMBOL(__end_pci_fixups_suspend) = .;           \
+       }                                                               \
+                                                                       \
+       /* Built-in firmware blobs */                                   \
+       .builtin_fw        : AT(ADDR(.builtin_fw) - LOAD_OFFSET) {      \
+               VMLINUX_SYMBOL(__start_builtin_fw) = .;                 \
+-              *(.builtin_fw)                                          \
++              KEEP(*(.builtin_fw))                                    \
+               VMLINUX_SYMBOL(__end_builtin_fw) = .;                   \
+       }                                                               \
+                                                                       \
+@@ -283,49 +284,49 @@
+       /* Kernel symbol table: Normal symbols */                       \
+       __ksymtab         : AT(ADDR(__ksymtab) - LOAD_OFFSET) {         \
+               VMLINUX_SYMBOL(__start___ksymtab) = .;                  \
+-              *(SORT(___ksymtab+*))                                   \
++              KEEP(*(SORT(___ksymtab+*)))                             \
+               VMLINUX_SYMBOL(__stop___ksymtab) = .;                   \
+       }                                                               \
+                                                                       \
+       /* Kernel symbol table: GPL-only symbols */                     \
+       __ksymtab_gpl     : AT(ADDR(__ksymtab_gpl) - LOAD_OFFSET) {     \
+               VMLINUX_SYMBOL(__start___ksymtab_gpl) = .;              \
+-              *(SORT(___ksymtab_gpl+*))                               \
++              KEEP(*(SORT(___ksymtab_gpl+*)))                         \
+               VMLINUX_SYMBOL(__stop___ksymtab_gpl) = .;               \
+       }                                                               \
+                                                                       \
+       /* Kernel symbol table: Normal unused symbols */                \
+       __ksymtab_unused  : AT(ADDR(__ksymtab_unused) - LOAD_OFFSET) {  \
+               VMLINUX_SYMBOL(__start___ksymtab_unused) = .;           \
+-              *(SORT(___ksymtab_unused+*))                            \
++              KEEP(*(SORT(___ksymtab_unused+*)))                      \
+               VMLINUX_SYMBOL(__stop___ksymtab_unused) = .;            \
+       }                                                               \
+                                                                       \
+       /* Kernel symbol table: GPL-only unused symbols */              \
+       __ksymtab_unused_gpl : AT(ADDR(__ksymtab_unused_gpl) - LOAD_OFFSET) { \
+               VMLINUX_SYMBOL(__start___ksymtab_unused_gpl) = .;       \
+-              *(SORT(___ksymtab_unused_gpl+*))                        \
++              KEEP(*(SORT(___ksymtab_unused_gpl+*)))                  \
+               VMLINUX_SYMBOL(__stop___ksymtab_unused_gpl) = .;        \
+       }                                                               \
+                                                                       \
+       /* Kernel symbol table: GPL-future-only symbols */              \
+       __ksymtab_gpl_future : AT(ADDR(__ksymtab_gpl_future) - LOAD_OFFSET) { \
+               VMLINUX_SYMBOL(__start___ksymtab_gpl_future) = .;       \
+-              *(SORT(___ksymtab_gpl_future+*))                        \
++              KEEP(*(SORT(___ksymtab_gpl_future+*)))                  \
+               VMLINUX_SYMBOL(__stop___ksymtab_gpl_future) = .;        \
+       }                                                               \
+                                                                       \
+       /* Kernel symbol table: Normal symbols */                       \
+       __kcrctab         : AT(ADDR(__kcrctab) - LOAD_OFFSET) {         \
+               VMLINUX_SYMBOL(__start___kcrctab) = .;                  \
+-              *(SORT(___kcrctab+*))                                   \
++              KEEP(*(SORT(___kcrctab+*)))                             \
+               VMLINUX_SYMBOL(__stop___kcrctab) = .;                   \
+       }                                                               \
+                                                                       \
+       /* Kernel symbol table: GPL-only symbols */                     \
+       __kcrctab_gpl     : AT(ADDR(__kcrctab_gpl) - LOAD_OFFSET) {     \
+               VMLINUX_SYMBOL(__start___kcrctab_gpl) = .;              \
+-              *(SORT(___kcrctab_gpl+*))                               \
++              KEEP(*(SORT(___kcrctab_gpl+*)))                         \
+               VMLINUX_SYMBOL(__stop___kcrctab_gpl) = .;               \
+       }                                                               \
+                                                                       \
+@@ -339,14 +340,14 @@
+       /* Kernel symbol table: GPL-only unused symbols */              \
+       __kcrctab_unused_gpl : AT(ADDR(__kcrctab_unused_gpl) - LOAD_OFFSET) { \
+               VMLINUX_SYMBOL(__start___kcrctab_unused_gpl) = .;       \
+-              *(SORT(___kcrctab_unused_gpl+*))                        \
++              KEEP(*(SORT(___kcrctab_unused_gpl+*)))                  \
+               VMLINUX_SYMBOL(__stop___kcrctab_unused_gpl) = .;        \
+       }                                                               \
+                                                                       \
+       /* Kernel symbol table: GPL-future-only symbols */              \
+       __kcrctab_gpl_future : AT(ADDR(__kcrctab_gpl_future) - LOAD_OFFSET) { \
+               VMLINUX_SYMBOL(__start___kcrctab_gpl_future) = .;       \
+-              *(SORT(___kcrctab_gpl_future+*))                        \
++              KEEP(*(SORT(___kcrctab_gpl_future+*)))                  \
+               VMLINUX_SYMBOL(__stop___kcrctab_gpl_future) = .;        \
+       }                                                               \
+                                                                       \
+@@ -365,14 +366,14 @@
+       /* Built-in module parameters. */                               \
+       __param : AT(ADDR(__param) - LOAD_OFFSET) {                     \
+               VMLINUX_SYMBOL(__start___param) = .;                    \
+-              *(__param)                                              \
++              KEEP(*(__param))                                        \
+               VMLINUX_SYMBOL(__stop___param) = .;                     \
+       }                                                               \
+                                                                       \
+       /* Built-in module versions. */                                 \
+       __modver : AT(ADDR(__modver) - LOAD_OFFSET) {                   \
+               VMLINUX_SYMBOL(__start___modver) = .;                   \
+-              *(__modver)                                             \
++              KEEP(*(__modver))                                       \
+               VMLINUX_SYMBOL(__stop___modver) = .;                    \
+               . = ALIGN((align));                                     \
+               VMLINUX_SYMBOL(__end_rodata) = .;                       \
+@@ -428,7 +429,7 @@
+ #define ENTRY_TEXT                                                    \
+               ALIGN_FUNCTION();                                       \
+               VMLINUX_SYMBOL(__entry_text_start) = .;                 \
+-              *(.entry.text)                                          \
++              KEEP(*(.entry.text))                                    \
+               VMLINUX_SYMBOL(__entry_text_end) = .;
+ #ifdef CONFIG_FUNCTION_GRAPH_TRACER
+@@ -456,7 +457,7 @@
+       . = ALIGN(align);                                               \
+       __ex_table : AT(ADDR(__ex_table) - LOAD_OFFSET) {               \
+               VMLINUX_SYMBOL(__start___ex_table) = .;                 \
+-              *(__ex_table)                                           \
++              KEEP(*(__ex_table))                                             \
+               VMLINUX_SYMBOL(__stop___ex_table) = .;                  \
+       }
+@@ -472,8 +473,8 @@
+ #ifdef CONFIG_CONSTRUCTORS
+ #define KERNEL_CTORS()        . = ALIGN(8);                      \
+                       VMLINUX_SYMBOL(__ctors_start) = .; \
+-                      *(.ctors)                          \
+-                      *(.init_array)                     \
++                      KEEP(*(.ctors))                    \
++                      KEEP(*(.init_array))               \
+                       VMLINUX_SYMBOL(__ctors_end) = .;
+ #else
+ #define KERNEL_CTORS()
+@@ -517,7 +518,7 @@
+ #define SBSS(sbss_align)                                              \
+       . = ALIGN(sbss_align);                                          \
+       .sbss : AT(ADDR(.sbss) - LOAD_OFFSET) {                         \
+-              *(.sbss)                                                \
++              *(.sbss .sbss.*)                                        \
+               *(.scommon)                                             \
+       }
+@@ -535,7 +536,7 @@
+               BSS_FIRST_SECTIONS                                      \
+               *(.bss..page_aligned)                                   \
+               *(.dynbss)                                              \
+-              *(.bss)                                                 \
++              *(.bss .bss.*)                                          \
+               *(COMMON)                                               \
+       }
+@@ -596,7 +597,7 @@
+       . = ALIGN(4);                                                   \
+       .tracedata : AT(ADDR(.tracedata) - LOAD_OFFSET) {               \
+               VMLINUX_SYMBOL(__tracedata_start) = .;                  \
+-              *(.tracedata)                                           \
++              KEEP(*(.tracedata))                                     \
+               VMLINUX_SYMBOL(__tracedata_end) = .;                    \
+       }
+ #else
+@@ -613,17 +614,17 @@
+ #define INIT_SETUP(initsetup_align)                                   \
+               . = ALIGN(initsetup_align);                             \
+               VMLINUX_SYMBOL(__setup_start) = .;                      \
+-              *(.init.setup)                                          \
++              KEEP(*(.init.setup))                                    \
+               VMLINUX_SYMBOL(__setup_end) = .;
+ #define INIT_CALLS_LEVEL(level)                                               \
+               VMLINUX_SYMBOL(__initcall##level##_start) = .;          \
+-              *(.initcall##level##.init)                              \
+-              *(.initcall##level##s.init)                             \
++              KEEP(*(.initcall##level##.init))                        \
++              KEEP(*(.initcall##level##s.init))                       \
+ #define INIT_CALLS                                                    \
+               VMLINUX_SYMBOL(__initcall_start) = .;                   \
+-              *(.initcallearly.init)                                  \
++              KEEP(*(.initcallearly.init))                            \
+               INIT_CALLS_LEVEL(0)                                     \
+               INIT_CALLS_LEVEL(1)                                     \
+               INIT_CALLS_LEVEL(2)                                     \
+@@ -637,21 +638,21 @@
+ #define CON_INITCALL                                                  \
+               VMLINUX_SYMBOL(__con_initcall_start) = .;               \
+-              *(.con_initcall.init)                                   \
++              KEEP(*(.con_initcall.init))                             \
+               VMLINUX_SYMBOL(__con_initcall_end) = .;
+ #define SECURITY_INITCALL                                             \
+               VMLINUX_SYMBOL(__security_initcall_start) = .;          \
+-              *(.security_initcall.init)                              \
++              KEEP(*(.security_initcall.init))                        \
+               VMLINUX_SYMBOL(__security_initcall_end) = .;
+ #ifdef CONFIG_BLK_DEV_INITRD
+ #define INIT_RAM_FS                                                   \
+       . = ALIGN(4);                                                   \
+       VMLINUX_SYMBOL(__initramfs_start) = .;                          \
+-      *(.init.ramfs)                                                  \
++      KEEP(*(.init.ramfs))                                            \
+       . = ALIGN(8);                                                   \
+-      *(.init.ramfs.info)
++      KEEP(*(.init.ramfs.info))
+ #else
+ #define INIT_RAM_FS
+ #endif
+--- a/arch/arm/Makefile
++++ b/arch/arm/Makefile
+@@ -18,11 +18,16 @@ ifeq ($(CONFIG_CPU_ENDIAN_BE8),y)
+ LDFLAGS_vmlinux       += --be8
+ LDFLAGS_MODULE        += --be8
+ endif
++LDFLAGS_vmlinux += --gc-sections --sort-section=name
+ OBJCOPYFLAGS  :=-O binary -R .comment -S
+ GZFLAGS               :=-9
+ #KBUILD_CFLAGS        +=-pipe
++ifndef CONFIG_FUNCTION_TRACER
++KBUILD_CFLAGS_KERNEL += -ffunction-sections -fdata-sections
++endif
++
+ # Never generate .eh_frame
+ KBUILD_CFLAGS += $(call cc-option,-fno-dwarf2-cfi-asm)
+--- a/arch/arm/kernel/vmlinux.lds.S
++++ b/arch/arm/kernel/vmlinux.lds.S
+@@ -12,13 +12,13 @@
+ #define PROC_INFO                                                     \
+       . = ALIGN(4);                                                   \
+       VMLINUX_SYMBOL(__proc_info_begin) = .;                          \
+-      *(.proc.info.init)                                              \
++      KEEP(*(.proc.info.init))                                        \
+       VMLINUX_SYMBOL(__proc_info_end) = .;
+ #define IDMAP_TEXT                                                    \
+       ALIGN_FUNCTION();                                               \
+       VMLINUX_SYMBOL(__idmap_text_start) = .;                         \
+-      *(.idmap.text)                                                  \
++      KEEP(*(.idmap.text))                                            \
+       VMLINUX_SYMBOL(__idmap_text_end) = .;                           \
+       . = ALIGN(32);                                                  \
+       VMLINUX_SYMBOL(__hyp_idmap_text_start) = .;                     \
+@@ -93,7 +93,7 @@ SECTIONS
+       .text : {                       /* Real text segment            */
+               _stext = .;             /* Text and read-only data      */
+                       __exception_text_start = .;
+-                      *(.exception.text)
++                      KEEP(*(.exception.text))
+                       __exception_text_end = .;
+                       IRQENTRY_TEXT
+                       TEXT_TEXT
+@@ -118,7 +118,7 @@ SECTIONS
+       __ex_table : AT(ADDR(__ex_table) - LOAD_OFFSET) {
+               __start___ex_table = .;
+ #ifdef CONFIG_MMU
+-              *(__ex_table)
++              KEEP(*(__ex_table))
+ #endif
+               __stop___ex_table = .;
+       }
+@@ -130,12 +130,12 @@ SECTIONS
+       . = ALIGN(8);
+       .ARM.unwind_idx : {
+               __start_unwind_idx = .;
+-              *(.ARM.exidx*)
++              KEEP(*(.ARM.exidx*))
+               __stop_unwind_idx = .;
+       }
+       .ARM.unwind_tab : {
+               __start_unwind_tab = .;
+-              *(.ARM.extab*)
++              KEEP(*(.ARM.extab*))
+               __stop_unwind_tab = .;
+       }
+ #endif
+@@ -154,14 +154,14 @@ SECTIONS
+        */
+       __vectors_start = .;
+       .vectors 0 : AT(__vectors_start) {
+-              *(.vectors)
++              KEEP(*(.vectors))
+       }
+       . = __vectors_start + SIZEOF(.vectors);
+       __vectors_end = .;
+       __stubs_start = .;
+       .stubs 0x1000 : AT(__stubs_start) {
+-              *(.stubs)
++              KEEP(*(.stubs))
+       }
+       . = __stubs_start + SIZEOF(.stubs);
+       __stubs_end = .;
+@@ -175,24 +175,24 @@ SECTIONS
+       }
+       .init.arch.info : {
+               __arch_info_begin = .;
+-              *(.arch.info.init)
++              KEEP(*(.arch.info.init))
+               __arch_info_end = .;
+       }
+       .init.tagtable : {
+               __tagtable_begin = .;
+-              *(.taglist.init)
++              KEEP(*(.taglist.init))
+               __tagtable_end = .;
+       }
+ #ifdef CONFIG_SMP_ON_UP
+       .init.smpalt : {
+               __smpalt_begin = .;
+-              *(.alt.smp.init)
++              KEEP(*(.alt.smp.init))
+               __smpalt_end = .;
+       }
+ #endif
+       .init.pv_table : {
+               __pv_table_begin = .;
+-              *(.pv_table)
++              KEEP(*(.pv_table))
+               __pv_table_end = .;
+       }
+       .init.data : {
+--- a/arch/arm/boot/compressed/Makefile
++++ b/arch/arm/boot/compressed/Makefile
+@@ -120,6 +120,7 @@ ifeq ($(CONFIG_FUNCTION_TRACER),y)
+ ORIG_CFLAGS := $(KBUILD_CFLAGS)
+ KBUILD_CFLAGS = $(subst -pg, , $(ORIG_CFLAGS))
+ endif
++KBUILD_CFLAGS_KERNEL := $(patsubst -f%-sections,,$(KBUILD_CFLAGS_KERNEL))
+ ccflags-y := -fpic -mno-single-pic-base -fno-builtin -I$(obj)
+ asflags-y := -DZIMAGE
diff --git a/target/linux/generic/patches-3.18/221-module_exports.patch b/target/linux/generic/patches-3.18/221-module_exports.patch
new file mode 100644 (file)
index 0000000..b538003
--- /dev/null
@@ -0,0 +1,88 @@
+--- a/include/asm-generic/vmlinux.lds.h
++++ b/include/asm-generic/vmlinux.lds.h
+@@ -52,6 +52,16 @@
+ #define LOAD_OFFSET 0
+ #endif
++#ifndef SYMTAB_KEEP
++#define SYMTAB_KEEP KEEP(*(SORT(___ksymtab+*)))
++#define SYMTAB_KEEP_GPL KEEP(*(SORT(___ksymtab_gpl+*)))
++#endif
++
++#ifndef SYMTAB_DISCARD
++#define SYMTAB_DISCARD
++#define SYMTAB_DISCARD_GPL
++#endif
++
+ #include <linux/export.h>
+ /* Align . to a 8 byte boundary equals to maximum function alignment. */
+@@ -284,14 +294,14 @@
+       /* Kernel symbol table: Normal symbols */                       \
+       __ksymtab         : AT(ADDR(__ksymtab) - LOAD_OFFSET) {         \
+               VMLINUX_SYMBOL(__start___ksymtab) = .;                  \
+-              KEEP(*(SORT(___ksymtab+*)))                             \
++              SYMTAB_KEEP                                             \
+               VMLINUX_SYMBOL(__stop___ksymtab) = .;                   \
+       }                                                               \
+                                                                       \
+       /* Kernel symbol table: GPL-only symbols */                     \
+       __ksymtab_gpl     : AT(ADDR(__ksymtab_gpl) - LOAD_OFFSET) {     \
+               VMLINUX_SYMBOL(__start___ksymtab_gpl) = .;              \
+-              KEEP(*(SORT(___ksymtab_gpl+*)))                         \
++              SYMTAB_KEEP_GPL                                         \
+               VMLINUX_SYMBOL(__stop___ksymtab_gpl) = .;               \
+       }                                                               \
+                                                                       \
+@@ -353,7 +363,7 @@
+                                                                       \
+       /* Kernel symbol table: strings */                              \
+         __ksymtab_strings : AT(ADDR(__ksymtab_strings) - LOAD_OFFSET) {       \
+-              *(__ksymtab_strings)                                    \
++              *(__ksymtab_strings+*)                                  \
+       }                                                               \
+                                                                       \
+       /* __*init sections */                                          \
+@@ -671,6 +681,8 @@
+       EXIT_TEXT                                                       \
+       EXIT_DATA                                                       \
+       EXIT_CALL                                                       \
++      SYMTAB_DISCARD                                                  \
++      SYMTAB_DISCARD_GPL                                              \
+       *(.discard)                                                     \
+       *(.discard.*)                                                   \
+       }
+--- a/scripts/Makefile.build
++++ b/scripts/Makefile.build
+@@ -349,7 +349,7 @@ targets += $(extra-y) $(MAKECMDGOALS) $(
+ # Linker scripts preprocessor (.lds.S -> .lds)
+ # ---------------------------------------------------------------------------
+ quiet_cmd_cpp_lds_S = LDS     $@
+-      cmd_cpp_lds_S = $(CPP) $(cpp_flags) -P -C -U$(ARCH) \
++      cmd_cpp_lds_S = $(CPP) $(EXTRA_LDSFLAGS) $(cpp_flags) -P -C -U$(ARCH) \
+                            -D__ASSEMBLY__ -DLINKER_SCRIPT -o $@ $<
+ $(obj)/%.lds: $(src)/%.lds.S FORCE
+--- a/include/linux/export.h
++++ b/include/linux/export.h
+@@ -52,12 +52,19 @@ extern struct module __this_module;
+ #define __CRC_SYMBOL(sym, sec)
+ #endif
++#ifdef MODULE
++#define __EXPORT_SUFFIX(sym)
++#else
++#define __EXPORT_SUFFIX(sym) "+" #sym
++#endif
++
+ /* For every exported symbol, place a struct in the __ksymtab section */
+ #define __EXPORT_SYMBOL(sym, sec)                             \
+       extern typeof(sym) sym;                                 \
+       __CRC_SYMBOL(sym, sec)                                  \
+       static const char __kstrtab_##sym[]                     \
+-      __attribute__((section("__ksymtab_strings"), aligned(1))) \
++      __attribute__((section("__ksymtab_strings"              \
++        __EXPORT_SUFFIX(sym)), aligned(1)))                   \
+       = VMLINUX_SYMBOL_STR(sym);                              \
+       extern const struct kernel_symbol __ksymtab_##sym;      \
+       __visible const struct kernel_symbol __ksymtab_##sym    \
diff --git a/target/linux/generic/patches-3.18/230-openwrt_lzma_options.patch b/target/linux/generic/patches-3.18/230-openwrt_lzma_options.patch
new file mode 100644 (file)
index 0000000..e59fdcd
--- /dev/null
@@ -0,0 +1,58 @@
+--- a/scripts/Makefile.lib
++++ b/scripts/Makefile.lib
+@@ -325,7 +325,7 @@ cmd_bzip2 = (cat $(filter-out FORCE,$^)
+ quiet_cmd_lzma = LZMA    $@
+ cmd_lzma = (cat $(filter-out FORCE,$^) | \
+-      lzma -9 && $(call size_append, $(filter-out FORCE,$^))) > $@ || \
++      lzma e -d20 -lc1 -lp2 -pb2 -eos -si -so && $(call size_append, $(filter-out FORCE,$^))) > $@ || \
+       (rm -f $@ ; false)
+ quiet_cmd_lzo = LZO     $@
+--- a/scripts/gen_initramfs_list.sh
++++ b/scripts/gen_initramfs_list.sh
+@@ -226,7 +226,7 @@ cpio_list=
+ output="/dev/stdout"
+ output_file=""
+ is_cpio_compressed=
+-compr="gzip -n -9 -f"
++compr="gzip -n -9 -f -"
+ arg="$1"
+ case "$arg" in
+@@ -242,13 +242,13 @@ case "$arg" in
+               output=${cpio_list}
+               echo "$output_file" | grep -q "\.gz$" \
+                 && [ -x "`which gzip 2> /dev/null`" ] \
+-                && compr="gzip -n -9 -f"
++                && compr="gzip -n -9 -f -"
+               echo "$output_file" | grep -q "\.bz2$" \
+                 && [ -x "`which bzip2 2> /dev/null`" ] \
+-                && compr="bzip2 -9 -f"
++                && compr="bzip2 -9 -f -"
+               echo "$output_file" | grep -q "\.lzma$" \
+                 && [ -x "`which lzma 2> /dev/null`" ] \
+-                && compr="lzma -9 -f"
++                && compr="lzma e -d20 -lc1 -lp2 -pb2 -eos -si -so"
+               echo "$output_file" | grep -q "\.xz$" \
+                 && [ -x "`which xz 2> /dev/null`" ] \
+                 && compr="xz --check=crc32 --lzma2=dict=1MiB"
+@@ -315,7 +315,7 @@ if [ ! -z ${output_file} ]; then
+       if [ "${is_cpio_compressed}" = "compressed" ]; then
+               cat ${cpio_tfile} > ${output_file}
+       else
+-              (cat ${cpio_tfile} | ${compr}  - > ${output_file}) \
++              (cat ${cpio_tfile} | ${compr} > ${output_file}) \
+               || (rm -f ${output_file} ; false)
+       fi
+       [ -z ${cpio_file} ] && rm ${cpio_tfile}
+--- a/lib/decompress.c
++++ b/lib/decompress.c
+@@ -48,6 +48,7 @@ static const struct compress_format comp
+       { {037, 0236}, "gzip", gunzip },
+       { {0x42, 0x5a}, "bzip2", bunzip2 },
+       { {0x5d, 0x00}, "lzma", unlzma },
++      { {0x6d, 0x00}, "lzma-openwrt", unlzma },
+       { {0xfd, 0x37}, "xz", unxz },
+       { {0x89, 0x4c}, "lzo", unlzo },
+       { {0x02, 0x21}, "lz4", unlz4 },
diff --git a/target/linux/generic/patches-3.18/250-netfilter_depends.patch b/target/linux/generic/patches-3.18/250-netfilter_depends.patch
new file mode 100644 (file)
index 0000000..af59b02
--- /dev/null
@@ -0,0 +1,18 @@
+--- a/net/netfilter/Kconfig
++++ b/net/netfilter/Kconfig
+@@ -198,7 +198,6 @@ config NF_CONNTRACK_FTP
+ config NF_CONNTRACK_H323
+       tristate "H.323 protocol support"
+-      depends on (IPV6 || IPV6=n)
+       depends on NETFILTER_ADVANCED
+       help
+         H.323 is a VoIP signalling protocol from ITU-T. As one of the most
+@@ -895,7 +894,6 @@ config NETFILTER_XT_TARGET_SECMARK
+ config NETFILTER_XT_TARGET_TCPMSS
+       tristate '"TCPMSS" target support'
+-      depends on (IPV6 || IPV6=n)
+       default m if NETFILTER_ADVANCED=n
+       ---help---
+         This option adds a `TCPMSS' target, which allows you to alter the
diff --git a/target/linux/generic/patches-3.18/251-sound_kconfig.patch b/target/linux/generic/patches-3.18/251-sound_kconfig.patch
new file mode 100644 (file)
index 0000000..c2ebace
--- /dev/null
@@ -0,0 +1,18 @@
+--- a/sound/core/Kconfig
++++ b/sound/core/Kconfig
+@@ -10,13 +10,13 @@ config SND_DMAENGINE_PCM
+       tristate
+ config SND_HWDEP
+-      tristate
++      tristate "Sound hardware support"
+ config SND_RAWMIDI
+       tristate
+ config SND_COMPRESS_OFFLOAD
+-      tristate
++      tristate "Compression offloading support"
+ # To be effective this also requires INPUT - users should say:
+ #    select SND_JACK if INPUT=y || INPUT=SND
diff --git a/target/linux/generic/patches-3.18/252-mv_cesa_depends.patch b/target/linux/generic/patches-3.18/252-mv_cesa_depends.patch
new file mode 100644 (file)
index 0000000..fee28db
--- /dev/null
@@ -0,0 +1,10 @@
+--- a/drivers/crypto/Kconfig
++++ b/drivers/crypto/Kconfig
+@@ -164,6 +164,7 @@ config CRYPTO_DEV_MV_CESA
+       depends on PLAT_ORION
+       select CRYPTO_ALGAPI
+       select CRYPTO_AES
++      select CRYPTO_HASH2
+       select CRYPTO_BLKCIPHER2
+       select CRYPTO_HASH
+       help
diff --git a/target/linux/generic/patches-3.18/253-ssb_b43_default_on.patch b/target/linux/generic/patches-3.18/253-ssb_b43_default_on.patch
new file mode 100644 (file)
index 0000000..29d2a41
--- /dev/null
@@ -0,0 +1,29 @@
+--- a/drivers/ssb/Kconfig
++++ b/drivers/ssb/Kconfig
+@@ -29,6 +29,7 @@ config SSB_SPROM
+ config SSB_BLOCKIO
+       bool
+       depends on SSB
++      default y
+ config SSB_PCIHOST_POSSIBLE
+       bool
+@@ -49,7 +50,7 @@ config SSB_PCIHOST
+ config SSB_B43_PCI_BRIDGE
+       bool
+       depends on SSB_PCIHOST
+-      default n
++      default y
+ config SSB_PCMCIAHOST_POSSIBLE
+       bool
+--- a/drivers/bcma/Kconfig
++++ b/drivers/bcma/Kconfig
+@@ -17,6 +17,7 @@ config BCMA
+ config BCMA_BLOCKIO
+       bool
+       depends on BCMA
++      default y
+ config BCMA_HOST_PCI_POSSIBLE
+       bool
diff --git a/target/linux/generic/patches-3.18/254-textsearch_kconfig_hacks.patch b/target/linux/generic/patches-3.18/254-textsearch_kconfig_hacks.patch
new file mode 100644 (file)
index 0000000..3c3b1e1
--- /dev/null
@@ -0,0 +1,23 @@
+--- a/lib/Kconfig
++++ b/lib/Kconfig
+@@ -320,16 +320,16 @@ config BCH_CONST_T
+ # Textsearch support is select'ed if needed
+ #
+ config TEXTSEARCH
+-      boolean
++      boolean "Textsearch support"
+ config TEXTSEARCH_KMP
+-      tristate
++      tristate "Textsearch KMP"
+ config TEXTSEARCH_BM
+-      tristate
++      tristate "Textsearch BM"
+ config TEXTSEARCH_FSM
+-      tristate
++      tristate "Textsearch FSM"
+ config BTREE
+       boolean
diff --git a/target/linux/generic/patches-3.18/255-lib80211_kconfig_hacks.patch b/target/linux/generic/patches-3.18/255-lib80211_kconfig_hacks.patch
new file mode 100644 (file)
index 0000000..32bb2aa
--- /dev/null
@@ -0,0 +1,19 @@
+--- a/net/wireless/Kconfig
++++ b/net/wireless/Kconfig
+@@ -192,13 +192,13 @@ config LIB80211
+         Drivers should select this themselves if needed.
+ config LIB80211_CRYPT_WEP
+-      tristate
++      tristate "LIB80211_CRYPT_WEP"
+ config LIB80211_CRYPT_CCMP
+-      tristate
++      tristate "LIB80211_CRYPT_CCMP"
+ config LIB80211_CRYPT_TKIP
+-      tristate
++      tristate "LIB80211_CRYPT_TKIP"
+ config LIB80211_DEBUG
+       bool "lib80211 debugging messages"
diff --git a/target/linux/generic/patches-3.18/256-crypto_add_kconfig_prompts.patch b/target/linux/generic/patches-3.18/256-crypto_add_kconfig_prompts.patch
new file mode 100644 (file)
index 0000000..f9f6c0e
--- /dev/null
@@ -0,0 +1,47 @@
+--- a/crypto/Kconfig
++++ b/crypto/Kconfig
+@@ -32,7 +32,7 @@ config CRYPTO_FIPS
+         this is.
+ config CRYPTO_ALGAPI
+-      tristate
++      tristate "ALGAPI"
+       select CRYPTO_ALGAPI2
+       help
+         This option provides the API for cryptographic algorithms.
+@@ -41,7 +41,7 @@ config CRYPTO_ALGAPI2
+       tristate
+ config CRYPTO_AEAD
+-      tristate
++      tristate "AEAD"
+       select CRYPTO_AEAD2
+       select CRYPTO_ALGAPI
+@@ -50,7 +50,7 @@ config CRYPTO_AEAD2
+       select CRYPTO_ALGAPI2
+ config CRYPTO_BLKCIPHER
+-      tristate
++      tristate "BLKCIPHER"
+       select CRYPTO_BLKCIPHER2
+       select CRYPTO_ALGAPI
+@@ -61,7 +61,7 @@ config CRYPTO_BLKCIPHER2
+       select CRYPTO_WORKQUEUE
+ config CRYPTO_HASH
+-      tristate
++      tristate "HASH"
+       select CRYPTO_HASH2
+       select CRYPTO_ALGAPI
+@@ -70,7 +70,7 @@ config CRYPTO_HASH2
+       select CRYPTO_ALGAPI2
+ config CRYPTO_RNG
+-      tristate
++      tristate "RNG"
+       select CRYPTO_RNG2
+       select CRYPTO_ALGAPI
diff --git a/target/linux/generic/patches-3.18/257-wireless_ext_kconfig_hack.patch b/target/linux/generic/patches-3.18/257-wireless_ext_kconfig_hack.patch
new file mode 100644 (file)
index 0000000..daac589
--- /dev/null
@@ -0,0 +1,22 @@
+--- a/net/wireless/Kconfig
++++ b/net/wireless/Kconfig
+@@ -1,5 +1,5 @@
+ config WIRELESS_EXT
+-      bool
++      bool "Wireless extensions"
+ config WEXT_CORE
+       def_bool y
+@@ -11,10 +11,10 @@ config WEXT_PROC
+       depends on WEXT_CORE
+ config WEXT_SPY
+-      bool
++      bool "WEXT_SPY"
+ config WEXT_PRIV
+-      bool
++      bool "WEXT_PRIV"
+ config CFG80211
+       tristate "cfg80211 - wireless configuration API"
diff --git a/target/linux/generic/patches-3.18/258-netfilter_netlink_kconfig_hack.patch b/target/linux/generic/patches-3.18/258-netfilter_netlink_kconfig_hack.patch
new file mode 100644 (file)
index 0000000..9d827c2
--- /dev/null
@@ -0,0 +1,11 @@
+--- a/net/netfilter/Kconfig
++++ b/net/netfilter/Kconfig
+@@ -2,7 +2,7 @@ menu "Core Netfilter Configuration"
+       depends on NET && INET && NETFILTER
+ config NETFILTER_NETLINK
+-      tristate
++      tristate "Netfilter NFNETLINK interface"
+ config NETFILTER_NETLINK_ACCT
+ tristate "Netfilter NFACCT over NFNETLINK interface"
diff --git a/target/linux/generic/patches-3.18/259-regmap_dynamic.patch b/target/linux/generic/patches-3.18/259-regmap_dynamic.patch
new file mode 100644 (file)
index 0000000..e7f5bce
--- /dev/null
@@ -0,0 +1,76 @@
+--- a/drivers/base/regmap/Kconfig
++++ b/drivers/base/regmap/Kconfig
+@@ -3,23 +3,28 @@
+ # subsystems should select the appropriate symbols.
+ config REGMAP
+-      default y if (REGMAP_I2C || REGMAP_SPI || REGMAP_SPMI || REGMAP_MMIO || REGMAP_IRQ)
+       select LZO_COMPRESS
+       select LZO_DECOMPRESS
+       select IRQ_DOMAIN if REGMAP_IRQ
+-      bool
++      tristate "Regmap"
+ config REGMAP_I2C
+-      tristate
++      select REGMAP
++      tristate "Regmap I2C
+ config REGMAP_SPI
+-      tristate
++      select REGMAP
++      depends on SPI_MASTER
++      tristate "Regmap SPI"
+ config REGMAP_SPMI
++      select REGMAP
+       tristate
+ config REGMAP_MMIO
++      select REGMAP
+       tristate
+ config REGMAP_IRQ
++      select REGMAP
+       bool
+--- a/include/linux/regmap.h
++++ b/include/linux/regmap.h
+@@ -49,7 +49,7 @@ struct reg_default {
+       unsigned int def;
+ };
+-#ifdef CONFIG_REGMAP
++#if IS_ENABLED(CONFIG_REGMAP)
+ enum regmap_endian {
+       /* Unspecified -> 0 -> Backwards compatible default */
+--- a/drivers/base/regmap/Makefile
++++ b/drivers/base/regmap/Makefile
+@@ -1,6 +1,8 @@
+-obj-$(CONFIG_REGMAP) += regmap.o regcache.o
+-obj-$(CONFIG_REGMAP) += regcache-rbtree.o regcache-lzo.o regcache-flat.o
+-obj-$(CONFIG_DEBUG_FS) += regmap-debugfs.o
++regmap-core-objs = regmap.o regcache.o regcache-rbtree.o regcache-lzo.o regcache-flat.o
++ifdef CONFIG_DEBUG_FS
++regmap-core-objs += regmap-debugfs.o
++endif
++obj-$(CONFIG_REGMAP) += regmap-core.o
+ obj-$(CONFIG_REGMAP_I2C) += regmap-i2c.o
+ obj-$(CONFIG_REGMAP_SPI) += regmap-spi.o
+ obj-$(CONFIG_REGMAP_SPMI) += regmap-spmi.o
+--- a/drivers/base/regmap/regmap.c
++++ b/drivers/base/regmap/regmap.c
+@@ -13,6 +13,7 @@
+ #include <linux/device.h>
+ #include <linux/slab.h>
+ #include <linux/export.h>
++#include <linux/module.h>
+ #include <linux/mutex.h>
+ #include <linux/err.h>
+ #include <linux/rbtree.h>
+@@ -2247,3 +2248,5 @@ static int __init regmap_initcall(void)
+       return 0;
+ }
+ postcore_initcall(regmap_initcall);
++
++MODULE_LICENSE("GPL");
diff --git a/target/linux/generic/patches-3.18/260-crypto_test_dependencies.patch b/target/linux/generic/patches-3.18/260-crypto_test_dependencies.patch
new file mode 100644 (file)
index 0000000..8a96fd9
--- /dev/null
@@ -0,0 +1,37 @@
+--- a/crypto/Kconfig
++++ b/crypto/Kconfig
+@@ -96,10 +96,10 @@ config CRYPTO_MANAGER
+ config CRYPTO_MANAGER2
+       def_tristate CRYPTO_MANAGER || (CRYPTO_MANAGER!=n && CRYPTO_ALGAPI=y)
+-      select CRYPTO_AEAD2
+-      select CRYPTO_HASH2
+-      select CRYPTO_BLKCIPHER2
+-      select CRYPTO_PCOMP2
++      select CRYPTO_AEAD2 if !CRYPTO_MANAGER_DISABLE_TESTS
++      select CRYPTO_HASH2 if !CRYPTO_MANAGER_DISABLE_TESTS
++      select CRYPTO_BLKCIPHER2 if !CRYPTO_MANAGER_DISABLE_TESTS
++      select CRYPTO_PCOMP2 if !CRYPTO_MANAGER_DISABLE_TESTS
+ config CRYPTO_USER
+       tristate "Userspace cryptographic algorithm configuration"
+--- a/crypto/algboss.c
++++ b/crypto/algboss.c
+@@ -248,6 +248,9 @@ static int cryptomgr_schedule_test(struc
+       type = alg->cra_flags;
+       /* This piece of crap needs to disappear into per-type test hooks. */
++#ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS
++      type |= CRYPTO_ALG_TESTED;
++#else
+       if ((!((type ^ CRYPTO_ALG_TYPE_BLKCIPHER) &
+              CRYPTO_ALG_TYPE_BLKCIPHER_MASK) && !(type & CRYPTO_ALG_GENIV) &&
+            ((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) ==
+@@ -256,6 +259,7 @@ static int cryptomgr_schedule_test(struc
+           (!((type ^ CRYPTO_ALG_TYPE_AEAD) & CRYPTO_ALG_TYPE_MASK) &&
+            alg->cra_type == &crypto_nivaead_type && alg->cra_aead.ivsize))
+               type |= CRYPTO_ALG_TESTED;
++#endif
+       param->type = type;
diff --git a/target/linux/generic/patches-3.18/261-move_bcm963xx_tag.patch b/target/linux/generic/patches-3.18/261-move_bcm963xx_tag.patch
new file mode 100644 (file)
index 0000000..ff8f6f8
--- /dev/null
@@ -0,0 +1,219 @@
+--- a/arch/mips/include/asm/mach-bcm63xx/bcm963xx_tag.h
++++ /dev/null
+@@ -1,96 +0,0 @@
+-#ifndef __BCM963XX_TAG_H
+-#define __BCM963XX_TAG_H
+-
+-#define TAGVER_LEN            4       /* Length of Tag Version */
+-#define TAGLAYOUT_LEN         4       /* Length of FlashLayoutVer */
+-#define SIG1_LEN              20      /* Company Signature 1 Length */
+-#define SIG2_LEN              14      /* Company Signature 2 Length */
+-#define BOARDID_LEN           16      /* Length of BoardId */
+-#define ENDIANFLAG_LEN                2       /* Endian Flag Length */
+-#define CHIPID_LEN            6       /* Chip Id Length */
+-#define IMAGE_LEN             10      /* Length of Length Field */
+-#define ADDRESS_LEN           12      /* Length of Address field */
+-#define DUALFLAG_LEN          2       /* Dual Image flag Length */
+-#define INACTIVEFLAG_LEN      2       /* Inactie Flag Length */
+-#define RSASIG_LEN            20      /* Length of RSA Signature in tag */
+-#define TAGINFO1_LEN          30      /* Length of vendor information field1 in tag */
+-#define FLASHLAYOUTVER_LEN    4       /* Length of Flash Layout Version String tag */
+-#define TAGINFO2_LEN          16      /* Length of vendor information field2 in tag */
+-#define ALTTAGINFO_LEN                54      /* Alternate length for vendor information; Pirelli */
+-
+-#define NUM_PIRELLI           2
+-#define IMAGETAG_CRC_START    0xFFFFFFFF
+-
+-#define PIRELLI_BOARDS { \
+-      "AGPF-S0", \
+-      "DWV-S0", \
+-}
+-
+-/*
+- * The broadcom firmware assumes the rootfs starts the image,
+- * therefore uses the rootfs start (flash_image_address)
+- * to determine where to flash the image.  Since we have the kernel first
+- * we have to give it the kernel address, but the crc uses the length
+- * associated with this address (root_length), which is added to the kernel
+- * length (kernel_length) to determine the length of image to flash and thus
+- * needs to be rootfs + deadcode (jffs2 EOF marker)
+-*/
+-
+-struct bcm_tag {
+-      /* 0-3: Version of the image tag */
+-      char tag_version[TAGVER_LEN];
+-      /* 4-23: Company Line 1 */
+-      char sig_1[SIG1_LEN];
+-      /*  24-37: Company Line 2 */
+-      char sig_2[SIG2_LEN];
+-      /* 38-43: Chip this image is for */
+-      char chip_id[CHIPID_LEN];
+-      /* 44-59: Board name */
+-      char board_id[BOARDID_LEN];
+-      /* 60-61: Map endianness -- 1 BE 0 LE */
+-      char big_endian[ENDIANFLAG_LEN];
+-      /* 62-71: Total length of image */
+-      char total_length[IMAGE_LEN];
+-      /* 72-83: Address in memory of CFE */
+-      char cfe__address[ADDRESS_LEN];
+-      /* 84-93: Size of CFE */
+-      char cfe_length[IMAGE_LEN];
+-      /* 94-105: Address in memory of image start
+-       * (kernel for OpenWRT, rootfs for stock firmware)
+-       */
+-      char flash_image_start[ADDRESS_LEN];
+-      /* 106-115: Size of rootfs */
+-      char root_length[IMAGE_LEN];
+-      /* 116-127: Address in memory of kernel */
+-      char kernel_address[ADDRESS_LEN];
+-      /* 128-137: Size of kernel */
+-      char kernel_length[IMAGE_LEN];
+-      /* 138-139: Unused at the moment */
+-      char dual_image[DUALFLAG_LEN];
+-      /* 140-141: Unused at the moment */
+-      char inactive_flag[INACTIVEFLAG_LEN];
+-      /* 142-161: RSA Signature (not used; some vendors may use this) */
+-      char rsa_signature[RSASIG_LEN];
+-      /* 162-191: Compilation and related information (not used in OpenWrt) */
+-      char information1[TAGINFO1_LEN];
+-      /* 192-195: Version flash layout */
+-      char flash_layout_ver[FLASHLAYOUTVER_LEN];
+-      /* 196-199: kernel+rootfs CRC32 */
+-      __u32 fskernel_crc;
+-      /* 200-215: Unused except on Alice Gate where is is information */
+-      char information2[TAGINFO2_LEN];
+-      /* 216-219: CRC32 of image less imagetag (kernel for Alice Gate) */
+-      __u32 image_crc;
+-      /* 220-223: CRC32 of rootfs partition */
+-      __u32 rootfs_crc;
+-      /* 224-227: CRC32 of kernel partition */
+-      __u32 kernel_crc;
+-      /* 228-235: Unused at present */
+-      char reserved1[8];
+-      /* 236-239: CRC32 of header excluding last 20 bytes */
+-      __u32 header_crc;
+-      /* 240-255: Unused at present */
+-      char reserved2[16];
+-};
+-
+-#endif /* __BCM63XX_TAG_H */
+--- a/drivers/mtd/bcm63xxpart.c
++++ b/drivers/mtd/bcm63xxpart.c
+@@ -34,7 +34,7 @@
+ #include <linux/mtd/partitions.h>
+ #include <asm/mach-bcm63xx/bcm63xx_nvram.h>
+-#include <asm/mach-bcm63xx/bcm963xx_tag.h>
++#include <linux/bcm963xx_tag.h>
+ #include <asm/mach-bcm63xx/board_bcm963xx.h>
+ #define BCM63XX_EXTENDED_SIZE 0xBFC00000      /* Extended flash address */
+--- a/include/uapi/linux/Kbuild
++++ b/include/uapi/linux/Kbuild
+@@ -70,6 +70,7 @@ header-y += blktrace_api.h
+ header-y += bpf.h
+ header-y += bpf_common.h
+ header-y += bpqether.h
++header-y += bcm963xx_tag.h
+ header-y += bsg.h
+ header-y += btrfs.h
+ header-y += can.h
+--- /dev/null
++++ b/include/uapi/linux/bcm963xx_tag.h
+@@ -0,0 +1,96 @@
++#ifndef __BCM963XX_TAG_H
++#define __BCM963XX_TAG_H
++
++#define TAGVER_LEN            4       /* Length of Tag Version */
++#define TAGLAYOUT_LEN         4       /* Length of FlashLayoutVer */
++#define SIG1_LEN              20      /* Company Signature 1 Length */
++#define SIG2_LEN              14      /* Company Signature 2 Length */
++#define BOARDID_LEN           16      /* Length of BoardId */
++#define ENDIANFLAG_LEN                2       /* Endian Flag Length */
++#define CHIPID_LEN            6       /* Chip Id Length */
++#define IMAGE_LEN             10      /* Length of Length Field */
++#define ADDRESS_LEN           12      /* Length of Address field */
++#define DUALFLAG_LEN          2       /* Dual Image flag Length */
++#define INACTIVEFLAG_LEN      2       /* Inactie Flag Length */
++#define RSASIG_LEN            20      /* Length of RSA Signature in tag */
++#define TAGINFO1_LEN          30      /* Length of vendor information field1 in tag */
++#define FLASHLAYOUTVER_LEN    4       /* Length of Flash Layout Version String tag */
++#define TAGINFO2_LEN          16      /* Length of vendor information field2 in tag */
++#define ALTTAGINFO_LEN                54      /* Alternate length for vendor information; Pirelli */
++
++#define NUM_PIRELLI           2
++#define IMAGETAG_CRC_START    0xFFFFFFFF
++
++#define PIRELLI_BOARDS { \
++      "AGPF-S0", \
++      "DWV-S0", \
++}
++
++/*
++ * The broadcom firmware assumes the rootfs starts the image,
++ * therefore uses the rootfs start (flash_image_address)
++ * to determine where to flash the image.  Since we have the kernel first
++ * we have to give it the kernel address, but the crc uses the length
++ * associated with this address (root_length), which is added to the kernel
++ * length (kernel_length) to determine the length of image to flash and thus
++ * needs to be rootfs + deadcode (jffs2 EOF marker)
++*/
++
++struct bcm_tag {
++      /* 0-3: Version of the image tag */
++      char tag_version[TAGVER_LEN];
++      /* 4-23: Company Line 1 */
++      char sig_1[SIG1_LEN];
++      /*  24-37: Company Line 2 */
++      char sig_2[SIG2_LEN];
++      /* 38-43: Chip this image is for */
++      char chip_id[CHIPID_LEN];
++      /* 44-59: Board name */
++      char board_id[BOARDID_LEN];
++      /* 60-61: Map endianness -- 1 BE 0 LE */
++      char big_endian[ENDIANFLAG_LEN];
++      /* 62-71: Total length of image */
++      char total_length[IMAGE_LEN];
++      /* 72-83: Address in memory of CFE */
++      char cfe__address[ADDRESS_LEN];
++      /* 84-93: Size of CFE */
++      char cfe_length[IMAGE_LEN];
++      /* 94-105: Address in memory of image start
++       * (kernel for OpenWRT, rootfs for stock firmware)
++       */
++      char flash_image_start[ADDRESS_LEN];
++      /* 106-115: Size of rootfs */
++      char root_length[IMAGE_LEN];
++      /* 116-127: Address in memory of kernel */
++      char kernel_address[ADDRESS_LEN];
++      /* 128-137: Size of kernel */
++      char kernel_length[IMAGE_LEN];
++      /* 138-139: Unused at the moment */
++      char dual_image[DUALFLAG_LEN];
++      /* 140-141: Unused at the moment */
++      char inactive_flag[INACTIVEFLAG_LEN];
++      /* 142-161: RSA Signature (not used; some vendors may use this) */
++      char rsa_signature[RSASIG_LEN];
++      /* 162-191: Compilation and related information (not used in OpenWrt) */
++      char information1[TAGINFO1_LEN];
++      /* 192-195: Version flash layout */
++      char flash_layout_ver[FLASHLAYOUTVER_LEN];
++      /* 196-199: kernel+rootfs CRC32 */
++      __u32 fskernel_crc;
++      /* 200-215: Unused except on Alice Gate where is is information */
++      char information2[TAGINFO2_LEN];
++      /* 216-219: CRC32 of image less imagetag (kernel for Alice Gate) */
++      __u32 image_crc;
++      /* 220-223: CRC32 of rootfs partition */
++      __u32 rootfs_crc;
++      /* 224-227: CRC32 of kernel partition */
++      __u32 kernel_crc;
++      /* 228-235: Unused at present */
++      char reserved1[8];
++      /* 236-239: CRC32 of header excluding last 20 bytes */
++      __u32 header_crc;
++      /* 240-255: Unused at present */
++      char reserved2[16];
++};
++
++#endif /* __BCM63XX_TAG_H */
diff --git a/target/linux/generic/patches-3.18/262-compressor_kconfig_hack.patch b/target/linux/generic/patches-3.18/262-compressor_kconfig_hack.patch
new file mode 100644 (file)
index 0000000..a24405d
--- /dev/null
@@ -0,0 +1,23 @@
+--- a/lib/Kconfig
++++ b/lib/Kconfig
+@@ -205,16 +205,16 @@ config RANDOM32_SELFTEST
+ # compression support is select'ed if needed
+ #
+ config ZLIB_INFLATE
+-      tristate
++      tristate "ZLIB inflate support"
+ config ZLIB_DEFLATE
+-      tristate
++      tristate "ZLIB deflate support"
+ config LZO_COMPRESS
+-      tristate
++      tristate "LZO compress support"
+ config LZO_DECOMPRESS
+-      tristate
++      tristate "LZO decompress support"
+ config LZ4_COMPRESS
+       tristate
diff --git a/target/linux/generic/patches-3.18/300-mips_expose_boot_raw.patch b/target/linux/generic/patches-3.18/300-mips_expose_boot_raw.patch
new file mode 100644 (file)
index 0000000..8ea08e7
--- /dev/null
@@ -0,0 +1,39 @@
+From: Mark Miller <mark@mirell.org>
+
+This exposes the CONFIG_BOOT_RAW symbol in Kconfig. This is needed on
+certain Broadcom chipsets running CFE in order to load the kernel.
+
+Signed-off-by: Mark Miller <mark@mirell.org>
+Acked-by: Rob Landley <rob@landley.net>
+---
+--- a/arch/mips/Kconfig
++++ b/arch/mips/Kconfig
+@@ -892,9 +892,6 @@ config FW_ARC
+ config ARCH_MAY_HAVE_PC_FDC
+       bool
+-config BOOT_RAW
+-      bool
+-
+ config CEVT_BCM1480
+       bool
+@@ -2492,6 +2489,18 @@ config USE_OF
+ config BUILTIN_DTB
+       bool
++config BOOT_RAW
++      bool "Enable the kernel to be executed from the load address"
++      default n
++      help
++       Allow the kernel to be executed from the load address for
++       bootloaders which cannot read the ELF format. This places
++       a jump to start_kernel at the load address.
++
++       If unsure, say N.
++
++
++
+ endmenu
+ config LOCKDEP_SUPPORT
diff --git a/target/linux/generic/patches-3.18/301-mips_image_cmdline_hack.patch b/target/linux/generic/patches-3.18/301-mips_image_cmdline_hack.patch
new file mode 100644 (file)
index 0000000..c87d448
--- /dev/null
@@ -0,0 +1,28 @@
+--- a/arch/mips/Kconfig
++++ b/arch/mips/Kconfig
+@@ -988,6 +988,10 @@ config SYNC_R4K
+ config MIPS_MACHINE
+       def_bool n
++config IMAGE_CMDLINE_HACK
++      bool "OpenWrt specific image command line hack"
++      default n
++
+ config NO_IOPORT_MAP
+       def_bool n
+--- a/arch/mips/kernel/head.S
++++ b/arch/mips/kernel/head.S
+@@ -80,6 +80,12 @@ FEXPORT(__kernel_entry)
+       j       kernel_entry
+ #endif
++#ifdef CONFIG_IMAGE_CMDLINE_HACK
++      .ascii  "CMDLINE:"
++EXPORT(__image_cmdline)
++      .fill   0x400
++#endif /* CONFIG_IMAGE_CMDLINE_HACK */
++
+       __REF
+ NESTED(kernel_entry, 16, sp)                  # kernel entry point
diff --git a/target/linux/generic/patches-3.18/302-mips_no_branch_likely.patch b/target/linux/generic/patches-3.18/302-mips_no_branch_likely.patch
new file mode 100644 (file)
index 0000000..1da9540
--- /dev/null
@@ -0,0 +1,11 @@
+--- a/arch/mips/Makefile
++++ b/arch/mips/Makefile
+@@ -87,7 +87,7 @@ all-$(CONFIG_SYS_SUPPORTS_ZBOOT)+= vmlin
+ # machines may also.  Since BFD is incredibly buggy with respect to
+ # crossformat linking we rely on the elf2ecoff tool for format conversion.
+ #
+-cflags-y                      += -G 0 -mno-abicalls -fno-pic -pipe
++cflags-y                      += -G 0 -mno-abicalls -fno-pic -pipe -mno-branch-likely
+ cflags-y                      += -msoft-float
+ LDFLAGS_vmlinux                       += -G 0 -static -n -nostdlib
+ KBUILD_AFLAGS_MODULE          += -mlong-calls
diff --git a/target/linux/generic/patches-3.18/304-mips_disable_fpu.patch b/target/linux/generic/patches-3.18/304-mips_disable_fpu.patch
new file mode 100644 (file)
index 0000000..4536ce6
--- /dev/null
@@ -0,0 +1,160 @@
+MIPS: allow disabling the kernel FPU emulator
+
+This patch allows turning off the in-kernel Algorithmics
+FPU emulator support, which allows one to save a couple of
+precious blocks on an embedded system.
+
+Signed-off-by: Florian Fainelli <florian@openwrt.org>
+--
+--- a/arch/mips/Kconfig
++++ b/arch/mips/Kconfig
+@@ -934,6 +934,17 @@ config I8259
+ config MIPS_BONITO64
+       bool
++config MIPS_FPU_EMU
++      bool "Enable FPU emulation"
++      default y
++      help
++         This option allows building a kernel with or without the Algorithmics
++         FPU emulator enabled. Turning off this option results in a kernel which
++         does not catch floating operations exceptions. Make sure that your toolchain
++         is configured to enable software floating point emulation in that case.
++
++         If unsure say Y here.
++
+ config MIPS_MSC
+       bool
+--- a/arch/mips/math-emu/Makefile
++++ b/arch/mips/math-emu/Makefile
+@@ -2,10 +2,12 @@
+ # Makefile for the Linux/MIPS kernel FPU emulation.
+ #
+-obj-y := cp1emu.o ieee754m.o ieee754d.o ieee754dp.o ieee754sp.o ieee754.o \
++obj-y := kernel_linkage.o
++
++obj-$(CONFIG_MIPS_FPU_EMU)    += ieee754m.o ieee754d.o ieee754dp.o ieee754sp.o ieee754.o \
+          ieee754xcpt.o dp_frexp.o dp_modf.o dp_div.o dp_mul.o dp_sub.o \
+          dp_add.o dp_fsp.o dp_cmp.o dp_logb.o dp_scalb.o dp_simple.o \
+          dp_tint.o dp_fint.o dp_tlong.o dp_flong.o sp_frexp.o sp_modf.o \
+          sp_div.o sp_mul.o sp_sub.o sp_add.o sp_fdp.o sp_cmp.o sp_logb.o \
+          sp_scalb.o sp_simple.o sp_tint.o sp_fint.o sp_tlong.o sp_flong.o \
+-         dp_sqrt.o sp_sqrt.o kernel_linkage.o dsemul.o
++         dp_sqrt.o sp_sqrt.o dsemul.o cp1emu.o
+--- a/arch/mips/math-emu/kernel_linkage.c
++++ b/arch/mips/math-emu/kernel_linkage.c
+@@ -29,6 +29,7 @@
+ #define SIGNALLING_NAN 0x7ff800007ff80000LL
++#ifdef CONFIG_MIPS_FPU_EMU
+ void fpu_emulator_init_fpu(void)
+ {
+       static int first = 1;
+@@ -115,3 +116,36 @@ int fpu_emulator_restore_context32(struc
+       return err;
+ }
+ #endif
++
++#else
++
++void fpu_emulator_init_fpu(void)
++{
++      printk(KERN_INFO "FPU emulator disabled, make sure your toolchain"
++              "was compiled with software floating point support (soft-float)\n");
++      return;
++}
++
++int fpu_emulator_save_context(struct sigcontext __user *sc)
++{
++      return 0;
++}
++
++int fpu_emulator_restore_context(struct sigcontext __user *sc)
++{
++      return 0;
++}
++
++#ifdef CONFIG_64BIT
++int fpu_emulator_save_context32(struct sigcontext32 __user *sc)
++{
++      return 0;
++}
++
++int fpu_emulator_restore_context32(struct sigcontext32 __user *sc)
++{
++      return 0;
++}
++#endif /* CONFIG_64BIT */
++
++#endif /* CONFIG_MIPS_FPU_EMU */
+--- a/arch/mips/include/asm/fpu_emulator.h
++++ b/arch/mips/include/asm/fpu_emulator.h
+@@ -27,6 +27,8 @@
+ #include <asm/inst.h>
+ #include <asm/local.h>
++#ifdef CONFIG_MIPS_FPU_EMU
++
+ #ifdef CONFIG_DEBUG_FS
+ struct mips_fpu_emulator_stats {
+@@ -60,6 +62,38 @@ extern int fpu_emulator_cop1Handler(stru
+ int process_fpemu_return(int sig, void __user *fault_addr);
+ int mm_isBranchInstr(struct pt_regs *regs, struct mm_decoded_insn dec_insn,
+                    unsigned long *contpc);
++#else
++static inline int mips_dsemul(struct pt_regs *regs, mips_instruction ir,
++                            unsigned long cpc)
++{
++      return 0;
++}
++
++static inline int do_dsemulret(struct pt_regs *xcp)
++{
++      return 0;
++}
++
++static inline int fpu_emulator_cop1Handler(struct pt_regs *xcp,
++                                         struct mips_fpu_struct *ctx,
++                                         int has_fpu,
++                                         void *__user *fault_addr)
++{
++      return 0;
++}
++
++static inline int process_fpemu_return(int sig, void __user *fault_addr)
++{
++      return -EINVAL;
++}
++
++static inline int mm_isBranchInstr(struct pt_regs *regs,
++                                 struct mm_decoded_insn dec_insn,
++                                 unsigned long *contpc)
++{
++      return 0;
++}
++#endif /* CONFIG_MIPS_FPU_EMU */
+ /*
+  * Instruction inserted following the badinst to further tag the sequence
+--- a/arch/mips/kernel/traps.c
++++ b/arch/mips/kernel/traps.c
+@@ -701,6 +701,7 @@ asmlinkage void do_ov(struct pt_regs *re
+       exception_exit(prev_state);
+ }
++#ifdef CONFIG_MIPS_FPU_EMU
+ int process_fpemu_return(int sig, void __user *fault_addr)
+ {
+       if (sig == SIGSEGV || sig == SIGBUS) {
+@@ -724,6 +725,7 @@ int process_fpemu_return(int sig, void _
+               return 0;
+       }
+ }
++#endif /* CONFIG_MIPS_FPU_EMU */
+ /*
+  * XXX Delayed fp exceptions when doing a lazy ctx switch XXX
diff --git a/target/linux/generic/patches-3.18/305-mips_module_reloc.patch b/target/linux/generic/patches-3.18/305-mips_module_reloc.patch
new file mode 100644 (file)
index 0000000..8818675
--- /dev/null
@@ -0,0 +1,352 @@
+--- a/arch/mips/Makefile
++++ b/arch/mips/Makefile
+@@ -90,8 +90,13 @@ all-$(CONFIG_SYS_SUPPORTS_ZBOOT)+= vmlin
+ cflags-y                      += -G 0 -mno-abicalls -fno-pic -pipe -mno-branch-likely
+ cflags-y                      += -msoft-float
+ LDFLAGS_vmlinux                       += -G 0 -static -n -nostdlib
++ifdef CONFIG_64BIT
+ KBUILD_AFLAGS_MODULE          += -mlong-calls
+ KBUILD_CFLAGS_MODULE          += -mlong-calls
++else
++KBUILD_AFLAGS_MODULE          += -mno-long-calls
++KBUILD_CFLAGS_MODULE          += -mno-long-calls
++endif
+ cflags-y += -ffreestanding
+--- a/arch/mips/include/asm/module.h
++++ b/arch/mips/include/asm/module.h
+@@ -11,6 +11,11 @@ struct mod_arch_specific {
+       const struct exception_table_entry *dbe_start;
+       const struct exception_table_entry *dbe_end;
+       struct mips_hi16 *r_mips_hi16_list;
++
++      void *phys_plt_tbl;
++      void *virt_plt_tbl;
++      unsigned int phys_plt_offset;
++      unsigned int virt_plt_offset;
+ };
+ typedef uint8_t Elf64_Byte;           /* Type for a 8-bit quantity.  */
+--- a/arch/mips/kernel/module.c
++++ b/arch/mips/kernel/module.c
+@@ -43,14 +43,222 @@ struct mips_hi16 {
+ static LIST_HEAD(dbe_list);
+ static DEFINE_SPINLOCK(dbe_lock);
+-#ifdef MODULE_START
++/*
++ * Get the potential max trampolines size required of the init and
++ * non-init sections. Only used if we cannot find enough contiguous
++ * physically mapped memory to put the module into.
++ */
++static unsigned int
++get_plt_size(const Elf_Ehdr *hdr, const Elf_Shdr *sechdrs,
++             const char *secstrings, unsigned int symindex, bool is_init)
++{
++      unsigned long ret = 0;
++      unsigned int i, j;
++      Elf_Sym *syms;
++
++      /* Everything marked ALLOC (this includes the exported symbols) */
++      for (i = 1; i < hdr->e_shnum; ++i) {
++              unsigned int info = sechdrs[i].sh_info;
++
++              if (sechdrs[i].sh_type != SHT_REL
++                  && sechdrs[i].sh_type != SHT_RELA)
++                      continue;
++
++              /* Not a valid relocation section? */
++              if (info >= hdr->e_shnum)
++                      continue;
++
++              /* Don't bother with non-allocated sections */
++              if (!(sechdrs[info].sh_flags & SHF_ALLOC))
++                      continue;
++
++              /* If it's called *.init*, and we're not init, we're
++                   not interested */
++              if ((strstr(secstrings + sechdrs[i].sh_name, ".init") != 0)
++                  != is_init)
++                      continue;
++
++              syms = (Elf_Sym *) sechdrs[symindex].sh_addr;
++              if (sechdrs[i].sh_type == SHT_REL) {
++                      Elf_Mips_Rel *rel = (void *) sechdrs[i].sh_addr;
++                      unsigned int size = sechdrs[i].sh_size / sizeof(*rel);
++
++                      for (j = 0; j < size; ++j) {
++                              Elf_Sym *sym;
++
++                              if (ELF_MIPS_R_TYPE(rel[j]) != R_MIPS_26)
++                                      continue;
++
++                              sym = syms + ELF_MIPS_R_SYM(rel[j]);
++                              if (!is_init && sym->st_shndx != SHN_UNDEF)
++                                      continue;
++
++                              ret += 4 * sizeof(int);
++                      }
++              } else {
++                      Elf_Mips_Rela *rela = (void *) sechdrs[i].sh_addr;
++                      unsigned int size = sechdrs[i].sh_size / sizeof(*rela);
++
++                      for (j = 0; j < size; ++j) {
++                              Elf_Sym *sym;
++
++                              if (ELF_MIPS_R_TYPE(rela[j]) != R_MIPS_26)
++                                      continue;
++
++                              sym = syms + ELF_MIPS_R_SYM(rela[j]);
++                              if (!is_init && sym->st_shndx != SHN_UNDEF)
++                                      continue;
++
++                              ret += 4 * sizeof(int);
++                      }
++              }
++      }
++
++      return ret;
++}
++
++#ifndef MODULE_START
++static void *alloc_phys(unsigned long size)
++{
++      unsigned order;
++      struct page *page;
++      struct page *p;
++
++      size = PAGE_ALIGN(size);
++      order = get_order(size);
++
++      page = alloc_pages(GFP_KERNEL | __GFP_NORETRY | __GFP_NOWARN |
++                      __GFP_THISNODE, order);
++      if (!page)
++              return NULL;
++
++      split_page(page, order);
++
++      for (p = page + (size >> PAGE_SHIFT); p < page + (1 << order); ++p)
++              __free_page(p);
++
++      return page_address(page);
++}
++#endif
++
++static void free_phys(void *ptr, unsigned long size)
++{
++      struct page *page;
++      struct page *end;
++
++      page = virt_to_page(ptr);
++      end = page + (PAGE_ALIGN(size) >> PAGE_SHIFT);
++
++      for (; page < end; ++page)
++              __free_page(page);
++}
++
++
+ void *module_alloc(unsigned long size)
+ {
++#ifdef MODULE_START
+       return __vmalloc_node_range(size, 1, MODULE_START, MODULE_END,
+                               GFP_KERNEL, PAGE_KERNEL, NUMA_NO_NODE,
+                               __builtin_return_address(0));
++#else
++      void *ptr;
++
++      if (size == 0)
++              return NULL;
++
++      ptr = alloc_phys(size);
++
++      /* If we failed to allocate physically contiguous memory,
++       * fall back to regular vmalloc. The module loader code will
++       * create jump tables to handle long jumps */
++      if (!ptr)
++              return vmalloc(size);
++
++      return ptr;
++#endif
+ }
++
++static inline bool is_phys_addr(void *ptr)
++{
++#ifdef CONFIG_64BIT
++      return (KSEGX((unsigned long)ptr) == CKSEG0);
++#else
++      return (KSEGX(ptr) == KSEG0);
+ #endif
++}
++
++/* Free memory returned from module_alloc */
++void module_free(struct module *mod, void *module_region)
++{
++      if (is_phys_addr(module_region)) {
++              if (mod->module_init == module_region)
++                      free_phys(module_region, mod->init_size);
++              else if (mod->module_core == module_region)
++                      free_phys(module_region, mod->core_size);
++              else
++                      BUG();
++      } else {
++              vfree(module_region);
++      }
++}
++
++static void *__module_alloc(int size, bool phys)
++{
++      void *ptr;
++
++      if (phys)
++              ptr = kmalloc(size, GFP_KERNEL);
++      else
++              ptr = vmalloc(size);
++      return ptr;
++}
++
++static void __module_free(void *ptr)
++{
++      if (is_phys_addr(ptr))
++              kfree(ptr);
++      else
++              vfree(ptr);
++}
++
++int module_frob_arch_sections(Elf_Ehdr *hdr, Elf_Shdr *sechdrs,
++                            char *secstrings, struct module *mod)
++{
++      unsigned int symindex = 0;
++      unsigned int core_size, init_size;
++      int i;
++
++      mod->arch.phys_plt_offset = 0;
++      mod->arch.virt_plt_offset = 0;
++      mod->arch.phys_plt_tbl = NULL;
++      mod->arch.virt_plt_tbl = NULL;
++
++      if (IS_ENABLED(CONFIG_64BIT))
++              return 0;
++
++      for (i = 1; i < hdr->e_shnum; i++)
++              if (sechdrs[i].sh_type == SHT_SYMTAB)
++                      symindex = i;
++
++      core_size = get_plt_size(hdr, sechdrs, secstrings, symindex, false);
++      init_size = get_plt_size(hdr, sechdrs, secstrings, symindex, true);
++
++      if ((core_size + init_size) == 0)
++              return 0;
++
++      mod->arch.phys_plt_tbl = __module_alloc(core_size + init_size, 1);
++      if (!mod->arch.phys_plt_tbl)
++              return -ENOMEM;
++
++      mod->arch.virt_plt_tbl = __module_alloc(core_size + init_size, 0);
++      if (!mod->arch.virt_plt_tbl) {
++              __module_free(mod->arch.phys_plt_tbl);
++              mod->arch.phys_plt_tbl = NULL;
++              return -ENOMEM;
++      }
++
++      return 0;
++}
+ int apply_r_mips_none(struct module *me, u32 *location, Elf_Addr v)
+ {
+@@ -64,8 +272,39 @@ static int apply_r_mips_32_rel(struct mo
+       return 0;
+ }
++static Elf_Addr add_plt_entry_to(unsigned *plt_offset,
++                               void *start, Elf_Addr v)
++{
++      unsigned *tramp = start + *plt_offset;
++      *plt_offset += 4 * sizeof(int);
++
++      /* adjust carry for addiu */
++      if (v & 0x00008000)
++              v += 0x10000;
++
++      tramp[0] = 0x3c190000 | (v >> 16);      /* lui t9, hi16 */
++      tramp[1] = 0x27390000 | (v & 0xffff);   /* addiu t9, t9, lo16 */
++      tramp[2] = 0x03200008;                  /* jr t9 */
++      tramp[3] = 0x00000000;                  /* nop */
++
++      return (Elf_Addr) tramp;
++}
++
++static Elf_Addr add_plt_entry(struct module *me, void *location, Elf_Addr v)
++{
++      if (is_phys_addr(location))
++              return add_plt_entry_to(&me->arch.phys_plt_offset,
++                              me->arch.phys_plt_tbl, v);
++      else
++              return add_plt_entry_to(&me->arch.virt_plt_offset,
++                              me->arch.virt_plt_tbl, v);
++
++}
++
+ static int apply_r_mips_26_rel(struct module *me, u32 *location, Elf_Addr v)
+ {
++      u32 ofs = *location & 0x03ffffff;
++
+       if (v % 4) {
+               pr_err("module %s: dangerous R_MIPS_26 REL relocation\n",
+                      me->name);
+@@ -73,14 +312,17 @@ static int apply_r_mips_26_rel(struct mo
+       }
+       if ((v & 0xf0000000) != (((unsigned long)location + 4) & 0xf0000000)) {
+-              printk(KERN_ERR
+-                     "module %s: relocation overflow\n",
+-                     me->name);
+-              return -ENOEXEC;
++              v = add_plt_entry(me, location, v + (ofs << 2));
++              if (!v) {
++                      printk(KERN_ERR
++                              "module %s: relocation overflow\n", me->name);
++                      return -ENOEXEC;
++              }
++              ofs = 0;
+       }
+       *location = (*location & ~0x03ffffff) |
+-                  ((*location + (v >> 2)) & 0x03ffffff);
++                  ((ofs + (v >> 2)) & 0x03ffffff);
+       return 0;
+ }
+@@ -287,11 +529,32 @@ int module_finalize(const Elf_Ehdr *hdr,
+               list_add(&me->arch.dbe_list, &dbe_list);
+               spin_unlock_irq(&dbe_lock);
+       }
++
++      /* Get rid of the fixup trampoline if we're running the module
++       * from physically mapped address space */
++      if (me->arch.phys_plt_offset == 0) {
++              __module_free(me->arch.phys_plt_tbl);
++              me->arch.phys_plt_tbl = NULL;
++      }
++      if (me->arch.virt_plt_offset == 0) {
++              __module_free(me->arch.virt_plt_tbl);
++              me->arch.virt_plt_tbl = NULL;
++      }
++
+       return 0;
+ }
+ void module_arch_cleanup(struct module *mod)
+ {
++      if (mod->arch.phys_plt_tbl) {
++              __module_free(mod->arch.phys_plt_tbl);
++              mod->arch.phys_plt_tbl = NULL;
++      }
++      if (mod->arch.virt_plt_tbl) {
++              __module_free(mod->arch.virt_plt_tbl);
++              mod->arch.virt_plt_tbl = NULL;
++      }
++
+       spin_lock_irq(&dbe_lock);
+       list_del(&mod->arch.dbe_list);
+       spin_unlock_irq(&dbe_lock);
diff --git a/target/linux/generic/patches-3.18/306-mips_mem_functions_performance.patch b/target/linux/generic/patches-3.18/306-mips_mem_functions_performance.patch
new file mode 100644 (file)
index 0000000..9818677
--- /dev/null
@@ -0,0 +1,83 @@
+--- a/arch/mips/include/asm/string.h
++++ b/arch/mips/include/asm/string.h
+@@ -133,11 +133,44 @@ strncmp(__const__ char *__cs, __const__
+ #define __HAVE_ARCH_MEMSET
+ extern void *memset(void *__s, int __c, size_t __count);
++#define memset(__s, __c, len)                                 \
++({                                                            \
++      size_t __len = (len);                                   \
++      void *__ret;                                            \
++      if (__builtin_constant_p(len) && __len >= 64)           \
++              __ret = memset((__s), (__c), __len);            \
++      else                                                    \
++              __ret = __builtin_memset((__s), (__c), __len);  \
++      __ret;                                                  \
++})