2066-pin processors

Am 28.12.18 um 10:46 schrieb Tim Williams: ...

I fully agree.

Gerhard

In SIMD vector processing, there is no need for a specific word length, 64. 666, 1000 or 1024 arguments are as good. Any number is either too small or too large for a specific application, except perhaps for some FFT type special cases.

Anyway, the problem with SIMD (Single Instruction Multiple Data) is moving input data to proper positions for a high speed SIMD superinstruction to execute and moving the results to application specific places.

Am 28.12.18 um 11:21 schrieb Gerhard Hoffmann:

I'd like to add that that people prove funny things.

For example, you can use ComeFroms instead of GoTos. Just label each instruction with the information after what other instruction it may be executed. The "ComeFrom address"

:-)

such as using "const" to suggest putting in read-only memory or "volatile" to signify that the memory mapped I/O register might change contents without program actions ?

These are all inputs to the linker and/or loader.

Some linkers first group sections by the attributes and within the same group by section name. Might be useful if you need to arrange sections.

Storing the return address in the first word of the subroutine was a common trick, for instance the DDP-x16 series (later Honeywell) used this trick in the 1960's. Those machines had index registers, so no need for self modifying code for array access.

However, I have never heard until now anyone calling storing return addresses in the first word of subroutine as self modifying code.

On modern processors, you need to flush the instruction cache/pipeline before executing the modified instruction.

The only case I have heard someone using self modifying code recently is trying to hide some algorithms. An algorithm could be recovered from compiled code simply by disassembling. However, if the algorithm code is created at run time by self modifying code, you would have to single step through the code building the self modifying code.

To store 6 characters ABCDEF into a 36 bit machine into a single register using 6 bit characters you would write 6HABCDEF

On a 16 bit machine using ASCII that would occupy three words.

I was referring to the office environment in which people put Post-it labels on their cubicle wall.

Interestingly enough, I was watching a video about a hacking challenge, a crafted puzzle based on Etherium cryptocurrency. The smart contracts VM (yes, it's a real bytecode-executing VM, possibly based on Java but I don't know the details) contains instructions for jumps, which can only target entry point instructions.

So, there for example, is a VM with both! :)

Now, ComeFroms without GoTos, or vice versa, that's what you should be worried :-)

On a related note, I learned that C supports labels for a different purpose: breaking to a different level of a nested loop. Probably obvious to many... but rarely seen!

Tim

It isn't gotos that are depressing to find, it's named labels with no matching goto in sight. Almost as bad as a ComeFrom, but not as bad as a Fortran computed GOTO.

Sure, the two best ways of pulling the ripcord in a deeply nested loop are a goto or throwing an exception. Just make sure that the named label is in the same screen-full of code and outside the outer loop. I wouldn't use goto to traverse part of the loop hierarchy.

Not just gotos, but switch statements as well--search for "Duff's Device". Back when processors and compilers were simpler than they are now, it made for some fairly startling speed improvements. Nowadays I'd expect it to be slower except on simple processors such as ARM Cortexes.

Cheers

Phil Hobbs

"In managing the DoD there are many unexpected communications problems. For instance, when the Marines are ordered to "secure a building," they form a landing party and assault it. On the other hand, the same instructions will lead the Army to occupy the building with a troop of infantry, and the Navy will characteristically respond by sending a yeoman to assure that the building lights are turned out. When the Air Force acts on these instructions, what results is a three year lease with option to purchase."

-- James Schlesinger (former Secretary of Defense, USA).

IIRC the original High Level Hardware Orion computer had a "come from" instruction at the (user writeable) microcode level.

I said no such thing.

Bill Gates once said that his customers ask for new features, not security. That was Microsoft philosophy.

Why couldn't a few million people sue Microsoft for damages?

What is wrong with computed GOTO. These days one would use switch/case in C.

The assigned GOTO is much more interesting. Assign the statement of a FORMAT statement or modify the switch variable e.g. by incrementing it and then execute the assigned GOTO.

In COBOL you can write quite hard to understand code e.g. with PERFORM THROUGH.

Section-A. code for A Section-B. code for B Section-C. code for C

PERFORM Section-B. Execute code for B only

PERFORM Section-A THRU Section-C Executes codes A, B and C

Using GOTOs to exit deeply nested loops should be the standard practice. It is much clearer than testing at the beginning/end of each nested loop if the exit condition exists.

A much more interesting thing is jumping _into_ some nested loops :-). Many stack oriented languages may fail, if the compiler allocates inner loop variables on stack. Even a FORTRAN compiler might in some cases complain that the DO loop statement variable is not initialized, if you try to jump _into_ a DO statement.

The examples above (except Cobol perform thru) are/were standard assembly tricks imported into a higher level language.

But it breaks a lot of optimizations of loops, because decrement-skip-if-zero instructions are available as a substitute for the declared loop index. Leaving the loop means you need to save a current-value for each loop counter (even if your optimizer didn't update those variables inside the loop, because it was using a shortcut).

Stupid compiler.

Only if one of the loop variable is used outside the loop, it needs to be saved before jumping out.

I use explicit assignment into a local variable before jumping out, since I do not recall in which languages the loop variable is valid outside the loop or not.

I agree that jumping _into_ a loop will kill the optimization.

Sorry, you're right, it was David Brown.

I say enough crazy things that I don't need to be misquoted.

It was me who said it is meaningless to say something is "secure", as an absolute, binary term. It is a bit like saying something is "fast" or "efficient". You can sometimes make something secure against a particular type of attack, but usually you can't be entirely sure. You have to view it as a process - a continual effort to making something steadily more secure, at least until is is secure enough for the purpose.