There are several different types of pointer analyses. The main distinguishing feature is whether they are flow-sensitive (i.e. the relationship between two statements in a program's control flow matters) or flow-insensitive (i.e. it does not). Consider the following program:
1: a = &x;
2: a = &y;
3: b = a;
In a flow-sensitive pointer analysis, we can see that the assignment to a in line 2 overrides the assignment in line 1. Thus, since line 3 happens later in control flow, we could determine that b points to x. However, in a flow-insensitive analysis, the ordering of statements does not matter, and thus we would have to assume that a points to either x or y, and hence so does b. Flow-insensitive analyses are thus less precise, but can be calculated more efficiently.
Andersen-style pointer analysis is a flow-insensitive, inclusion based style of pointer analysis. As a flow-insensitive analysis, it maintains a single points-to graph for the entire program, rather than one for each program point. It is an O(n^3) algorithm and can be solved using constraint satisfaction.
Analyses can be context-sensitive or context-insensitive. The former keeps distinguishes between two instances of the same program statement depending on calling context, while the latter does not. The former is more accurate, but the latter is easier to calculate. Your analysis should be context-insensitive.
A key factor in the efficiency of Andersen-style analyses is how well they detect cycles in the constraint graph. Hardekopf and Lin showed how this detection can be made significantly more efficient with their Lazy and Hybrid cycle detection algorithms, detailed here. Your implementation should utilize these techniques.
Polyglot is an extensible compiler framework for Java developed at Cornell University. In rough outline, it parses a source language and produces an abstract syntax tree (AST) which can then be manipulated. The AST is finally compiled down to bytecode. The framework provides support for control-flow graphs and dataflow analysis
A working Andersen-style points-to analysis in Polyglot, run on the SpecJVM benchmark suite. Also, a report detailing the analysis, your implementation, and results