ROSE 0.11.145.317
SgAsmCilMetadataRoot.h
1
2#ifndef ROSE_SgAsmCilMetadataRoot_H
3#define ROSE_SgAsmCilMetadataRoot_H
4#include <RoseFirst.h>
5#include <Cxx_GrammarDeclarations.h>
6#include <SgAsmCilNode.h>
7
8
9
10/* #line 1 "/workspace/src/ROSETTA/Grammar/grammarClassDeclarationMacros.macro" */
11
12// WARNING -- GENERATED CODE -- DO NOT MODIFY THIS CODE -- WARNING!
13// This code is automatically generated for each
14// terminal and non-terminal within the defined
15// grammar. There is a simple way to change the
16// code to fix bugs etc. See the ROSE README file
17// for directions.
18
19// tps: (02/22/2010): Adding DLL export requirements
20#include "rosedll.h"
21
22// predeclarations for SgAsmCilMetadataRoot
23
24/* #line 25 "../../../src/frontend/SageIII//SgAsmCilMetadataRoot.h" */
25
26/* #line 13 "/workspace/src/ROSETTA/Grammar/grammarClassDeclarationMacros.macro after subst for $PREDECLARATIONS" */
27
28/* #line 14 "/workspace/src/ROSETTA/Grammar/grammarClassDeclarationMacros.macro" */
29
30#if !defined(DOCUMENTATION)
31// Class Definition for SgAsmCilMetadataRoot
32class ROSE_DLL_API SgAsmCilMetadataRoot : public SgAsmCilNode
33 {
34 public:
35
36
37/* #line 38 "../../../src/frontend/SageIII//SgAsmCilMetadataRoot.h" */
38
39 virtual SgNode* copy ( SgCopyHelp& help) const override;
40// Start of memberFunctionString
41/* #line 34979 "/workspace/src/ROSETTA/src/binaryInstruction.C" */
42
43
44 //----------------------- Boost serialization for SgAsmCilMetadataRoot -----------------------
45#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
46private:
47 friend class boost::serialization::access;
48
49 template<class S>
50 void serialize(S &s, const unsigned /*version*/) {
51 debugSerializationBegin("SgAsmCilMetadataRoot");
52 s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilNode);
53 s & BOOST_SERIALIZATION_NVP(p_Signature);
54 s & BOOST_SERIALIZATION_NVP(p_MajorVersion);
55 s & BOOST_SERIALIZATION_NVP(p_MinorVersion);
56 s & BOOST_SERIALIZATION_NVP(p_Reserved0);
57 s & BOOST_SERIALIZATION_NVP(p_Length);
58 s & BOOST_SERIALIZATION_NVP(p_Version);
59 s & BOOST_SERIALIZATION_NVP(p_VersionPadding);
60 s & BOOST_SERIALIZATION_NVP(p_Flags);
61 s & BOOST_SERIALIZATION_NVP(p_NumberOfStreams);
62 s & BOOST_SERIALIZATION_NVP(p_Streams);
63 s & BOOST_SERIALIZATION_NVP(p_ErrorFree);
64 debugSerializationEnd("SgAsmCilMetadataRoot");
65 }
66#endif // ROSE_ENABLE_BOOST_SERIALIZATION
67
68public:
72 uint32_t const& get_Signature() const;
73 void set_Signature(uint32_t const&);
76public:
80 uint16_t const& get_MajorVersion() const;
81 void set_MajorVersion(uint16_t const&);
84public:
88 uint16_t const& get_MinorVersion() const;
89 void set_MinorVersion(uint16_t const&);
92public:
96 uint32_t const& get_Reserved0() const;
97 void set_Reserved0(uint32_t const&);
100public:
104 uint32_t const& get_Length() const;
105 void set_Length(uint32_t const&);
108public:
112 std::string const& get_Version() const;
113 void set_Version(std::string const&);
116public:
120 uint32_t const& get_VersionPadding() const;
121 void set_VersionPadding(uint32_t const&);
124public:
128 uint16_t const& get_Flags() const;
129 void set_Flags(uint16_t const&);
132public:
136 uint16_t const& get_NumberOfStreams() const;
137 void set_NumberOfStreams(uint16_t const&);
140public:
144 std::vector<SgAsmCilDataStream*> const& get_Streams() const;
145 std::vector<SgAsmCilDataStream*>& get_Streams();
148public:
152 bool const& get_ErrorFree() const;
153 void set_ErrorFree(bool const&);
155private:
158 mutable int8_t idxStringHeap = -1;
159 mutable int8_t idxBlobHeap = -1;
160 mutable int8_t idxUsHeap = -1;
161 mutable int8_t idxGuidHeap = -1;
162 mutable int8_t idxMetadataHeap = -1;
165public:
168 static constexpr uint32_t MAGIC_SIGNATURE = 0x424A5342;
169
173 void parse();
174
180 void parse(const std::vector<uint8_t>& buf, size_t index);
181
183 void unparse(std::ostream& f) const;
184
186 void unparse(std::vector<uint8_t>&, std::size_t) const;
187
189 void dump(std::ostream& os) const;
190
194 SgAsmCilUint8Heap* get_StringHeap() const;
195 SgAsmCilUint8Heap* get_BlobHeap() const;
196 SgAsmCilUint8Heap* get_UsHeap() const;
197 SgAsmCilUint32Heap* get_GuidHeap() const;
198 SgAsmCilMetadataHeap* get_MetadataHeap() const;
200public:
202 virtual ~SgAsmCilMetadataRoot();
203
204public:
207
208protected:
216
217
218// End of memberFunctionString
219// Start of memberFunctionString
220/* #line 1 "/workspace/src/ROSETTA/Grammar/Common.code" */
221
222// *** COMMON CODE SECTION BEGINS HERE ***
223
224 public:
225
226 // DQ (3/25/3006): I put this back in because it had the logic for where the copy function required
227 // and not required which is required to match the other aspects of the copy mechanism code generation.
228 // Specifically it is a problem to declare the copy function everywhere because it is not implemented
229 // for the SgSymbol IR nodes. I'm not clear why it is not implemented for these IR nodes.
230 /* \brief Copies AST (whole subtree, depending on the SgCopyHelp class */
231 // virtual SgNode* copy ( const SgCopyHelp & help) const;
232
234 virtual std::string class_name() const override;
235
237 virtual VariantT variantT() const override; // MS: new variant used in tree traversal
238
240 // King84 (2010.08.16): Moved this to an enum to save space, since it's only used at compiler-time anyway.
241 // static const VariantT static_variant = V_SgAsmCilMetadataRoot;
242 enum { static_variant = V_SgAsmCilMetadataRoot };
243
244 /* the generated cast function */
246 ROSE_DLL_API friend SgAsmCilMetadataRoot* isSgAsmCilMetadataRoot( SgNode * s );
247
249 ROSE_DLL_API friend const SgAsmCilMetadataRoot* isSgAsmCilMetadataRoot( const SgNode * s );
250
251 // ******************************************
252 // * Memory Pool / New / Delete
253 // ******************************************
254
255 public:
257 static const unsigned pool_size; //
259 static std::vector<unsigned char *> pools; //
261 static SgAsmCilMetadataRoot * next_node; //
262
264 static unsigned long initializeStorageClassArray(SgAsmCilMetadataRootStorageClass *); //
265
267 static void clearMemoryPool(); //
268 static void deleteMemoryPool(); //
269
271 static void extendMemoryPoolForFileIO(); //
272
274 static SgAsmCilMetadataRoot * getPointerFromGlobalIndex(unsigned long); //
276 static SgAsmCilMetadataRoot * getPointerFromGlobalIndex(AstSpecificDataManagingClass *, unsigned long); //
277
279 static unsigned long getNumberOfValidNodesAndSetGlobalIndexInFreepointer(unsigned long); //
281 static void resetValidFreepointers(); //
283 static unsigned long getNumberOfLastValidPointer(); //
284
285
286#if defined(INLINE_FUNCTIONS)
288 inline void *operator new (size_t size);
289#else
291 void *operator new (size_t size);
292#endif
294 void operator delete (void* pointer, size_t size);
295
296 // DQ (4/5/2007): This is not the correct operator that we want, but appears to be required to compile ROSE with ROSE.
297 void operator delete (void* pointer)
298 {
299 // This is the generated delete operator...
300 SgAsmCilMetadataRoot::operator delete (pointer,sizeof(SgAsmCilMetadataRoot));
301 }
302
304 static size_t numberOfNodes();
305
307 static size_t memoryUsage();
308
309 // End of scope which started in IR nodes specific code
310 /* */
311
312 /* name Internal Functions
313 \brief Internal functions ... incomplete-documentation
314
315 These functions have been made public as part of the design, but they are suggested for internal use
316 or by particularly knowledgeable users for specialized tools or applications.
317
318 \internal We could not make these private because they are required by user for special purposes. And
319 it would be unwieldy to have many of the internal classes in ROSE be explicitly defined as friends.
320
321 */
322
323 // MS: 02/12/02 container of pointers to AST successor nodes used in the traversal
324 // overridden in every class by *generated* implementation
326 virtual std::vector<SgNode*> get_traversalSuccessorContainer() const override;
327 // MS: 06/28/02 container of names of variables or container indices
328 // used used in the traversal to access AST successor nodes
329 // overridden in every class by *generated* implementation
332 virtual std::vector<std::string> get_traversalSuccessorNamesContainer() const override;
333
334 // GB (09/25/2007): Functions for index-based access to traversal successors; these are hopefully a lot faster
335 // than all the vector copies. The implementation for these functions is generated for each class.
337 virtual size_t get_numberOfTraversalSuccessors() const override;
339 virtual SgNode *get_traversalSuccessorByIndex(size_t idx) const override;
341 virtual size_t get_childIndex(SgNode *child) const override;
342
343#ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
344 // MS: 08/16/2002 method for generating RTI information
346 virtual RTIReturnType roseRTI() override;
347#endif
348 /* */
349
350
351
352 /* name Deprecated Functions
353 \brief Deprecated functions ... incomplete-documentation
354
355 These functions have been deprecated from use.
356 */
357 /* */
358
360 virtual const char* sage_class_name() const override ROSE_DEPRECATED_FUNCTION;
361
362 // JJW (10/16/2008): Changed to a single function in Node.code, and put
363 // getVariant() in #if 0 block to prevent confusing Doxygen
364#if 0
366 virtual int variant() const ROSE_DEPRECATED_FUNCTION;
368 // virtual int getVariant() const ROSE_DEPRECATED_FUNCTION;
369#endif
370 /* */
371
372
373
374
375 public:
376 /* name Traversal Support Functions
377 \brief Traversal support functions ... incomplete-documentation
378
379 These functions have been made public as part of the design, but they are suggested for internal use
380 or by particularly knowledgable users for specialized tools or applications.
381 */
382 /* */
383
384 // DQ (11/26/2005): Support for visitor pattern mechanims
385 // (inferior to ROSE traversal mechanism, experimental).
389
390 /* DXN (08/09/2010): support for the classic visitor pattern done in GoF */
392 virtual void accept (ROSE_VisitorPattern & visitor) override;
393
394 // DQ (12/26/2005): Support for traversal based on the memory pool
397 static void traverseMemoryPoolNodes(ROSE_VisitTraversal & visit);
398
402
403 // DQ (2/9/2006): Added to support traversal over single representative of each IR node
404 // This traversal helps support internal tools that call static member functions.
405 // note: this function operates on the memory pools.
408 static void visitRepresentativeNode (ROSE_VisitTraversal & visit);
409 /* */
410
411 public:
412 /* NodeId support functions */
414 static SgNode* getNodeByNodeId(VariantT variantT, size_t poolIdx, size_t itemIdx);
417 static SgAsmCilMetadataRoot* getNodeByNodeIdInternal(size_t poolIdx, size_t itemIdx);
420 static std::string getNodeIdString(SgAsmCilMetadataRoot* sgnode);
421 static std::string getNodeIdStringInternal(SgAsmCilMetadataRoot* sgnode);
422
423 public:
424 /* name Memory Allocation Functions
425 \brief Memory allocations functions ... incomplete-documentation
426
427 These functions have been made public as part of the design, but they are suggested for internal use
428 or by particularly knowledgable users for specialized tools or applications.
429 */
430 /* */
431
442 virtual bool isInMemoryPool() override;
443
454 virtual void checkDataMemberPointersIfInMemoryPool() override;
455
456 // DQ (4/30/2006): Modified to be a const function.
471 virtual std::vector<std::pair<SgNode*,std::string> > returnDataMemberPointers() const override;
472
483
495 virtual long getChildIndex( SgNode* childNode ) const override;
496
497 // DQ (9/2/2015): Since this function is generated by ROSETTA, we can't define the
498 // comment here (changed to be a C style comment and not be a doxygen comment).
499 /* \brief Constructor for use by AST File I/O Mechanism
500
501 This constructor permits the IR node to be rebuilt from the contiguously arranged data in memory
502 which obtained via fast binary file I/O from disk.
503 */
504 // SgAsmCilMetadataRoot( SgAsmCilMetadataRootStorageClass& source );
505
506
507
508
509
510 // JH (10/24/2005): methods added to support the ast file IO
511 private:
512
513 /* name AST Memory Allocation Support Functions
514 \brief Memory allocations support....
515
516 These functions handle the low leve support of the memory allocation scheme which permits IR nodes to be allocated
517 in large contiguous blocks to reduce memory fragmentation, improve performance, support specialized access (AST traversals),
518 and support the AST File I/O Mechanism.
519 */
520 /* */
521
522 /* JH (10/24/2005): Two typedefs. The TestType notes the type every pointer is cast to before
523 we compare them. Since I had several problems with this, I decided to make a typdef to ensure
524 that I use the same type everywhere, if any changes are made. THe second one declares the type
525 (actually unsigned long) where teh pointer address gets converted to. On 64 bit platforms this
526 might got changed, but unfortunatly, the return types are still unsigned longs. There exists
527 a correspinding one in the AST_FILE_IO class!
528 */
529 // DQ (9/2/2015): This typedef is no longer used, we can't define the
530 // comment here (changed to be a C style comment and not be a doxygen comment).
531 /* \brief Typedef used for low level memory access.
532 */
533 // typedef unsigned char* TestType;
534
535 // DQ (9/2/2015): This typedef is no longer used, we can't define the
536 // comment here (changed to be a C style comment and not be a doxygen comment).
537 /* \brief Typedef used to hold memory addresses as values.
538 */
539 // typedef unsigned long AddressType;
540
541
542
543 // necessary, to have direct access to the p_freepointer and the private methods !
545 friend class AST_FILE_IO;
546
548 friend class SgAsmCilMetadataRootStorageClass;
549
551 friend class AstSpecificDataManagingClass;
552
554 friend class AstSpecificDataManagingClassStorageClass;
555 public:
557 SgAsmCilMetadataRoot( const SgAsmCilMetadataRootStorageClass& source );
558
559 // private: // JJW hack
560 /*
561 name AST Memory Allocation Support Variables
562 Memory allocations support variables
563
564 These variables handle the low level support of the memory allocation scheme which permits IR nodes to be allocated
565 in large contiguous blocks to reduce memory fragmentation, improve performance, support specialized access (AST traversals),
566 and support the AST File I/O Mechanism.
567 */
568 /* */
569
570 public:
571
572 // DQ (11/21/2009): Added function to add new Regular Expression attributes and return pointer
573 // to current node (so that it will work cleanly with build functions to specify patterns).
574 // virtual SgNode* addRegExpAttribute();
581
582#ifndef _MSC_VER
583// Rasmussen (04/17/2019): Support for ATerms has been deprecated as it is no longer needed
584// and likely never fully implemented nor tested. Files remain in the src tree but are no
585// longer built.
586#define BUILD_ATERM_SUPPORT 0
587 #if BUILD_ATERM_SUPPORT
588 #ifdef ROSE_USE_ROSE_ATERM_SUPPORT
589 // DQ (10/4/2014): Adding ATerm support to ROSE.
599 // Rasmussen (1/7/2019): Added override to kill warning messages of overridden virtual function
600 virtual ATerm generate_ATerm() override;
601
603 virtual void generate_ATerm_Annotation(ATerm & term) override;
604 #endif
605 #endif // BUILD_ATERM_SUPPORT
606#endif
607 // These can't be virtual functions since we don't yet know what IR node to build (until we have read the aterm).
608 // virtual generate_AST(ATerm & term);
609 // virtual void read_ATerm_Annotation(ATerm & term);
610
611// *** COMMON CODE SECTION ENDS HERE ***
612
613
614// End of memberFunctionString
615// Start of memberFunctionString
616/* #line 726 "/workspace/src/ROSETTA/Grammar/Node.code" */
617
618 // the generated cast function
619 // friend ROSE_DLL_API SgAsmCilMetadataRoot* isSgAsmCilMetadataRoot ( SgNode* s );
620
621 typedef SgAsmCilNode base_node_type;
622
623
624// End of memberFunctionString
625
626
627
628
629
630
631
632
633
634
635
636
637 protected:
638// Start of memberFunctionString
639uint32_t p_Signature;
640
641// End of memberFunctionString
642// Start of memberFunctionString
643uint16_t p_MajorVersion;
644
645// End of memberFunctionString
646// Start of memberFunctionString
647uint16_t p_MinorVersion;
648
649// End of memberFunctionString
650// Start of memberFunctionString
651uint32_t p_Reserved0;
652
653// End of memberFunctionString
654// Start of memberFunctionString
655uint32_t p_Length;
656
657// End of memberFunctionString
658// Start of memberFunctionString
659std::string p_Version;
660
661// End of memberFunctionString
662// Start of memberFunctionString
663uint32_t p_VersionPadding;
664
665// End of memberFunctionString
666// Start of memberFunctionString
667uint16_t p_Flags;
668
669// End of memberFunctionString
670// Start of memberFunctionString
671uint16_t p_NumberOfStreams;
672
673// End of memberFunctionString
674// Start of memberFunctionString
675std::vector<SgAsmCilDataStream*> p_Streams;
676
677// End of memberFunctionString
678// Start of memberFunctionString
679bool p_ErrorFree;
680
681// End of memberFunctionString
682
684 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataRoot, uint32_t,&SgAsmCilMetadataRoot::p_Signature>;
685 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataRoot, uint16_t,&SgAsmCilMetadataRoot::p_MajorVersion>;
686 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataRoot, uint16_t,&SgAsmCilMetadataRoot::p_MinorVersion>;
687 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataRoot, uint32_t,&SgAsmCilMetadataRoot::p_Reserved0>;
688 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataRoot, uint32_t,&SgAsmCilMetadataRoot::p_Length>;
689 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataRoot, std::string,&SgAsmCilMetadataRoot::p_Version>;
690 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataRoot, uint32_t,&SgAsmCilMetadataRoot::p_VersionPadding>;
691 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataRoot, uint16_t,&SgAsmCilMetadataRoot::p_Flags>;
692 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataRoot, uint16_t,&SgAsmCilMetadataRoot::p_NumberOfStreams>;
693 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataRoot, std::vector<SgAsmCilDataStream*>,&SgAsmCilMetadataRoot::p_Streams>;
694 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataRoot, bool,&SgAsmCilMetadataRoot::p_ErrorFree>;
695
696/* #line 21 "/workspace/src/ROSETTA/Grammar/grammarClassDeclarationMacros.macro" */
697
698
699 };
700#endif
701
702// postdeclarations for SgAsmCilMetadataRoot
703
704/* #line 705 "../../../src/frontend/SageIII//SgAsmCilMetadataRoot.h" */
705
706/* #line 27 "/workspace/src/ROSETTA/Grammar/grammarClassDeclarationMacros.macro after subst for $POSTDECLARATIONS" */
707
708/* #line 28 "/workspace/src/ROSETTA/Grammar/grammarClassDeclarationMacros.macro" */
709
710
711/* #line 712 "../../../src/frontend/SageIII//SgAsmCilMetadataRoot.h" */
712
713#endif // ROSE_SgAsmCilMetadataRoot_H
714
Class holding static data and functions supporting File I/O.
Definition AST_FILE_IO.h:19
Attribute containing a regex expression as a string.
CIL SgAsmCilMetadataHeap node.
CIL SgAsmCilMetadataRoot.
Base class for CIL branch of binary analysis IR nodes.
void initializeProperties()
Initialize all properties that have explicit initial values.
Base class for CIL branch of binary analysis IR nodes.
Base class for CIL branch of binary analysis IR nodes.
Supporting class from copy mechanism within ROSE.
Definition sageCopy.h:26
This class represents the base class for all IR nodes within Sage III.
virtual RTIReturnType roseRTI()
return C++ Runtime-Time-Information
virtual size_t get_numberOfTraversalSuccessors() const
return number of children in the traversal successor list
virtual std::vector< std::string > get_traversalSuccessorNamesContainer() const
container of names of variables or container indices used used in the traversal to access AST success...
virtual void debugSerializationEnd(const char *className)
Called by generated serializers.
static std::string getNodeIdString(SgNode *sgnode)
compute the NodeId for a particular SgNode*.
virtual bool isInMemoryPool()
FOR INTERNAL USE This is used in internal tests to verify that all IR nodes are allocated from the he...
int variant() const
Older version function returns enum value "NODE".
virtual void processDataMemberReferenceToPointers(ReferenceToPointerHandler *)
FOR INTERNAL USE Processes pairs of references to SgNode* and strings for use in AST tools
virtual size_t get_childIndex(SgNode *child) const
index-based access to traversal successors by child node
virtual std::vector< SgNode * > get_traversalSuccessorContainer() const
container of pointers to AST successor nodes used in the traversal overridden in every class by gener...
virtual VariantT variantT() const
returns new style SageIII enum values
virtual long getChildIndex(SgNode *childNode) const
FOR INTERNAL USE Returns a unique index value for the childNode in the list of children at this IR no...
virtual void debugSerializationBegin(const char *className)
Called by generated serializers.
virtual SgNode * get_traversalSuccessorByIndex(size_t idx) const
index-based access to traversal successors by index number
virtual std::string class_name() const
returns a string representing the class name
static void visitRepresentativeNode(ROSE_VisitTraversal &visit)
FOR INTERNAL USE Support for type-based traversal.
virtual void checkDataMemberPointersIfInMemoryPool()
FOR INTERNAL USE This is used in internal tests to verify that all IR nodes are allocated from the he...
static size_t numberOfNodes()
Returns the total number of IR nodes of this type.
virtual void accept(ROSE_VisitorPattern &visitor)
support for the classic visitor pattern done in GoF
static void traverseMemoryPoolVisitorPattern(ROSE_VisitorPattern &visitor)
FOR INTERNAL USE Support for visitor pattern.
void executeVisitorMemberFunction(ROSE_VisitorPattern &visitor)
FOR INTERNAL USE Support for visitor pattern.
static SgNode * getNodeByNodeId(VariantT variantT, size_t poolIdx, size_t itemIdx)
Find a node by its variant type, pool index, and item index.
static size_t memoryUsage()
Returns the size in bytes of the total memory allocated for all IR nodes of this type.
static void traverseMemoryPoolNodes(ROSE_VisitTraversal &visit)
FOR INTERNAL USE Support for visitor pattern over all IR nodes by type of IR node.
virtual const char * sage_class_name() const
generates string representing the class name: (e.g. for SgNode returns "SgNode").
virtual std::vector< std::pair< SgNode *, std::string > > returnDataMemberPointers() const
FOR INTERNAL USE Returns STL vector of pairs of SgNode* and strings for use in AST tools
static SgNode * getNodeByNodeIdInternal(size_t poolIdx, size_t itemIdx)
FOR INTERNAL USE Find an SgNode from its memory pool and location therin.
SgNode * addRegExpAttribute(std::string s, AstRegExAttribute *a)
Support for AST matching using regular expression.
void parse(SgAsmGenericFile *)
Main function to parse DWARF information.
void serialize(std::ostream &output, Graph &graph)
Serialize a graph into a stream of bytes.
void copy(const Word *src, const BitRange &srcRange, Word *dst, const BitRange &dstRange)
Copy some bits.