last case must be var_dump(strrpos("works_like_a_charm", 'charm', -5)); //ER: false, AR: 13

when offset is negative the search *starts* that many characters *from the end*. The search is not excluding the last n characters. 

strrpos("aaaa", 'aa', -2) == strrpos("aaaa", 'aa', 2)
strrpos("aaaa", 'a', -1) == strrpos("aaaa", 'a', 3)
strrpos("/documents/show/5474", '/', -20) == strrpos("/documents/show/5474", '/', 0)
strrpos("works_like_a_charm", 'charm', -3) == strrpos("works_like_a_charm", 'charm', 15)
strrpos("works_like_a_charm", 'charm', -4) == strrpos("works_like_a_charm", 'charm', 14)


So they work as expected. 

What you want to do would be achieved by this:

strrpos(substr("aaaa", -2), "aa");

When needle is longer than the remaining string, the offset seems to be expanded to at least include the needle.

Note also the comment on http://php.net/manual/de/function.strrpos.php#76447

1. Does strrpos("works_like_a_charm", 'charm', 15) really equals to strrpos("works_like_a_charm", 'charm', -3)? false != 13. It is also applicable for 3 last cases.

Looks like you're right! I dug deeper into it and it seems there is an issue when the negative offset is smaller or equals the size of the needle.

I'm digging deeper into it.

Looks like the problem is related to https://github.com/php/php-src/blob/PHP-5.6.29/ext/standard/string.c#L1987

replace this one:
e = haystack + haystack_len + offset;

with this one:
e = haystack + haystack_len + offset - needle_len;

will solve the problem.

my previous comment is not absolutely right. I'm not sure why those conditions are needed:

if (needle_len > -offset) {
	e = haystack + haystack_len - needle_len;
} else {
	e = haystack + haystack_len + offset;
}

In all cases we need to subtract absolute value of offset from e pointer and also subtract value of needle length. There is no reason to check needle_len > -offset

The current implementation is mathematically correct and is the same as f.e. the implementation in Java and other programming languages. The docs are misleading here.

The negative offset specifies the last offset in the string the needle can start. Therefore the results are correct.

Though the documentation of that feature needs some work to explicitly state that and make that more clear.

For more infos have a look at https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#lastIndexOf(java.lang.String,%20int)

Java implementation has no negative fromIndex for "public int lastIndexOf(String str, int fromIndex)". Java implementation returns "-1" for any negative fromIndex.
There is an examples from python:
"
>>> 'aaaa'.rfind('a',0, -2)
1
>>> 'aaaa'.rfind('a', 0, -1)
2
>>> '/documents/show/5474'.rfind('/', 0, -20)
-1
>>> 'works_like_a_charm'.rfind('charm', 0, -3)
-1
>>> 'works_like_a_charm'.rfind('charm', 0, -5)
-1
"

It works the way we expect

> Java implementation has no negative fromIndex for "public int
> lastIndexOf(String str, int fromIndex)".

If the offset is negative, strrpos($haystack, $needle, $offset)
behaves like String.lastIndexOf(needle, -offset).

> It works the way we expect

Then you have to adjust your expectations. :)  Or, your code.
For instance:

  strrpos('works_like_a_charm', 'charm', -3 - strlen('charm')); // false