[FTfJP23] Points-to Analysis for Context-oriented Javascript Programs

Points-to Analysis for Context-
Oriented JavaScript Programs
Sergio Cardenas, Paul Leger, Hiroaki Fukuda, Nicolás Cardozo
Systems an Computing Engineering - Universidad de los Andes, Bogotá - Colombia
Universidad Católica del Norte, Coquimbo - Chile
Shibaura Institute of Technology, Tokyo - Japan
se.cardenas@uniandes.edu.co, pleger@ucn.cl, hiroaki@shibaura-it.ac.jp, n.cardozo@uniandes.edu.co
@ncardoz
Formal Techniques for Java-like Programs - 18 / 07 / 2023

Points-to analysis
2
Object first(Object o1, Object o2){
return o1;
}
Object second(Object o1, Object o2){
return first(o2, o1);
}
void f() {
Object o1 = new Object();
Object o3 = first(o1, o2);
Object o5 = second(o1, o2);
}
f

Points-to analysis
2
return o1;
}
}
void f() {
}
o1 inst1
f

Points-to analysis
2
return o1;
}
}
void f() {
}
o1
o2
inst1
inst2
f

Points-to analysis
2
return o1;
}
}
void f() {
}
o1
o2
inst1
inst2
o3
f
first

Points-to analysis
2
return o1;
}
}
void f() {
}
o1
o2
inst1
inst2
o3
inst1
f
first

Points-to analysis
2
return o1;
}
}
void f() {
}
o1
o2
inst1
inst2
o3
inst1
first
inst1
inst2
...
f
first

3
programs need to be more dynamic …

3
… due to complex and
changing requirements

3
new modularity
abstractions

3
new modularity
abstractions
changing locations

Context-oriented programming (COP)
4
Msg = {
send: function(msg) {
return msg;
}
};

4
Msg = {
return msg;
}
};
Encryption = new cop.Context({});
EncryptionBehavior = Trait({
return "<E>" + this.proceed() + "<E>";
}
});

4
Msg = {
return msg;
}
};
}
});
Compression = new cop.Context({});
CompressionBehavior = Trait({
return "<C>" + this.proceed() + "<C>";
}
});

4
Msg = {
return msg;
}
};
}
});
}
});
Encryption.adapt(Msg, EncryptionBehavior);
Compression.adapt(Msg, CompressionBehavior);

4
Msg = {
return msg;
}
};
}
});
}
});
Encryption.activate();

4
Msg = {
return msg;
}
};
}
});
}
});
Compression.activate();

5
msg = Msg();
msg.send(42);

5
Msg = {
return msg;
}
};
}
});
}
});
msg = Msg();
msg.send(42);

6
Base analysis precise and efficient
to determine different properties
about dynamic programs in COP

Analyzing COP programs
7
COP program

7
COP program
Context.adapt(object1, trait1)
Context.adapt(objectn, traitm)
…
1. tuple extraction
⟨ctx, trait, obj⟩

7
COP program
…
1. tuple extraction
⟨ctx, trait, obj⟩ 2. Code transformation

7
COP program
…
1. tuple extraction
⟨ctx, trait, obj⟩ 2. Code transformation 3. Field-sensitive correlation
tracking analysis

Context identification and transformation
8
}
});

9
}
});

9
}
});
o = {
send: function() {
return "<E>" + this.proceed() + “<E>";
}
}
EncryptionBehavior = Trait(o);
EncryptionBehavior.obj = o;

10
}
});

10
}
});
Encryption.adaptation1 = {
obj: Msg,
trait: EncryptionBehavior
}

11
}
});

11
}
});
for(var p in
Encryption.adaptation1.trait.obj) {
(function (prop) {
Encryption.adaptation1.obj[prop] =
Encryption.adaptation1.trait.obj[prop];
})(p);
}

12
Experiments
use four
different
applications
comparing
field-sensitive
analysis and
our extension
hello-world.js
shape-polymorphism.js
video-encoder.js
course-management.js
https://
fl
aglab.github.io/AdaptiveSystemAnalysis/

Precision evaluation
13
Shape = {
b: 2,
h: 3,
type: "shape",
getType: function() { return this.type; },
area: function() { return 'Calling an abstract method area’; },
perimeter: function() { return 'Calling an abstract method perimeter’; },
numberOfSides: function() { return 0; }
};
Triangle = new cop.Context({});
TriangleBehavior = cop.Trait({
getType: function() { return “triangle"; },
area: function() { return this.b * this.h/2; },
perimeter: function() {
return this.b + 2*Math.sqrt(Math.pow(this.h,2) + Math.pow(this.b/2, 2));
},
});
Triangle.adapt(TShape, TriangleBehavior);
Circle = new cop.Context({});
CircleBehavior = cop.Trait({
getType: function() { return “circle"; },
area: function() { return Math.pow(this.b, 2) * Math.PI; },
perimeter: function() { return this.b * 2* Math.PI; },
numberOfSides: function() {
throw new Error("Number of sides is not defined in a circle");
}
});
Circle.adapt(Shape, CircleBehavior);
baseline ours
r1
r2
r3
r4
r6
r5
r7
r8
r9

13
Shape = {
b: 2,
h: 3,
type: "shape",
};
},
});
}
});
area
baseline ours
r1
r1
r2
r3
r4
r6
r5
r7
r8
r9

13
Shape = {
b: 2,
h: 3,
type: "shape",
};
},
});
}
});
area
baseline ours
r1
r1
r2
r3
r4
r6
r5
r1
r3
r6
r7
r8
r9
area

14
Shape = {
b: 2,
h: 3,
type: "shape",
};
},
});
}
});
baseline ours
r1
r2
r3
r4
r6
r5
r7
r8
r9

14
Shape = {
b: 2,
h: 3,
type: "shape",
};
},
});
}
});
sides
baseline ours
r9
r1
r2
r3
r4
r6
r5
r7
r8
r9

14
Shape = {
b: 2,
h: 3,
type: "shape",
};
},
});
}
});
sides
baseline ours
r9
r1
r2
r3
r4
r6
r5
r8
r7
r9
r7
r8
r9
sides

The road ahead … adaptation completeness
15
Context1 = new cop.Context({});
Behavior1 = cop.Trait({
foo: function() ...
});
Context1.adapt(Object, Behavior1);
bar: function(){
baz();
foo();
}
});
Object = {
baz: function() ...
};

15
foo: function() ...
});
bar: function(){
baz();
foo();
}
});
Object = {
baz: function() ...
};
Context1.activate();
bar();
1.

15
foo: function() ...
});
bar: function(){
baz();
foo();
}
});
Object = {
baz: function() ...
};
bar();
bar();
1. 2.

Conclusion
16
@ncardoz
COP
analysis framework

Conclusion
16
@ncardoz
COP
analysis framework
First analysis taking into
account the modularity and
dynamic aspects of COP

Conclusion
16
@ncardoz
COP
analysis framework
First analysis taking into
account the modularity and
dynamic aspects of COP
Improved recall for COP
programs (without proceed)

[FTfJP23] Points-to Analysis for Context-oriented Javascript Programs

More Related Content

Similar to [FTfJP23] Points-to Analysis for Context-oriented Javascript Programs

More from Universidad de los Andes

Recently uploaded

[FTfJP23] Points-to Analysis for Context-oriented Javascript Programs