Remove mipsel-linux-android gcc-4.8 bins, libs, and includesHEADmastermain

Android has moved to newer versions of GCC/binutils, then LLVM.

There was no gcc-4.9 build for this triple AFAICT; I suspect Android
moved to the mips64el-linux-android toolchain at that point.

Bug: 203698882
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
Change-Id: Idd3b212b0f835bcd385826dd4e400792e66d5046

1 files changed, 0 insertions, 302 deletions

diff --git a/share/gdb/python/gdb/FrameDecorator.py b/share/gdb/python/gdb/FrameDecorator.py
deleted file mode 100644
index 1bbc5ab..0000000
--- a/share/gdb/python/gdb/FrameDecorator.py
+++ /dev/null
@@ -1,302 +0,0 @@
-# Copyright (C) 2013-2014 Free Software Foundation, Inc.
-
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program 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 General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-import gdb
-
-# This small code snippet deals with problem of strings in Python 2.x
-# and Python 3.x.  Python 2.x has str and unicode classes which are
-# sub-classes of basestring.  In Python 3.x all strings are encoded
-# and basestring has been removed.
-try:
-    basestring
-except NameError:
-    basestring = str
-
-class FrameDecorator(object):
-    """Basic implementation of a Frame Decorator"""
-
-    """ This base frame decorator decorates a frame or another frame
-    decorator, and provides convenience methods.  If this object is
-    wrapping a frame decorator, defer to that wrapped object's method
-    if it has one.  This allows for frame decorators that have
-    sub-classed FrameDecorator object, but also wrap other frame
-    decorators on the same frame to correctly execute.
-
-    E.g
-
-    If the result of frame filters running means we have one gdb.Frame
-    wrapped by multiple frame decorators, all sub-classed from
-    FrameDecorator, the resulting hierarchy will be:
-
-    Decorator1
-      -- (wraps) Decorator2
-        -- (wraps) FrameDecorator
-          -- (wraps) gdb.Frame
-
-    In this case we have two frame decorators, both of which are
-    sub-classed from FrameDecorator.  If Decorator1 just overrides the
-    'function' method, then all of the other methods are carried out
-    by the super-class FrameDecorator.  But Decorator2 may have
-    overriden other methods, so FrameDecorator will look at the
-    'base' parameter and defer to that class's methods.  And so on,
-    down the chain."""
-
-    # 'base' can refer to a gdb.Frame or another frame decorator.  In
-    # the latter case, the child class will have called the super
-    # method and _base will be an object conforming to the Frame Filter
-    # class.
-    def __init__(self, base):
-        self._base = base
-
-    @staticmethod
-    def _is_limited_frame(frame):
-        """Internal utility to determine if the frame is special or
-        limited."""
-        sal = frame.find_sal()
-
-        if (not sal.symtab or not sal.symtab.filename
-            or frame.type() == gdb.DUMMY_FRAME
-            or frame.type() == gdb.SIGTRAMP_FRAME):
-
-            return True
-
-        return False
-
-    def elided(self):
-        """Return any elided frames that this class might be
-        wrapping, or None."""
-        if hasattr(self._base, "elided"):
-            return self._base.elided()
-
-        return None
-
-    def function(self):
-        """ Return the name of the frame's function or an address of
-        the function of the frame.  First determine if this is a
-        special frame.  If not, try to determine filename from GDB's
-        frame internal function API.  Finally, if a name cannot be
-        determined return the address.  If this function returns an
-        address, GDB will attempt to determine the function name from
-        its internal minimal symbols store (for example, for inferiors
-        without debug-info)."""
-
-        # Both gdb.Frame, and FrameDecorator have a method called
-        # "function", so determine which object this is.
-        if not isinstance(self._base, gdb.Frame):
-            if hasattr(self._base, "function"):
-                # If it is not a gdb.Frame, and there is already a
-                # "function" method, use that.
-                return self._base.function()
-
-        frame = self.inferior_frame()
-
-        if frame.type() == gdb.DUMMY_FRAME:
-            return "<function called from gdb>"
-        elif frame.type() == gdb.SIGTRAMP_FRAME:
-            return "<signal handler called>"
-
-        func = frame.function()
-
-        # If we cannot determine the function name, return the
-        # address.  If GDB detects an integer value from this function
-        # it will attempt to find the function name from minimal
-        # symbols via its own internal functions.
-        if func == None:
-            pc = frame.pc()
-            return pc
-
-        return str(func)
-
-    def address(self):
-        """ Return the address of the frame's pc"""
-
-        if hasattr(self._base, "address"):
-            return self._base.address()
-
-        frame = self.inferior_frame()
-        return frame.pc()
-
-    def filename(self):
-        """ Return the filename associated with this frame, detecting
-        and returning the appropriate library name is this is a shared
-        library."""
-
-        if hasattr(self._base, "filename"):
-            return self._base.filename()
-
-        frame = self.inferior_frame()
-        sal = frame.find_sal()
-        if not sal.symtab or not sal.symtab.filename:
-            pc = frame.pc()
-            return gdb.solib_name(pc)
-        else:
-            return sal.symtab.filename
-
-    def frame_args(self):
-        """ Return an iterable of frame arguments for this frame, if
-        any.  The iterable object contains objects conforming with the
-        Symbol/Value interface.  If there are no frame arguments, or
-        if this frame is deemed to be a special case, return None."""
-
-        if hasattr(self._base, "frame_args"):
-            return self._base.frame_args()
-
-        frame = self.inferior_frame()
-        if self._is_limited_frame(frame):
-            return None
-
-        args = FrameVars(frame)
-        return args.fetch_frame_args()
-
-    def frame_locals(self):
-        """ Return an iterable of local variables for this frame, if
-        any.  The iterable object contains objects conforming with the
-        Symbol/Value interface.  If there are no frame locals, or if
-        this frame is deemed to be a special case, return None."""
-
-        if hasattr(self._base, "frame_locals"):
-            return self._base.frame_locals()
-
-        frame = self.inferior_frame()
-        if self._is_limited_frame(frame):
-            return None
-
-        args = FrameVars(frame)
-        return args.fetch_frame_locals()
-
-    def line(self):
-        """ Return line number information associated with the frame's
-        pc.  If symbol table/line information does not exist, or if
-        this frame is deemed to be a special case, return None"""
-
-        if hasattr(self._base, "line"):
-            return self._base.line()
-
-        frame = self.inferior_frame()
-        if self._is_limited_frame(frame):
-            return None
-
-        sal = frame.find_sal()
-        if (sal):
-            return sal.line
-        else:
-            return None
-
-    def inferior_frame(self):
-        """ Return the gdb.Frame underpinning this frame decorator."""
-
-        # If 'base' is a frame decorator, we want to call its inferior
-        # frame method.  If '_base' is a gdb.Frame, just return that.
-        if hasattr(self._base, "inferior_frame"):
-            return self._base.inferior_frame()
-        return self._base
-
-class SymValueWrapper(object):
-    """A container class conforming to the Symbol/Value interface
-    which holds frame locals or frame arguments."""
-    def __init__(self, symbol, value):
-        self.sym = symbol
-        self.val = value
-
-    def value(self):
-        """ Return the value associated with this symbol, or None"""
-        return self.val
-
-    def symbol(self):
-        """ Return the symbol, or Python text, associated with this
-        symbol, or None"""
-        return self.sym
-
-class FrameVars(object):
-
-    """Utility class to fetch and store frame local variables, or
-    frame arguments."""
-
-    def __init__(self, frame):
-        self.frame = frame
-        self.symbol_class = {
-            gdb.SYMBOL_LOC_STATIC: True,
-            gdb.SYMBOL_LOC_REGISTER: True,
-            gdb.SYMBOL_LOC_ARG: True,
-            gdb.SYMBOL_LOC_REF_ARG: True,
-            gdb.SYMBOL_LOC_LOCAL: True,
-	    gdb.SYMBOL_LOC_REGPARM_ADDR: True,
-	    gdb.SYMBOL_LOC_COMPUTED: True
-            }
-
-    def fetch_b(self, sym):
-        """ Local utility method to determine if according to Symbol
-        type whether it should be included in the iterator.  Not all
-        symbols are fetched, and only symbols that return
-        True from this method should be fetched."""
-
-        # SYM may be a string instead of a symbol in the case of
-        # synthetic local arguments or locals.  If that is the case,
-        # always fetch.
-        if isinstance(sym, basestring):
-            return True
-
-        sym_type = sym.addr_class
-
-        return self.symbol_class.get(sym_type, False)
-
-    def fetch_frame_locals(self):
-        """Public utility method to fetch frame local variables for
-        the stored frame.  Frame arguments are not fetched.  If there
-        are no frame local variables, return an empty list."""
-        lvars = []
-
-        try:
-            block = self.frame.block()
-        except RuntimeError:
-            block = None
-
-        while block != None:
-            if block.is_global or block.is_static:
-                break
-            for sym in block:
-                if sym.is_argument:
-                    continue;
-                if self.fetch_b(sym):
-                    lvars.append(SymValueWrapper(sym, None))
-
-            block = block.superblock
-
-        return lvars
-
-    def fetch_frame_args(self):
-        """Public utility method to fetch frame arguments for the
-        stored frame.  Frame arguments are the only type fetched.  If
-        there are no frame argument variables, return an empty list."""
-
-        args = []
-
-        try:
-            block = self.frame.block()
-        except RuntimeError:
-            block = None
-
-        while block != None:
-            if block.function != None:
-                break
-            block = block.superblock
-
-        if block != None:
-            for sym in block:
-                if not sym.is_argument:
-                    continue;
-                args.append(SymValueWrapper(sym, None))
-
-        return args