self-modifying

Have you ever created or encountered a self modifying code in Java? If yes, then please post the link or simply post the code. Ignoring the world of grief you could be causing yourself via self-modifying code(!), it seems to me there are 3 options: use the inbuilt compiler support of Java 6 and write/recompile/reload classes use the Apache BCEL bytecode manipulation library to write your class directly make use of Java 6's inbuilt scripting support (or use Apache BSF ) to write methods in your JVM scripting language of choice, and execute these Of the three above, my initial choice (in the

I am not aware of any self-improving compiler, but then again I am not much of a compiler-guy. Is there ANY self-improving compiler out there? Please note that I am talking about a compiler that improves itself - not a compiler that improves the code it compiles . Any pointers appreciated! Side-note : in case you're wondering why I am asking have a look at this post . Even if I agree with most of the arguments I am not too sure about the following: We have programs that can improve their code without human input now — they’re called compilers. ... hence my question. While it is true that

Is there any real use for self modifying code ? I know that they can be used to build worms/viruses, but I was wondering whether there is some good reason that a programmer may have to use self modifying code. Any ideas? Hypothetical situations are welcome too. Turns out that the Wikipedia entry on " self-modifying code " has a great list: Semi-automatic optimization of a state dependent loop. Runtime code generation , or specialization of an algorithm in runtime or loadtime (which is popular, for example, in the domain of real-time graphics) such as a general sort utility preparing code to

I like examples, so I wrote a bit of self-modifying code in c... #include <stdio.h> #include <sys/mman.h> // linux int main(void) { unsigned char *c = mmap(NULL, 7, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_PRIVATE| MAP_ANONYMOUS, -1, 0); // get executable memory c[0] = 0b11000111; // mov (x86_64), immediate mode, full-sized (32 bits) c[1] = 0b11000000; // to register rax (000) which holds the return value // according to linux x86_64 calling convention c[6] = 0b11000011; // return for (c[2] = 0; c[2] < 30; c[2]++) { // incr immediate data after every run // rest of immediate data (c[3:6]) are

i found an article about self modifying code and tried to do some examples, but i get always segmentation faults. As fas as i can understand, there is a violation in memory permissions. The code segment is (r)ead/e(x)ecute and so the attempt of writting results to this fault. Is there a way to test the program either by changing the memory permissions at runtime or before? I'm using linux and the example is written in GAS assembly. .extern memcpy .section .data string: .asciz "whatever" string_end: .section .bss .lcomm buf, string_end-string .section .text .globl main main: call changer mov