#! /bin/bash
# (c) 2015, Quentin Casasnovas <quentin.casasnovas@oracle.com>

setglobal obj = $1

file $(obj) | grep -q ELF || shell {echo "$(obj) is not and ELF file." !1 > !2 ; exit 0}

# Bail out early if there isn't an __ex_table section in this object file.
objdump -hj __ex_table $(obj) !2 > /dev/null > /dev/null
test $Status -ne 0 && exit 0

setglobal white_list = '.text,.fixup'

setglobal suspicious_relocs = $[objdump -rj __ex_table $(obj)  | tail -n +6 |
			grep -v $[eval echo -e{$(white_list)}] | awk '{print $3}]

# No suspicious relocs in __ex_table, jobs a good'un
test -z $(suspicious_relocs) && exit 0


# After this point, something is seriously wrong since we just found out we
# have some relocations in __ex_table which point to sections which aren't
# white listed.  If you're adding a new section in the Linux kernel, and
# you're expecting this section to contain code which can fault (i.e. the
# __ex_table relocation to your new section is expected), simply add your
# new section to the white_list variable above.  If not, you're probably
# doing something wrong and the rest of this code is just trying to print
# you more information about it.

proc find_section_offset_from_symbol
{
    eval $[objdump -t $(obj) | grep $(1) | sed 's/\([0-9a-f]\+\) .\{7\} \([^ \t]\+\).*/section="\2"; section_offset="0x\1" /]

    # addr2line takes addresses in hexadecimal...
    setglobal section_offset = $[printf "0x%016x" $shExpr(' ${section_offset} + $2 ')]
}

proc find_symbol_and_offset_from_reloc
{
    # Extract symbol and offset from the objdump output
    eval $[echo $reloc | sed 's/\([^+]\+\)+\?\(0x[0-9a-f]\+\)\?/symbol="\1"; symbol_offset="\2"/]

    # When the relocation points to the begining of a symbol or section, it
    # won't print the offset since it is zero.
    if test -z $(symbol_offset) {
	setglobal symbol_offset = '0x0'
    }
}

proc find_alt_replacement_target
{
    # The target of the .altinstr_replacement is the relocation just before
    # the .altinstr_replacement one.
    eval $[objdump -rj .altinstructions $(obj) | grep -B1 "$(section)+$(section_offset)" | head -n1 | awk '{print $3}' |
	   sed 's/\([^+]\+\)+\(0x[0-9a-f]\+\)/alt_target_section="\1"; alt_target_offset="\2"/]
}

proc handle_alt_replacement_reloc
{
    # This will define alt_target_section and alt_target_section_offset
    find_alt_replacement_target $(section) $(section_offset)

    echo "Error: found a reference to .altinstr_replacement in __ex_table:"
    addr2line -fip -j $(alt_target_section) -e $(obj) $(alt_target_offset) | awk '{print "\t" $0}'

    setglobal error = 'true'
}

proc is_executable_section
{
    objdump -hwj $(section) $(obj) | grep -q CODE
    return $?
}

proc handle_suspicious_generic_reloc
{
    if is_executable_section $(section) {
	# We've got a relocation to a non white listed _executable_
	# section, print a warning so the developper adds the section to
	# the white list or fix his code.  We try to pretty-print the file
	# and line number where that relocation was added.
	echo "Warning: found a reference to section \"$(section)\" in __ex_table:"
	addr2line -fip -j $(section) -e $(obj) $(section_offset) | awk '{print "\t" $0}'
    } else {
	# Something is definitively wrong here since we've got a relocation
	# to a non-executable section, there's no way this would ever be
	# running in the kernel.
	echo "Error: found a reference to non-executable section \"$(section)\" in __ex_table at offset $(section_offset)"
	setglobal error = 'true'
    }
}

proc handle_suspicious_reloc
{
    match $(section) {
	with ".altinstr_replacement"
	    handle_alt_replacement_reloc $(section) $(section_offset)
	    
	with *
	    handle_suspicious_generic_reloc $(section) $(section_offset)
	    
    }
}

proc diagnose
{

    for reloc in [$(suspicious_relocs)] {
	# Let's find out where the target of the relocation in __ex_table
	# is, this will define ${symbol} and ${symbol_offset}
	find_symbol_and_offset_from_reloc $(reloc)

	# When there's a global symbol at the place of the relocation,
	# objdump will use it instead of giving us a section+offset, so
	# let's find out which section is this symbol in and the total
	# offset withing that section.
	find_section_offset_from_symbol $(symbol) $(symbol_offset)

	# In this case objdump was presenting us with a reloc to a symbol
	# rather than a section. Now that we've got the actual section,
	# we can skip it if it's in the white_list.
	if test -z $[ echo $section | grep -v $[eval echo -e{$(white_list)}]] {
	    continue;
	}

	# Will either print a warning if the relocation happens to be in a
	# section we do not know but has executable bit set, or error out.
	handle_suspicious_reloc
    }
}

proc check_debug_info {
    objdump -hj .debug_info $(obj) !2 > /dev/null > /dev/null ||
	echo -e "$(obj) does not contain debug information, the addr2line output will be limited.\n" \
	     "Recompile $(obj) with CONFIG_DEBUG_INFO to get a more useful output."
}

check_debug_info

diagnose

if test $(error) {
    exit 1
}

exit 0