gcc-4.3.1/libjava/gnu/gcj/tools/gc_analyze/MemoryMap.java - toolchain/gcc - Git at Google

 /* MemoryMap.java -- Maps address ranges to their data.
    Copyright (C) 2007  Free Software Foundation

    This file is part of libgcj.

    This software is copyrighted work licensed under the terms of the
    Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
    details.  */

 package gnu.gcj.tools.gc_analyze;

 import java.io.BufferedReader;
 import java.io.EOFException;
 import java.io.File;
 import java.io.IOException;
 import java.io.RandomAccessFile;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.nio.channels.FileChannel;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.SortedSet;
 import java.util.TreeSet;

 /**
  * Reads /proc/self/maps output from dump file.
  * Creates map of <filename> to Range.
  *
  * Returns filename given address.
  * Returns offset given address.
  * Returns BytePtr given address.
  *
  */
 class MemoryMap
 {
   static class RangeComparator implements Comparator<Range>
   {
     public int compare(Range r1, Range r2)
     {
       if (r2.end == 0 && r1.end != 0)
         return -compare(r2, r1);

       if (r1.begin < r2.begin)
         return -1;
       else if (r1.begin >= r2.end)
         return 1;
       else
         return 0;
     }
   }

   static class Range
   {
     long begin;
     long end;

     long offset;
     String filename;
     Range()
     {
     }

     Range(long b, long e, String s, long o)
     {
       begin = b;
       end = e;
       filename = s;
       offset = o;
     }
   }

   /**
    * Parse the string as an unsigned hexadecimal number.  This is
    * similar to Long.parseInt(s,16), but without the restriction that
    * values that have the sign bit set not being allowed.
    *
    * @param s the number as a String.
    * @return the number.
    */
   static long parseHexLong(String s)
   {
     if (s.length() > 16)
       throw new NumberFormatException();
     long r = 0;
     for (int i = 0; i < s.length(); i++)
       {
         int digit = 0;
         char c = s.charAt(i);
         switch (c)
           {
           case '0':
           case '1':
           case '2':
           case '3':
           case '4':
           case '5':
           case '6':
           case '7':
           case '8':
           case '9':
             digit = c - '0';
             break;
           case 'a':
           case 'b':
           case 'c':
           case 'd':
           case 'e':
           case 'f':
             digit = 10 + c - 'a';
             break;
           case 'A':
           case 'B':
           case 'C':
           case 'D':
           case 'E':
           case 'F':
             digit = 10 + c - 'A';
             break;
           default:
             throw new NumberFormatException();
           }
         r = (r << 4) + digit;
       }
     return r;
   }

   // String filename -> Range
   TreeSet<Range> map = new TreeSet<Range>(new RangeComparator());
   HashMap<String, SymbolTable> symbolTables =
     new HashMap<String, SymbolTable>();
   ByteOrder byteOrder;
   int wordSize;

   public MemoryMap(BufferedReader reader,
                    String rawFileName) throws IOException
   {
     FileChannel raw = (new RandomAccessFile(rawFileName, "r")).getChannel();
     ByteBuffer buf = ByteBuffer.allocate(8);
     raw.read(buf);
     if (buf.hasRemaining())
       {
         raw.close();
         throw new EOFException();
       }
     buf.flip();
     wordSize = buf.get();

     if (wordSize == 8 || wordSize == 4)
       byteOrder = ByteOrder.LITTLE_ENDIAN;
     else
       {
         byteOrder = ByteOrder.BIG_ENDIAN;
         buf.rewind();
         wordSize = buf.getInt();
         if (0 == wordSize)
           wordSize = buf.getInt();
       }
     switch (wordSize)
       {
       case 4:
       case 8:
         break;
       default:
         throw new IOException("Bad .bytes file header");
       }
     buf = ByteBuffer.allocate(3 * wordSize);
     buf.order(byteOrder);
     raw.position(0L);

     for(;;)
       {
         // Read the block header.
         buf.clear();
         if (-1 == raw.read(buf))
           {
             //EOF
             raw.close();
             break;
           }
         if (buf.hasRemaining())
           {
             raw.close();
             throw new EOFException();
           }
         buf.flip();
         long dummy
           = (wordSize == 4) ? (buf.getInt() & 0xffffffffL) : buf.getLong();
         if (dummy != wordSize)
           throw new IOException("Bad .bytes file header");
         long start
           = wordSize == 4 ? (buf.getInt() & 0xffffffffL) : buf.getLong();
         long length
           = wordSize == 4 ? (buf.getInt() & 0xffffffffL) : buf.getLong();
         if (length < 0L)
           throw new IOException("Bad .bytes file header");

         long currentPos = raw.position();
         raw.position(currentPos + length);

         Range range = new Range(start, start + length,
                                 rawFileName, currentPos);
         map.add(range);
       }

     for (;;)
       {
         String s = reader.readLine();
         if (s == null)
           break;
         if (s.indexOf("Begin address map") >= 0)
           {
             for (;;)
               {
                 s = reader.readLine();
                 if (s.indexOf("End address map") >= 0)
                   {
                     dump();
                     return;
                   }
                 int endOfAddress = s.indexOf('-');
                 long address = parseHexLong(s.substring(0, endOfAddress));
                 int endOfAddress2 = s.indexOf(' ', endOfAddress + 1);
                 long address2 = parseHexLong(s.substring(endOfAddress + 1,
                                                          endOfAddress2));
                 int endOfOffset = s.indexOf(' ', endOfAddress2 + 6);
                 long offset;
                 try
                   {
                     offset = parseHexLong(s.substring(endOfAddress2 + 6,
                                                       endOfOffset));
                   }
                 catch (Exception e)
                   {
                     offset = 0;
                   }
                 int end = s.indexOf('/');

                 if (end > 0)
                   {
                     String file = s.substring(end);
                     if (file.startsWith("/dev/"))
                       continue;

                     Range r = new Range(address, address2, file, offset);
                     if (offset == 0)
                       {
                         // Read the file's symbol table
                         try
                           {
                             File f = ToolPrefix.fileForName(file);
                             if (f != null)
                               {
                                 SymbolTable st = new SymbolTable(f.getPath());
                                 if (st.loadAddr != address)
                                   st.relocation = address - st.loadAddr;
                                 symbolTables.put(file, st);
                               }
                           }
                         catch (Exception ex)
                           {
                             ex.printStackTrace();
                           }
                       }
                     map.add(r);
                   }
               } // inner loop
           } // started inner loop
       } // outer loop - finding begin
   } // memoryMap


   public void dump()
   {
     System.out.println("MemoryMap:");
     for (Range r : map)
       {
         System.out.println(Long.toHexString(r.begin) + "-"
                            + Long.toHexString(r.end) + " -> "
                            + r.filename + " offset "
                            + Long.toHexString(r.offset));
       }
   }

   Range getRange(long addr)
   {
     Range r = new Range();
     r.begin = addr;
     SortedSet<Range> t = map.tailSet(r);
     if (t.isEmpty())
       return null;
     Range c = t.first();
     if (c.begin <= addr && addr < c.end)
       return c;
     return null;
   }

   String getFile(long addr)
   {
     Range r = getRange(addr);
     if (null != r)
       return r.filename;
     return null;
   }

   long getOffset(long addr)
   {
     Range r = getRange(addr);
     if (null != r)
       return r.offset;
     return 0L;
   }

   /**
    * @return BytePtr which includes given address.
    */
   BytePtr getBytePtr(long addr, int length) throws IOException
   {
     Range r = getRange(addr);

     if (null == r)
       return null;

     File f = ToolPrefix.fileForName(r.filename);
     if (null == f)
       return null;

     if (addr + length > r.end)
       length = (int)(r.end - addr);

     ByteBuffer b = ByteBuffer.allocate(length);
     b.order(byteOrder);

     FileChannel fc = (new RandomAccessFile(f, "r")).getChannel();
     fc.position(r.offset + addr - r.begin);
     int nr = fc.read(b);
     fc.close();
     if (nr != length)
       return null;
     b.flip();
     return new BytePtr(b, wordSize);
   }

   public String getSymbol(long addr)
   {
     Range r = getRange(addr);

     if (r == null)
       return null;

     SymbolTable st = symbolTables.get(r.filename);
     if (st == null)
       return null;

     // Apply relocation
     addr -= st.relocation;

     return st.getSymbol(addr);
   }
 }
	/* MemoryMap.java -- Maps address ranges to their data.
	Copyright (C) 2007 Free Software Foundation

	This file is part of libgcj.

	This software is copyrighted work licensed under the terms of the
	Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
	details. */

	package gnu.gcj.tools.gc_analyze;

	import java.io.BufferedReader;
	import java.io.EOFException;
	import java.io.File;
	import java.io.IOException;
	import java.io.RandomAccessFile;
	import java.nio.ByteBuffer;
	import java.nio.ByteOrder;
	import java.nio.channels.FileChannel;
	import java.util.Comparator;
	import java.util.HashMap;
	import java.util.SortedSet;
	import java.util.TreeSet;

	/**
	* Reads /proc/self/maps output from dump file.
	* Creates map of <filename> to Range.
	*
	* Returns filename given address.
	* Returns offset given address.
	* Returns BytePtr given address.
	*
	*/
	class MemoryMap
	{
	static class RangeComparator implements Comparator<Range>
	{
	public int compare(Range r1, Range r2)
	{
	if (r2.end == 0 && r1.end != 0)
	return -compare(r2, r1);

	if (r1.begin < r2.begin)
	return -1;
	else if (r1.begin >= r2.end)
	return 1;
	else
	return 0;
	}
	}

	static class Range
	{
	long begin;
	long end;

	long offset;
	String filename;
	Range()
	{
	}

	Range(long b, long e, String s, long o)
	{
	begin = b;
	end = e;
	filename = s;
	offset = o;
	}
	}

	/**
	* Parse the string as an unsigned hexadecimal number. This is
	* similar to Long.parseInt(s,16), but without the restriction that
	* values that have the sign bit set not being allowed.
	*
	* @param s the number as a String.
	* @return the number.
	*/
	static long parseHexLong(String s)
	{
	if (s.length() > 16)
	throw new NumberFormatException();
	long r = 0;
	for (int i = 0; i < s.length(); i++)
	{
	int digit = 0;
	char c = s.charAt(i);
	switch (c)
	{
	case '0':
	case '1':
	case '2':
	case '3':
	case '4':
	case '5':
	case '6':
	case '7':
	case '8':
	case '9':
	digit = c - '0';
	break;
	case 'a':
	case 'b':
	case 'c':
	case 'd':
	case 'e':
	case 'f':
	digit = 10 + c - 'a';
	break;
	case 'A':
	case 'B':
	case 'C':
	case 'D':
	case 'E':
	case 'F':
	digit = 10 + c - 'A';
	break;
	default:
	throw new NumberFormatException();
	}
	r = (r << 4) + digit;
	}
	return r;
	}

	// String filename -> Range
	TreeSet<Range> map = new TreeSet<Range>(new RangeComparator());
	HashMap<String, SymbolTable> symbolTables =
	new HashMap<String, SymbolTable>();
	ByteOrder byteOrder;
	int wordSize;

	public MemoryMap(BufferedReader reader,
	String rawFileName) throws IOException
	{
	FileChannel raw = (new RandomAccessFile(rawFileName, "r")).getChannel();
	ByteBuffer buf = ByteBuffer.allocate(8);
	raw.read(buf);
	if (buf.hasRemaining())
	{
	raw.close();
	throw new EOFException();
	}
	buf.flip();
	wordSize = buf.get();

	if (wordSize == 8 \|\| wordSize == 4)
	byteOrder = ByteOrder.LITTLE_ENDIAN;
	else
	{
	byteOrder = ByteOrder.BIG_ENDIAN;
	buf.rewind();
	wordSize = buf.getInt();
	if (0 == wordSize)
	wordSize = buf.getInt();
	}
	switch (wordSize)
	{
	case 4:
	case 8:
	break;
	default:
	throw new IOException("Bad .bytes file header");
	}
	buf = ByteBuffer.allocate(3 * wordSize);
	buf.order(byteOrder);
	raw.position(0L);

	for(;;)
	{
	// Read the block header.
	buf.clear();
	if (-1 == raw.read(buf))
	{
	//EOF
	raw.close();
	break;
	}
	if (buf.hasRemaining())
	{
	raw.close();
	throw new EOFException();
	}
	buf.flip();
	long dummy
	= (wordSize == 4) ? (buf.getInt() & 0xffffffffL) : buf.getLong();
	if (dummy != wordSize)
	throw new IOException("Bad .bytes file header");
	long start
	= wordSize == 4 ? (buf.getInt() & 0xffffffffL) : buf.getLong();
	long length
	= wordSize == 4 ? (buf.getInt() & 0xffffffffL) : buf.getLong();
	if (length < 0L)
	throw new IOException("Bad .bytes file header");

	long currentPos = raw.position();
	raw.position(currentPos + length);

	Range range = new Range(start, start + length,
	rawFileName, currentPos);
	map.add(range);
	}

	for (;;)
	{
	String s = reader.readLine();
	if (s == null)
	break;
	if (s.indexOf("Begin address map") >= 0)
	{
	for (;;)
	{
	s = reader.readLine();
	if (s.indexOf("End address map") >= 0)
	{
	dump();
	return;
	}
	int endOfAddress = s.indexOf('-');
	long address = parseHexLong(s.substring(0, endOfAddress));
	int endOfAddress2 = s.indexOf(' ', endOfAddress + 1);
	long address2 = parseHexLong(s.substring(endOfAddress + 1,
	endOfAddress2));
	int endOfOffset = s.indexOf(' ', endOfAddress2 + 6);
	long offset;
	try
	{
	offset = parseHexLong(s.substring(endOfAddress2 + 6,
	endOfOffset));
	}
	catch (Exception e)
	{
	offset = 0;
	}
	int end = s.indexOf('/');

	if (end > 0)
	{
	String file = s.substring(end);
	if (file.startsWith("/dev/"))
	continue;

	Range r = new Range(address, address2, file, offset);
	if (offset == 0)
	{
	// Read the file's symbol table
	try
	{
	File f = ToolPrefix.fileForName(file);
	if (f != null)
	{
	SymbolTable st = new SymbolTable(f.getPath());
	if (st.loadAddr != address)
	st.relocation = address - st.loadAddr;
	symbolTables.put(file, st);
	}
	}
	catch (Exception ex)
	{
	ex.printStackTrace();
	}
	}
	map.add(r);
	}
	} // inner loop
	} // started inner loop
	} // outer loop - finding begin
	} // memoryMap


	public void dump()
	{
	System.out.println("MemoryMap:");
	for (Range r : map)
	{
	System.out.println(Long.toHexString(r.begin) + "-"
	+ Long.toHexString(r.end) + " -> "
	+ r.filename + " offset "
	+ Long.toHexString(r.offset));
	}
	}

	Range getRange(long addr)
	{
	Range r = new Range();
	r.begin = addr;
	SortedSet<Range> t = map.tailSet(r);
	if (t.isEmpty())
	return null;
	Range c = t.first();
	if (c.begin <= addr && addr < c.end)
	return c;
	return null;
	}

	String getFile(long addr)
	{
	Range r = getRange(addr);
	if (null != r)
	return r.filename;
	return null;
	}

	long getOffset(long addr)
	{
	Range r = getRange(addr);
	if (null != r)
	return r.offset;
	return 0L;
	}

	/**
	* @return BytePtr which includes given address.
	*/
	BytePtr getBytePtr(long addr, int length) throws IOException
	{
	Range r = getRange(addr);

	if (null == r)
	return null;

	File f = ToolPrefix.fileForName(r.filename);
	if (null == f)
	return null;

	if (addr + length > r.end)
	length = (int)(r.end - addr);

	ByteBuffer b = ByteBuffer.allocate(length);
	b.order(byteOrder);

	FileChannel fc = (new RandomAccessFile(f, "r")).getChannel();
	fc.position(r.offset + addr - r.begin);
	int nr = fc.read(b);
	fc.close();
	if (nr != length)
	return null;
	b.flip();
	return new BytePtr(b, wordSize);
	}

	public String getSymbol(long addr)
	{
	Range r = getRange(addr);

	if (r == null)
	return null;

	SymbolTable st = symbolTables.get(r.filename);
	if (st == null)
	return null;

	// Apply relocation
	addr -= st.relocation;

	return st.getSymbol(addr);
	}
	}