Disable non-static function calls

Compiled BPF programs must consist of a single contiguous code block,
meaning trying to call other function entry points (besides the
kernel-defined helpers) is not possible. The bcc frontend didn't
explicitly prohibit this, even though the program would fail to
compile/load. Add an explicit check and error message.

Fixes: #653
Signed-off-by: Brenden Blanco <bblanco@gmail.com>

Minor sorting of the yaml tool list and sync it to the latest
updates in tools
Signed-off-by: Colin Ian King <colin.king@canonical.com>

Printing the BPF program after loading it means that if there is a
load error, the program isn't printed, which sort of defeats the
purpose of the whole thing.

* adding args matching option

* fixing typos

* fixing merge artefacts

* [execsnoop]: adding documentation on -l in man

* [execsnoop][man]: fixing typo in commands name

Add a link to the proposed generic XDP feature to the list of XDP features.

Use normal inlining in clang loader

Display pid namespace in summary histogram using a new `--pidnss` option.

used the CheckCXXCompilerFlag module of Cmake to check the compiler whether or not supporting c++11. (#1116)

bcc: add __attribute__((always_inline)) to helper functions

When using Clang 3.9(compiled by GCC 6.x), bcc will used -isystem,
because the GCC_VERSION(get the version of the Clang) is less 6.0.
And then the compiler will compile failed.

In bcc, ProgArray.__delitem__ defaults to ArrayBase.__delitem__
which uses the bpf_update_elem helper to clear the item (override
with a null value). However, eBPF doesn't offer a bpf_update_elem
helper for prog arrays.

This pull request overrides __delitem__ in ProgArray to use the
bpf_delete_item helper.

On some distributions, the debuglink section in the binary will
not have a .debug file extension. As a result, we will try to look
for the debuginfo file in the binary itself, immediately find it,
and abort looking for any other alternatives. This is not good,
because the binary might contain stripped or partial symbols,
which precludes certain tools from realizing their full potential.

Fix by checking that the debuginfo file we're trying to use is
not the same as the binary file. In any case, if external debuginfo
can't be found, we will fall back to the symbols in the original
binary file, if present, so this should not regress any existing
scenario.

Fixed SEGFAULT due to perf buffer overflow if lost_cb unset

When setting a lost_cb, the reference to the ctypes function is not retained like the regular callback,
this leads to a SEGFAULT if the gc kills the lost_fn if a lost event occurs afterwards

This fixes a SEGFAULT in the underlying libbcc when no lost_cb is set.
This occurs when the perf buffer is full and the lost_cb is called.
libbcc expects a NULL pointer as lost_cb to trigger its internal lost message.
This fixes the bug by providing an appropriate NULL pointer when lost_cb is unset.

This commit migrates softirqs to use kernel tracepoints instead of
kprobes. Because tracepoints only provide the vector number and not
the function name, we use a conversion table, which is borrowed from
kernel/softirq.c, to translate the vector number to a display name.
This table is expected to be fairly stable. Notably, new names have
not been added since approximately 2009, and the last rename (without
adding or removing a name) was in 2014.

Resolves #1031.

Fix compiler warning on redefined Macro

Miscellaneous style and code layout improvements

README.md: fix broken link to stacksnoop examples

Updates to Lua/BPF code generator

the BPF maps and pointers were previously
implicitly dereferenced whenever an operation
on them required a value and not a pointer.
the upside is that accessing map element data
didn’t require an explicit operation, the downside
is that it wasn’t possible to get the value
explicitly.

this makes it possible to dereference any pointer
and materialize the value in the register as long
as it’s shorter than register width using `ptr[0]`
element access operator.

the DW LD_ABS|IND is prohibited, so it is
implemented as a double W load with shift.
this is slow as it also has to undo the ntohl
semantics of W loads, but makes dissection of
64bit fields with absolute addressing possible 

the direct access to packet is implemented as
a `load_bytes(off, var)` built-in for basic support,
there is no implicit data loader using it yet

the packet can now use indirect addressing mode
using NET_OFF to read from network protocol off

it has convenience dissectors for IPv4 and IPv6,
that can be used like:

```
local net = pkt.net_off
if net.ver == 4 then
    local ip = net.ip
else
    local ip6 = net.ip6
end
```

Free demangle_name after use

docs: update list of XDP compatible drivers