Previously, the ControlLogix would have had an "SLC Typed Read" and "SLC Typed Write" MSG instruction, to read to and write from the N registers in the SLC.
Now, you will need a "CIP Data Table Read" and "CIP Data Table Write", and you will have to specify the tag names you wish to read/write from/to.
In SLC world, everything comes in pre-built, contiguous registers. So if you tell your CLX to read 20 registers starting from N7:0, it will read N7:0 through N7:19.
In CompactLogix world, you can define whatever data structure you like. Most likely, the data you need to read and write has been converted to an array, perhaps called "Register_N7". So N7:0 became Register_N7[0], and N7:19 became Register_N7[19]. To help get your head around the slight difference, look at the N7 data table in RSLogix 500, and then look at the Register_N7 tag in the Controller Tags window of RSLogix 5000. You can expand out the tag to see the individual elements, and if you want to, expand out each element to see the individual bits. Just the same as if you change the Radix from Decimal to Binary in RSLogix 500.
An array is a contiguous block of data, so you take the same approach as before: you tell the Control Logix to read 20 elements, starting at Register_N7[0]. It will return Register_N7[0] through Register N7[19].
The other piece of the puzzle is the data type. SLC's use 16 bit data (in general) while CompactLogix and ControlLogix use 32 bit data (in general). You will likely find in the Control Logix, that the data tags that are written to the SLC are actually INT type (16 bit) instead of DINT type (32 bit) - and probably likewise with the tags that the data read from the SLC is stored in. If your Control Logix is expecting to read 20x 16-bit words, you had better provide it with 20x 16-bit words. Likewise, if it's expecting to write to 20x 16 bit words, you had better provide it with 20x 16 bit words to write to, lest it write nonsensical data into places you weren't expecting.
Ultimately, you have to make sure the data type at both ends is the same. You can either convert everything to INT, or convert everything to DINT. Best practice is to use DINTs as the CLX is a 32-bit platform and there are performance costs involved with using 16-bit words. In practical terms, this just means that all you need to do is convert the tags in the Control Logix to DINTs.
One final tidbit to consider: where possible, it's often better to read, rather than write. If I have a PLC which is being written to by a remote PLC, I have no easy way of working out what is changing the data, unless the data exchange is very well commented. When dealing with an SLC and a Control Logix, it's quite common to do both the read and write in the CLX, simply because the SLC doesn't understand the CLX's tag-based addressing structure, and can't directly read from a tag. To set up an SLC to read a CLX, you have to do some mapping in the CLX to "simulate" SLC-type registers, like "N7:0". Due to this extra layer of complication, many people end up just doing both the read and the write from the CLX.
However, now you've got two Logix 5000 platforms, which will perform messaging to each other with no such qualms! If you feel so inclined, now might be a good time to investigate the possibility of converting the logic so that both PLC's read from the other, instead of one reading and writing.
And if you feel even more inclined, look into produced/consumed tags. It's another way of doing communications between two Logix-class PLC's, and in many cases is far superior to explicit messaging.
*disclaimer: horses for courses. There are perfectly valid reasons for writing rather than reading, and perfectly valid reasons for using explicit messaging over produced/consumed. It's possible that in your specific situation, the current arrangement is the best possible solution. But it's definitely worth thinking about.